auq-mcp-server 2.3.0 → 2.5.0

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

@@ -0,0 +1,300 @@
+/**
+ * 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";
+import { SessionManager } from "../../session/SessionManager.js";
+import { getSessionDirectory } from "../../session/utils.js";
+import { loadConfig } from "../../config/ConfigLoader.js";
+import { formatAge, outputResult, parseFlags, resolveArchiveDirectory, } from "../utils.js";
+async function sessionsList(args) {
+    const { flags } = parseFlags(args);
+    const jsonMode = flags.json === true;
+    const filterStale = flags.stale === true;
+    const filterAll = flags.all === true;
+    // --pending is same as default
+    // Initialise SessionManager
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // Load staleThreshold from config
+    const config = loadConfig();
+    const staleThreshold = config.staleThreshold ?? 7200000;
+    // Get all session IDs
+    const sessionIds = await sessionManager.getAllSessionIds();
+    // Build entries
+    const entries = [];
+    for (const sessionId of sessionIds) {
+        const status = await sessionManager.getSessionStatus(sessionId);
+        if (!status)
+            continue;
+        const createdAt = status.createdAt;
+        const ageMs = Date.now() - new Date(createdAt).getTime();
+        const stale = ageMs > staleThreshold;
+        const age = formatAge(createdAt);
+        const isPending = status.status === "pending" || status.status === "in-progress";
+        // Apply filter
+        if (filterAll) {
+            // Show all statuses
+        }
+        else if (filterStale) {
+            // Only stale sessions that are pending/in-progress
+            if (!isPending || !stale)
+                continue;
+        }
+        else {
+            // Default / --pending: only pending/in-progress
+            if (!isPending)
+                continue;
+        }
+        const request = await sessionManager.getSessionRequest(sessionId);
+        const questionCount = request?.questions?.length ?? status.totalQuestions ?? 0;
+        entries.push({
+            sessionId,
+            status: status.status,
+            createdAt,
+            age,
+            stale,
+            questionCount,
+        });
+    }
+    // Sort by createdAt descending (newest first)
+    entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    // Output
+    if (jsonMode) {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    if (entries.length === 0) {
+        console.log("No sessions found.");
+        return;
+    }
+    for (const entry of entries) {
+        const staleIndicator = entry.stale ? " ⚠" : "";
+        console.log(`${entry.sessionId}  ${entry.status}  ${entry.age}  questions: ${entry.questionCount}${staleIndicator}`);
+    }
+}
+// ── Sessions Dismiss ───────────────────────────────────────────────
+async function sessionsDismiss(args) {
+    const { flags, positionals } = parseFlags(args);
+    const jsonMode = flags.json === true;
+    const force = flags.force === true;
+    const sessionId = positionals[0];
+    // ── Validate sessionId ──────────────────────────────────────────
+    if (!sessionId) {
+        outputResult({
+            success: false,
+            error: "Missing session ID. Usage: auq sessions dismiss <sessionId> [--force] [--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;
+    }
+    // ── Check stale status ─────────────────────────────────────────
+    const status = await sessionManager.getSessionStatus(sessionId);
+    const config = loadConfig();
+    const staleThreshold = config.staleThreshold ?? 7200000;
+    const ageMs = status
+        ? Date.now() - new Date(status.createdAt).getTime()
+        : 0;
+    const isStale = ageMs > staleThreshold;
+    if (!isStale && !force) {
+        outputResult({
+            success: false,
+            error: "Session is not stale. Use --force to dismiss anyway.",
+        }, jsonMode);
+        process.exitCode = 1;
+        return;
+    }
+    // ── Archive session ────────────────────────────────────────────
+    const archiveBase = resolveArchiveDirectory();
+    const archiveDir = join(archiveBase, sessionId);
+    await fs.mkdir(archiveDir, { recursive: true });
+    // Copy all files from session directory to archive
+    const sessionDir = join(getSessionDirectory(), sessionId);
+    const files = await fs.readdir(sessionDir);
+    for (const file of files) {
+        await fs.copyFile(join(sessionDir, file), join(archiveDir, file));
+    }
+    // ── Remove from active ─────────────────────────────────────────
+    await sessionManager.deleteSession(sessionId);
+    // ── Output ──────────────────────────────────────────────────────
+    outputResult({ success: true, sessionId, archivedTo: archiveDir }, jsonMode);
+    if (!jsonMode) {
+        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) {
+                process.exitCode = 1;
+            }
+            break;
+    }
+}

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/cli/utils.js

@@ -0,0 +1,95 @@
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Parse CLI flags from an args array.
+ * Handles --flag (boolean) and --flag value patterns.
+ * Everything not starting with -- goes to positionals.
+ */
+export function parseFlags(args) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i++; // skip next arg — it was consumed as a value
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positionals.push(arg);
+        }
+    }
+    return { flags, positionals };
+}
+/**
+ * Standard CLI output helper.
+ * - jsonMode: console.log(JSON.stringify(result, null, 2))
+ * - else: human-readable formatted output
+ */
+export function outputResult(result, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.success) {
+        const message = typeof result.error === "string"
+            ? result.error
+            : typeof result.message === "string"
+                ? result.message
+                : "Unknown error";
+        console.error(`Error: ${message}`);
+        return;
+    }
+    // Human-readable: print each key=value pair (skip success)
+    for (const [key, value] of Object.entries(result)) {
+        if (key === "success")
+            continue;
+        if (typeof value === "object" && value !== null) {
+            console.log(`${key}:`);
+            for (const [subKey, subValue] of Object.entries(value)) {
+                console.log(`  ${subKey} = ${String(subValue)}`);
+            }
+        }
+        else {
+            console.log(`${key} = ${String(value)}`);
+        }
+    }
+}
+/**
+ * Format age from a timestamp to a human-readable string.
+ * Returns "Xm ago", "Xh ago", "Xd ago", etc.
+ */
+export function formatAge(createdAt) {
+    const now = Date.now();
+    const then = createdAt instanceof Date
+        ? createdAt.getTime()
+        : new Date(createdAt).getTime();
+    const diffMs = now - then;
+    if (diffMs < 0)
+        return "just now";
+    const seconds = Math.floor(diffMs / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ago`;
+    if (hours > 0)
+        return `${hours}h ago`;
+    if (minutes > 0)
+        return `${minutes}m ago`;
+    return `${seconds}s ago`;
+}
+/**
+ * Resolve the archive directory for dismissed sessions.
+ * Uses the XDG data home standard: ~/.local/share/auq/archive
+ */
+export function resolveArchiveDirectory() {
+    const xdgDataHome = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+    return join(xdgDataHome, "auq", "archive");
+}

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

@@ -91,4 +91,45 @@ describe("ConfigLoader", () => {
             expect(paths.globalExists).toBe(true);
         });
     });
+    describe("stale/orphan session config options", () => {
+        it("should include stale config defaults when no config files exist", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const config = loadConfig();
+            expect(config.staleThreshold).toBe(7200000);
+            expect(config.notifyOnStale).toBe(true);
+            expect(config.staleAction).toBe("warn");
+        });
+        it("should load staleThreshold from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ staleThreshold: 3600000 }));
+            const config = loadConfig();
+            expect(config.staleThreshold).toBe(3600000);
+        });
+        it("should load staleAction from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ staleAction: "archive" }));
+            const config = loadConfig();
+            expect(config.staleAction).toBe("archive");
+        });
+        it("should load notifyOnStale from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ notifyOnStale: false }));
+            const config = loadConfig();
+            expect(config.notifyOnStale).toBe(false);
+        });
+        it("should fall back to default for invalid staleAction value", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ staleAction: "invalid_action" }));
+            const config = loadConfig();
+            // Invalid enum value should be ignored, default used
+            expect(config.staleAction).toBe(DEFAULT_CONFIG.staleAction);
+        });
+        it("should reject negative staleThreshold value", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ staleThreshold: -1000 }));
+            const config = loadConfig();
+            // Negative value should be rejected by min(0), default used
+            expect(config.staleThreshold).toBe(DEFAULT_CONFIG.staleThreshold);
+        });
+    });
 });

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

@@ -8,8 +8,13 @@ export const DEFAULT_CONFIG = {
     language: "auto",
     theme: "system",
     autoSelectRecommended: true,
+    staleThreshold: 7200000, // 2 hours in ms
+    notifyOnStale: true,
+    staleAction: "warn",
     notifications: {
         enabled: true,
         sound: true,
     },
+    // Update
+    updateCheck: true,
 };

package/dist/src/config/types.js

@@ -21,9 +21,15 @@ export const AUQConfigSchema = z.object({
     language: z.string().default("auto"),
     theme: z.string().default("system"),
     autoSelectRecommended: z.boolean().default(true),
+    // Stale/Orphan Session Detection
+    staleThreshold: z.number().min(0).default(7200000), // 2 hours in ms
+    notifyOnStale: z.boolean().default(true),
+    staleAction: z.enum(["warn", "remove", "archive"]).default("warn"),
     // Notifications (OSC 9/99)
     notifications: NotificationConfigSchema.default({
         enabled: true,
         sound: true,
     }),
+    // Update
+    updateCheck: z.boolean().default(true),
 });

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

@@ -22,14 +22,15 @@ export const createAskUserQuestionsCore = (options = {}) => {
         title: question.title,
         multiSelect: question.multiSelect,
     }));
-    const ask = async (questions, callId, workingDirectory) => {
+    const ask = async (questions, callId, workingDirectory, signal) => {
         await ensureInitialized();
         const parsedQuestions = QuestionsSchema.parse(questions);
-        return sessionManager.startSession(normalizeQuestions(parsedQuestions), callId, workingDirectory);
+        return sessionManager.startSession(normalizeQuestions(parsedQuestions), callId, workingDirectory, signal);
     };
     return {
         ask,
         cleanupExpiredSessions: () => sessionManager.cleanupExpiredSessions(),
         ensureInitialized,
+        markAbandoned: (sessionId) => sessionManager.updateSessionStatus(sessionId, "abandoned"),
     };
 };

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

@@ -39,6 +39,7 @@ export const en = {
         copied: "Copied to clipboard",
         saved: "Saved",
         error: "Error",
+        staleSession: "Session \"{title}\" may be orphaned (created {hours}h ago)",
     },
     stepper: {
         submitting: "Submitting answers...",
@@ -72,4 +73,10 @@ export const en = {
     ui: {
         themeLabel: "theme:",
     },
+    abandoned: {
+        title: "AI Disconnected",
+        message: "The AI has disconnected. Do you still want to answer?",
+        continue: "Answer anyway",
+        cancel: "Cancel",
+    },
 };