auq-mcp-server 2.4.0 → 2.5.0

package/README.md

@@ -248,6 +248,7 @@ It is recommended to **disable** the built-in questioning tool in your harness (
 # you won't likely need these at all
 auq server       # Start MCP server
 auq --version    # Show version
+auq update       # Check for and install updates
 auq --help       # Show help
 ```
 
@@ -334,6 +335,43 @@ When an AI client disconnects, associated sessions are marked as "abandoned". Th
 
 ---
 
+### Auto-Update
+
+AUQ automatically checks for updates and keeps itself up to date.
+
+#### How it works
+
+- **Patch updates** (e.g., 2.4.0 → 2.4.1): Automatically installed when the TUI starts. These are bug fixes and minor improvements.
+- **Minor/Major updates** (e.g., 2.4.0 → 2.5.0 or 3.0.0): A fullscreen prompt is shown with changelog and options to update, skip, or defer.
+- **CLI notification**: When running non-TUI commands, a one-line update notification is shown if a newer version is available.
+
+#### Manual update
+
+Run `auq update` to manually check for and install updates:
+
+```bash
+auq update        # Interactive update check
+auq update -y     # Skip confirmation prompt
+```
+
+#### Disabling update checks
+
+Disable automatic update checks via config:
+
+```bash
+auq config set updateCheck false
+```
+
+Or set the environment variable:
+
+```bash
+NO_UPDATE_NOTIFIER=1 auq ask "question"
+```
+
+Update checks are automatically disabled in CI environments (`CI=true`).
+
+The `auq update` command always works regardless of these settings.
+
 ### 🎨 Themes
 
 AUQ supports **16 built-in color themes** with automatic persistence. Press `Ctrl+T` to cycle through themes.
@@ -518,6 +556,7 @@ _Settings from local config override global config, which overrides defaults._
   "language": "auto",
   "theme": "system",
   "autoSelectRecommended": true,
+  "updateCheck": true,
   "notifications": {
     "enabled": true,
     "sound": true
@@ -543,6 +582,7 @@ _Settings from local config override global config, which overrides defaults._
 | `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                             |
+| `updateCheck`           | boolean | true      | true/false                      | Enable automatic update checks on startup             |
 
 </details>
 

package/dist/bin/auq.js

@@ -20,6 +20,7 @@ Commands:
   answer <id> [flags]    Answer or reject a session
   sessions <sub> [flags] List/dismiss sessions
   config <sub> [flags]   Get/set configuration
+  update                 Check for and install updates
 
 Answer:
   auq answer <id> --answers '<json>'    Submit answers
@@ -28,6 +29,7 @@ Answer:
 
 Sessions:
   auq sessions list [--pending|--stale|--all] [--json]
+  auq sessions show <id> [--json]
   auq sessions dismiss <id> [--force] [--json]
 
 Config:
@@ -84,6 +86,40 @@ if (command === "server") {
     // Keep process alive
     await new Promise(() => { });
 }
+// Handle 'update' command
+if (command === "update") {
+    const { runUpdateCommand } = await import("../src/cli/commands/update.js");
+    await runUpdateCommand(args.slice(1));
+    process.exit(0);
+}
+// ── Fire-and-forget update notification ────────────────────────────
+// Start a non-blocking update check for non-TUI CLI commands.
+// The result is awaited briefly after the main command finishes.
+let updateNotification = null;
+if (command &&
+    !["server", "--help", "-h", "--version", "-v", "update"].includes(command)) {
+    updateNotification = (async () => {
+        try {
+            if (process.env.NO_UPDATE_NOTIFIER === "1" ||
+                process.env.CI === "true" ||
+                process.env.CI === "1" ||
+                process.env.NODE_ENV === "test")
+                return;
+            const { UpdateChecker } = await import("../src/update/index.js");
+            const checker = new UpdateChecker();
+            const result = await Promise.race([
+                checker.check(),
+                new Promise((r) => setTimeout(() => r(null), 5000)),
+            ]);
+            if (result) {
+                process.stderr.write(`Update available: ${result.currentVersion} \u2192 ${result.latestVersion}. Run \`auq update\` to upgrade.\n`);
+            }
+        }
+        catch {
+            // Silently ignore — update checks must never break the main command
+        }
+    })();
+}
 // Handle 'ask' command
 if (command === "ask") {
     const { SessionManager } = await import("../src/session/index.js");
@@ -143,6 +179,7 @@ if (command === "ask") {
         const callId = randomUUID();
         const { formattedResponse, sessionId } = await sessionManager.startSession(questions, callId, workingDirectory);
         console.log(formattedResponse);
+        await updateNotification;
         process.exit(0);
     }
     catch (error) {
@@ -160,18 +197,21 @@ if (command === "ask") {
 if (command === "answer") {
     const { runAnswerCommand } = await import("../src/cli/commands/answer.js");
     await runAnswerCommand(args.slice(1));
+    await updateNotification;
     process.exit(0);
 }
 // Handle 'sessions' command
 if (command === "sessions") {
     const { runSessionsCommand } = await import("../src/cli/commands/sessions.js");
     await runSessionsCommand(args.slice(1));
+    await updateNotification;
     process.exit(0);
 }
 // Handle 'config' command
 if (command === "config") {
     const { runConfigCommand } = await import("../src/cli/commands/config.js");
     await runConfigCommand(args.slice(1));
+    await updateNotification;
     process.exit(0);
 }
 // Default: Start TUI

package/dist/bin/tui-app.js

@@ -15,6 +15,8 @@ import { isSessionStale, isSessionAbandoned, formatStaleToastMessage, } from "..
 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 { UpdateChecker, fetchChangelog, installUpdate, detectPackageManager, readCache, writeCache, } from "../src/update/index.js";
+import { UpdateOverlay } from "../src/tui/components/UpdateOverlay.js";
 import { KEYS } from "../src/tui/constants/keybindings.js";
 const App = ({ config }) => {
     const [state, setState] = useState({ mode: "WAITING" });
@@ -29,6 +31,12 @@ const App = ({ config }) => {
     const [sessionMeta, setSessionMeta] = useState(new Map());
     const [lastInteractions, setLastInteractions] = useState(new Map());
     const [staleToastShown, setStaleToastShown] = useState(new Set());
+    const [updateInfo, setUpdateInfo] = useState(null);
+    const [showUpdateOverlay, setShowUpdateOverlay] = useState(false);
+    const [isInstallingUpdate, setIsInstallingUpdate] = useState(false);
+    const [installError, setInstallError] = useState(null);
+    const [changelogContent, setChangelogContent] = useState(null);
+    const [updateDismissed, setUpdateDismissed] = useState(false);
     // Get session directory for logging
     const sessionDir = getSessionDirectory();
     // Notification configuration from config
@@ -124,6 +132,45 @@ const App = ({ config }) => {
             clearProgress(notificationConfig);
         };
     }, [notificationConfig]);
+    // ── Auto-update checker ─────────────────────────────────────
+    useEffect(() => {
+        // Skip update checks if disabled
+        if (config?.updateCheck === false)
+            return;
+        if (process.env.NO_UPDATE_NOTIFIER === "1")
+            return;
+        if (process.env.CI === "true" || process.env.CI === "1")
+            return;
+        if (process.env.NODE_ENV === "test")
+            return;
+        if (!process.stdout.isTTY)
+            return;
+        const checker = new UpdateChecker();
+        let intervalId = null;
+        const runCheck = async () => {
+            try {
+                const result = await checker.check();
+                if (result) {
+                    setUpdateInfo(result);
+                    // Fetch changelog for the overlay
+                    const changelog = await fetchChangelog(result.latestVersion);
+                    setChangelogContent(changelog.content);
+                }
+            }
+            catch {
+                // Silently fail — update checks should never break the TUI
+            }
+        };
+        runCheck();
+        intervalId = setInterval(() => {
+            checker.clearCache();
+            runCheck();
+        }, 3600000); // 1 hour
+        return () => {
+            if (intervalId)
+                clearInterval(intervalId);
+        };
+    }, [config?.updateCheck]);
     // Auto-transition: WAITING → PROCESSING when queue has items
     useEffect(() => {
         if (!isInitialized)
@@ -282,6 +329,51 @@ const App = ({ config }) => {
     const handleFlowStateChange = useCallback((flowState) => {
         setIsInReviewOrRejection(flowState.showReview || flowState.showRejectionConfirm);
     }, []);
+    // ── Auto-update handlers ────────────────────────────────────
+    const handleUpdateInstall = async () => {
+        try {
+            setIsInstallingUpdate(true);
+            setInstallError(null);
+            const pm = detectPackageManager();
+            const success = await installUpdate(pm);
+            if (success) {
+                setShowUpdateOverlay(false);
+                setToast({
+                    message: `Updated to v${updateInfo.latestVersion}. Please restart auq.`,
+                    type: "success",
+                });
+                // Exit after short delay so user sees the message
+                setTimeout(() => process.exit(0), 2000);
+            }
+            else {
+                setInstallError("Installation failed. Please try manually.");
+            }
+            setIsInstallingUpdate(false);
+        }
+        catch (err) {
+            setIsInstallingUpdate(false);
+            setInstallError(err instanceof Error ? err.message : "Installation failed");
+        }
+    };
+    const handleSkipVersion = async () => {
+        if (updateInfo) {
+            try {
+                const cache = await readCache();
+                if (cache) {
+                    await writeCache({ ...cache, skippedVersion: updateInfo.latestVersion });
+                }
+            }
+            catch {
+                // Non-critical — skip-version simply won't persist
+            }
+        }
+        setShowUpdateOverlay(false);
+        setUpdateInfo(null);
+    };
+    const handleRemindLater = () => {
+        setShowUpdateOverlay(false);
+        setUpdateDismissed(true);
+    };
     const switchToSession = useCallback((targetIndex) => {
         if (state.mode !== "PROCESSING" || sessionQueue.length <= 1) {
             return;
@@ -343,8 +435,23 @@ const App = ({ config }) => {
         isActive: state.mode === "PROCESSING" &&
             !isInReviewOrRejection &&
             !showSessionPicker &&
+            !showUpdateOverlay &&
             sessionQueue.length >= 2,
     });
+    // Update overlay keyboard shortcut (independent of session count)
+    useInput((input, key) => {
+        if (!key.ctrl && !key.meta && input === KEYS.UPDATE) {
+            if (updateInfo && !showUpdateOverlay) {
+                setShowUpdateOverlay(true);
+            }
+        }
+    }, {
+        isActive: state.mode === "PROCESSING" &&
+            !isInReviewOrRejection &&
+            !showSessionPicker &&
+            !showUpdateOverlay &&
+            !!updateInfo,
+    });
     // Handle session completion
     const handleSessionComplete = (wasRejected = false, rejectionReason) => {
         // Clear progress bar on session completion
@@ -407,7 +514,12 @@ const App = ({ config }) => {
             React.createElement(Box, { flexDirection: "column", paddingX: 1 },
                 React.createElement(Header, { pendingCount: state.mode === "PROCESSING"
                         ? Math.max(0, sessionQueue.length - 1)
-                        : sessionQueue.length }),
+                        : sessionQueue.length, updateInfo: !showUpdateOverlay && updateInfo
+                        ? {
+                            updateType: updateInfo.updateType,
+                            latestVersion: updateInfo.latestVersion,
+                        }
+                        : null, onUpdateBadgeActivate: () => setShowUpdateOverlay(true) }),
                 mainContent,
                 state.mode === "PROCESSING" && sessionQueue.length >= 2 && (React.createElement(SessionDots, { sessions: sessionQueue.map((s) => ({
                         ...s,
@@ -428,6 +540,7 @@ const App = ({ config }) => {
                         switchToSession(idx);
                         setShowSessionPicker(false);
                     }, onClose: () => setShowSessionPicker(false) })),
+                showUpdateOverlay && updateInfo && (React.createElement(UpdateOverlay, { isOpen: showUpdateOverlay, currentVersion: updateInfo.currentVersion, latestVersion: updateInfo.latestVersion, updateType: updateInfo.updateType, changelog: changelogContent, changelogUrl: updateInfo.changelogUrl, isInstalling: isInstallingUpdate, installError: installError, onInstall: handleUpdateInstall, onSkipVersion: handleSkipVersion, onRemindLater: handleRemindLater })),
                 React.createElement(ThemeIndicator, null)))));
 };
 export const runTui = (config) => {

package/dist/package.json

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

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

@@ -1,6 +1,6 @@
 /**
- * CLI Sessions Command — `auq sessions list` and `auq sessions dismiss`
- * Manages listing and dismissing/archiving sessions.
+ * CLI Sessions Command — `auq sessions list`, `auq sessions show`, and `auq sessions dismiss`
+ * Manages listing, viewing, and dismissing/archiving sessions.
  */
 import { promises as fs } from "fs";
 import { join } from "path";
@@ -137,23 +137,159 @@ async function sessionsDismiss(args) {
         console.log(`Session ${sessionId} dismissed and archived to ${archiveDir}.`);
     }
 }
+// ── Sessions Show ─────────────────────────────────────────────────
+async function sessionsShow(args) {
+    const { flags, positionals } = parseFlags(args);
+    const jsonMode = flags.json === true;
+    const sessionId = positionals[0];
+    // ── Validate sessionId ──────────────────────────────────────────
+    if (!sessionId) {
+        outputResult({
+            success: false,
+            error: "Missing session ID. Usage: auq sessions show <sessionId> [--json]",
+        }, jsonMode);
+        process.exitCode = 1;
+        return;
+    }
+    // ── Initialise SessionManager ───────────────────────────────────
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // ── Verify session exists ──────────────────────────────────────
+    const exists = await sessionManager.sessionExists(sessionId);
+    if (!exists) {
+        outputResult({ success: false, error: `Session not found: ${sessionId}` }, jsonMode);
+        process.exitCode = 1;
+        return;
+    }
+    // ── Fetch session data ──────────────────────────────────────────
+    const status = await sessionManager.getSessionStatus(sessionId);
+    const request = await sessionManager.getSessionRequest(sessionId);
+    const answersData = await sessionManager.getSessionAnswers(sessionId);
+    if (!status || !request) {
+        outputResult({ success: false, error: `Could not read session data for: ${sessionId}` }, jsonMode);
+        process.exitCode = 1;
+        return;
+    }
+    const questions = request.questions;
+    const answers = answersData?.answers ?? null;
+    // ── Build answer lookup (questionIndex → UserAnswer) ────────────
+    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,
+            totalQuestions: questions.length,
+            questions: questions.map((q, i) => ({
+                index: i,
+                prompt: q.prompt,
+                title: q.title,
+                multiSelect: q.multiSelect ?? false,
+                options: q.options.map((o) => ({
+                    label: o.label,
+                    ...(o.description ? { description: o.description } : {}),
+                })),
+            })),
+            answers: answers
+                ? answers.map((a) => ({
+                    questionIndex: a.questionIndex,
+                    selectedOption: a.selectedOption ?? null,
+                    selectedOptions: a.selectedOptions ?? null,
+                    customText: a.customText ?? null,
+                    timestamp: a.timestamp,
+                }))
+                : null,
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // ── Human-readable output ───────────────────────────────────────
+    const age = formatAge(status.createdAt);
+    console.log(`Session: ${sessionId}`);
+    console.log(`Status: ${status.status} | Created: ${age}`);
+    console.log(`Questions: ${questions.length}`);
+    console.log("");
+    for (let i = 0; i < questions.length; i++) {
+        const q = questions[i];
+        const selectTag = q.multiSelect ? "[multi-select]" : "[single-select]";
+        const answer = answerMap.get(i);
+        // Determine which options are selected
+        const selectedLabels = new Set();
+        if (answer) {
+            if (answer.selectedOption)
+                selectedLabels.add(answer.selectedOption);
+            if (answer.selectedOptions) {
+                for (const opt of answer.selectedOptions)
+                    selectedLabels.add(opt);
+            }
+        }
+        console.log(`  ${i + 1}. ${q.prompt}  ${selectTag}`);
+        for (const opt of q.options) {
+            const prefix = selectedLabels.has(opt.label) ? "✓" : "→";
+            console.log(`     ${prefix} ${opt.label}`);
+            if (opt.description) {
+                console.log(`       ${opt.description}`);
+            }
+        }
+        // Show custom text if provided
+        if (answer?.customText) {
+            console.log(`     ✎ Custom: ${answer.customText}`);
+        }
+        console.log("");
+    }
+    // ── Answer summary ──────────────────────────────────────────────
+    if (answers && answers.length > 0) {
+        const summaryParts = [];
+        for (const a of answers) {
+            if (a.selectedOption) {
+                summaryParts.push(a.selectedOption);
+            }
+            else if (a.selectedOptions && a.selectedOptions.length > 0) {
+                summaryParts.push(a.selectedOptions.join(", "));
+            }
+            else if (a.customText) {
+                summaryParts.push(`"${a.customText}"`);
+            }
+        }
+        if (summaryParts.length > 0) {
+            console.log(`  (User answered: ${summaryParts.join(", ")})`);
+        }
+    }
+}
 // ── Sessions Command Dispatcher ────────────────────────────────────
 export async function runSessionsCommand(args) {
     const subcommand = args[0];
     switch (subcommand) {
         case "list":
             return sessionsList(args.slice(1));
+        case "show":
+            return sessionsShow(args.slice(1));
         case "dismiss":
             return sessionsDismiss(args.slice(1));
         default:
             console.log("Usage: auq sessions <subcommand>", "\n");
             console.log("Subcommands:");
             console.log("  list [--pending|--stale|--all] [--json]  List sessions");
+            console.log("  show <sessionId> [--json]                Show session details");
             console.log("  dismiss <sessionId> [--force] [--json]    Dismiss/archive a session");
             console.log("");
             console.log("Examples:");
             console.log("  auq sessions list");
             console.log("  auq sessions list --stale --json");
+            console.log("  auq sessions show <sessionId>");
+            console.log("  auq sessions show <sessionId> --json");
             console.log("  auq sessions dismiss <sessionId>");
             console.log("  auq sessions dismiss <sessionId> --force");
             if (subcommand !== undefined) {

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

@@ -0,0 +1,124 @@
+/**
+ * CLI Update Command — `auq update`
+ *
+ * Checks for available updates, displays changelog, and installs
+ * the latest version using the detected package manager.
+ */
+import { createInterface } from "node:readline";
+import { UpdateChecker } from "../../update/checker.js";
+import { fetchChangelog } from "../../update/changelog.js";
+import { detectPackageManager } from "../../update/package-manager.js";
+import { installUpdate, getManualCommand } from "../../update/installer.js";
+import { parseFlags } from "../utils.js";
+/**
+ * Prompt the user for input via readline.
+ *
+ * Uses stderr for the question text to keep stdout clean for piping.
+ */
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+/**
+ * Run the `auq update` command.
+ *
+ * Usage:
+ *   auq update           Check for updates and install interactively
+ *   auq update -y        Check and install without confirmation
+ *   auq update --yes     Same as -y
+ *   auq update --json    Output result as JSON
+ */
+export async function runUpdateCommand(args) {
+    const { flags } = parseFlags(args);
+    const jsonMode = flags.json === true;
+    // parseFlags only handles --flag; check raw args for short -y flag
+    const skipPrompt = flags.yes === true || args.includes("-y");
+    // 1. Check for updates (blocking, with status output)
+    process.stderr.write("Checking for updates...\n");
+    const checker = new UpdateChecker();
+    let result;
+    try {
+        result = await checker.check();
+    }
+    catch {
+        const msg = "Unable to check for updates. Please check your network connection.";
+        if (jsonMode) {
+            console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        }
+        else {
+            process.stderr.write(`\u274c ${msg}\n`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    // 2. If no update available
+    if (!result) {
+        const version = checker["currentVersion"];
+        const msg = `Already up to date (v${version})`;
+        if (jsonMode) {
+            console.log(JSON.stringify({ success: true, upToDate: true, currentVersion: version }, null, 2));
+        }
+        else {
+            process.stderr.write(`\u2714 ${msg}\n`);
+        }
+        return;
+    }
+    // 3. Display update info
+    process.stderr.write(`\nUpdate available: ${result.currentVersion} \u2192 ${result.latestVersion} (${result.updateType})\n`);
+    // 4. Fetch and display changelog
+    const changelog = await fetchChangelog(result.latestVersion);
+    if (changelog.content) {
+        process.stderr.write(`\nChangelog:\n${changelog.content}\n`);
+    }
+    else {
+        process.stderr.write(`\nView changelog: ${changelog.fallbackUrl}\n`);
+    }
+    // 5. Breaking change warning for major updates
+    if (result.updateType === "major") {
+        process.stderr.write("\n\u26a0  Breaking changes may be included in this major version update.\n");
+    }
+    // 6. Confirmation prompt (unless --yes/-y)
+    if (!skipPrompt) {
+        const answer = await prompt("\nInstall update? (Y/n): ");
+        const trimmed = answer.trim().toLowerCase();
+        if (trimmed !== "" && trimmed !== "y" && trimmed !== "yes") {
+            process.stderr.write("Update cancelled.\n");
+            return;
+        }
+    }
+    // 7. Detect package manager and show what will run
+    const pm = detectPackageManager();
+    const manualCmd = getManualCommand(pm);
+    process.stderr.write(`\nInstalling with ${pm.name}: ${manualCmd}\n`);
+    // 8. Execute installation
+    const success = await installUpdate(pm);
+    if (success) {
+        const msg = "Update complete! Please restart auq.";
+        if (jsonMode) {
+            console.log(JSON.stringify({
+                success: true,
+                upToDate: false,
+                previousVersion: result.currentVersion,
+                installedVersion: result.latestVersion,
+            }, null, 2));
+        }
+        else {
+            process.stderr.write(`\u2705 ${msg}\n`);
+        }
+    }
+    else {
+        const msg = `Update failed. Run manually: ${manualCmd}`;
+        if (jsonMode) {
+            console.log(JSON.stringify({ success: false, error: "Installation failed", manualCommand: manualCmd }, null, 2));
+        }
+        else {
+            process.stderr.write(`\u274c ${msg}\n`);
+        }
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { AUQConfigSchema } from "../types.js";
+import { DEFAULT_CONFIG } from "../defaults.js";
+describe("updateCheck config", () => {
+    it("DEFAULT_CONFIG includes updateCheck: true", () => {
+        expect(DEFAULT_CONFIG.updateCheck).toBe(true);
+    });
+    it("schema accepts updateCheck: true", () => {
+        const result = AUQConfigSchema.parse({ updateCheck: true });
+        expect(result.updateCheck).toBe(true);
+    });
+    it("schema accepts updateCheck: false", () => {
+        const result = AUQConfigSchema.parse({ updateCheck: false });
+        expect(result.updateCheck).toBe(false);
+    });
+    it("schema defaults updateCheck to true when missing", () => {
+        const result = AUQConfigSchema.parse({});
+        expect(result.updateCheck).toBe(true);
+    });
+    it("partial schema retains default for updateCheck when not provided", () => {
+        const result = AUQConfigSchema.partial().parse({ maxOptions: 8 });
+        // Zod .default(true) still applies even when field is omitted in partial parse
+        expect(result.updateCheck).toBe(true);
+    });
+    it("schema rejects non-boolean updateCheck", () => {
+        expect(() => AUQConfigSchema.parse({ updateCheck: "yes" })).toThrow();
+    });
+    it("updateCheck coexists with other config values", () => {
+        const result = AUQConfigSchema.parse({ updateCheck: false });
+        // Other defaults should still be set
+        expect(result.updateCheck).toBe(false);
+        expect(result.maxOptions).toBeDefined();
+    });
+});

package/dist/src/config/defaults.js

@@ -15,4 +15,6 @@ export const DEFAULT_CONFIG = {
         enabled: true,
         sound: true,
     },
+    // Update
+    updateCheck: true,
 };

package/dist/src/config/types.js

@@ -30,4 +30,6 @@ export const AUQConfigSchema = z.object({
         enabled: true,
         sound: true,
     }),
+    // Update
+    updateCheck: z.boolean().default(true),
 });