yepanywhere 0.5.2 → 0.6.0

package/dist/routes/settings.js

@@ -1,14 +1,76 @@
 /**
  * Server settings API routes
  */
-import { ALL_PERMISSION_MODES, ALL_PROVIDERS, HELPER_SIDE_MODEL_CHEAPEST, HELPER_SIDE_MODEL_SAME_AS_MAIN, PROMPT_SUGGESTION_MODES, RECAP_MODES, normalizeYaClientBaseUrl, normalizeYaClientBaseUrlFromShareViewerUrl, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
+import { ALL_PERMISSION_MODES, ALL_PROVIDERS, HELPER_SIDE_MODEL_CHEAPEST, HELPER_SIDE_MODEL_SAME_AS_MAIN, normalizeYaClientBaseUrl, normalizeYaClientBaseUrlFromShareViewerUrl, DEFAULT_CACHE_MISS_BILLING_SETTINGS, DEFAULT_PROJECT_QUEUE_QUIET_SECONDS, DEFAULT_PROMPT_CACHE_KEEPALIVE_INACTIVITY_MINUTES, MAX_PROJECT_QUEUE_QUIET_SECONDS, PROMPT_CACHE_KEEPALIVE_MODES, PROMPT_SUGGESTION_MODES, RECAP_MODES, clampRecapAfterSeconds, clampProjectQueueQuietSeconds, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
 import { Hono } from "hono";
+import { getFileAccessInfo, normalizeFileAccess, } from "../middleware/file-access.js";
 import { testSSHConnection } from "../sdk/remote-spawn.js";
 import { CODEX_UPDATE_POLICIES, DEFAULT_SERVER_SETTINGS, DEFAULT_SPEECH_AUDIO_RETENTION_MAX_AGE_DAYS, DEFAULT_SPEECH_AUDIO_RETENTION_MAX_BYTES, } from "../services/ServerSettingsService.js";
 import { isValidSshHostAlias, normalizeSshHostAlias, } from "../utils/sshHostAlias.js";
 const HELPER_TARGET_ID_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
 const MAX_HELPER_TARGETS = 20;
 const HELPER_TARGET_MODEL_DISCOVERY_TIMEOUT_MS = 5000;
+const SESSION_TOOLBAR_PRESENCE_CLIENT_DEFAULT_KEYS = [
+    "modeSelector",
+    "steerNow",
+    "attachments",
+    "slashMenu",
+    "thinkingToggle",
+    "renderMode",
+    "microphone",
+    "waveform",
+    "shortcutsHelp",
+    "contextUsage",
+    "btw",
+    "nudge",
+    "sessionStatus",
+    "projectQueue",
+];
+const TOOLBAR_CONTROL_PRESENCES = [
+    "hidden",
+    "pin",
+    "last",
+    "mid",
+    "first",
+];
+const CLIENT_DEFAULT_KEYS = [
+    "speech",
+    "busyComposerDefaultAction",
+    "collapsedComposerButton",
+    "sessionToolbarPresence",
+    "steerNowDefault",
+    "patientQueueDefault",
+    "projectQueueCtrlEnterEnabled",
+    "compactAtContextPercent",
+];
+const BUSY_COMPOSER_DEFAULT_ACTIONS = [
+    "steer",
+    "queue",
+];
+const COLLAPSED_COMPOSER_BUTTON_PREFERENCES = [
+    "primary",
+    "alternate",
+    "microphone",
+];
+const SPEECH_CLIENT_DEFAULT_KEYS = [
+    "voiceInputEnabled",
+    "speechMethod",
+    "speechSmartTurnSettings",
+    "grokSpeechAudioSettings",
+];
+const THINKING_MODES = [
+    "off",
+    "auto",
+    "on",
+];
+const EFFORT_LEVELS = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+const MAX_SPEECH_SMART_TURN_TIMEOUT_MS = 10000;
 function parseHostAliasList(rawHosts) {
     const hosts = [];
     for (const rawHost of rawHosts) {
@@ -93,6 +155,120 @@ function parseHelperTargets(raw) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
+function parseOptionalString(value, maxLength) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value !== "string")
+        return null;
+    return value.length > 0 ? value.slice(0, maxLength) : undefined;
+}
+function parseProviderSessionDefaults(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const parsed = {};
+    if ("model" in raw) {
+        const model = parseOptionalString(raw.model, 200);
+        if (model === null)
+            return null;
+        if (model)
+            parsed.model = model;
+    }
+    if ("serviceTier" in raw) {
+        const serviceTier = parseOptionalString(raw.serviceTier, 64);
+        if (serviceTier === null)
+            return null;
+        if (serviceTier)
+            parsed.serviceTier = serviceTier;
+    }
+    if ("thinkingMode" in raw) {
+        if (raw.thinkingMode !== undefined &&
+            raw.thinkingMode !== null &&
+            raw.thinkingMode !== "" &&
+            !THINKING_MODES.includes(raw.thinkingMode)) {
+            return null;
+        }
+        if (typeof raw.thinkingMode === "string" && raw.thinkingMode.length > 0) {
+            parsed.thinkingMode = raw.thinkingMode;
+        }
+    }
+    if ("effortLevel" in raw) {
+        if (raw.effortLevel !== undefined &&
+            raw.effortLevel !== null &&
+            raw.effortLevel !== "" &&
+            !EFFORT_LEVELS.includes(raw.effortLevel)) {
+            return null;
+        }
+        if (typeof raw.effortLevel === "string" && raw.effortLevel.length > 0) {
+            parsed.effortLevel = raw.effortLevel;
+        }
+    }
+    if ("helperSideModel" in raw) {
+        const helperSideModel = parseOptionalString(raw.helperSideModel, 200);
+        if (helperSideModel === null)
+            return null;
+        if (helperSideModel) {
+            parsed.helperSideModel =
+                helperSideModel === HELPER_SIDE_MODEL_SAME_AS_MAIN
+                    ? HELPER_SIDE_MODEL_SAME_AS_MAIN
+                    : helperSideModel === HELPER_SIDE_MODEL_CHEAPEST
+                        ? HELPER_SIDE_MODEL_CHEAPEST
+                        : helperSideModel;
+        }
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+const MAX_FILE_ACCESS_CUSTOM_ENTRIES = 100;
+const MAX_FILE_ACCESS_CUSTOM_LENGTH = 1024;
+/**
+ * Returns:
+ * - `null` when the payload is invalid
+ * - `undefined` when the setting should be cleared (reset to secure defaults)
+ * - a normalized object when valid
+ */
+function parseFileAccess(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const allowedKeys = new Set([
+        "projects",
+        "uploads",
+        "temp",
+        "home",
+        "custom",
+    ]);
+    for (const key of Object.keys(raw)) {
+        if (!allowedKeys.has(key))
+            return null;
+    }
+    for (const key of ["projects", "uploads", "temp", "home"]) {
+        if (key in raw && typeof raw[key] !== "boolean")
+            return null;
+    }
+    if ("custom" in raw) {
+        if (!Array.isArray(raw.custom) ||
+            raw.custom.length > MAX_FILE_ACCESS_CUSTOM_ENTRIES) {
+            return null;
+        }
+        for (const entry of raw.custom) {
+            if (typeof entry !== "string" ||
+                entry.length > MAX_FILE_ACCESS_CUSTOM_LENGTH) {
+                return null;
+            }
+        }
+    }
+    return normalizeFileAccess({
+        projects: raw.projects,
+        uploads: raw.uploads,
+        temp: raw.temp,
+        home: raw.home,
+        custom: raw.custom ?? [],
+    });
+}
 function parseOpenAiModelsResponse(raw) {
     if (!isRecord(raw) || !Array.isArray(raw.data))
         return null;
@@ -120,6 +296,19 @@ function parseOpenAiModelsResponse(raw) {
     }
     return models;
 }
+function parseAgentContextHints(raw, current) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (!isRecord(raw))
+        return null;
+    const parsed = { ...current };
+    if ("latexMathRendering" in raw) {
+        if (typeof raw.latexMathRendering !== "boolean")
+            return null;
+        parsed.latexMathRendering = raw.latexMathRendering;
+    }
+    return parsed;
+}
 async function discoverOpenAiCompatibleModels(baseUrl) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), HELPER_TARGET_MODEL_DISCOVERY_TIMEOUT_MS);
@@ -165,15 +354,18 @@ function parseNewSessionDefaults(raw) {
         }
     }
     if ("model" in input) {
-        if (input.model !== undefined &&
-            input.model !== null &&
-            input.model !== "" &&
-            typeof input.model !== "string") {
+        const model = parseOptionalString(input.model, 200);
+        if (model === null)
             return null;
-        }
-        if (typeof input.model === "string" && input.model.length > 0) {
-            parsed.model = input.model;
-        }
+        if (model)
+            parsed.model = model;
+    }
+    if ("serviceTier" in input) {
+        const serviceTier = parseOptionalString(input.serviceTier, 64);
+        if (serviceTier === null)
+            return null;
+        if (serviceTier)
+            parsed.serviceTier = serviceTier;
     }
     if ("permissionMode" in input) {
         if (input.permissionMode !== undefined &&
@@ -198,6 +390,19 @@ function parseNewSessionDefaults(raw) {
             parsed.recapMode = input.recapMode;
         }
     }
+    if ("recapAfterSeconds" in input) {
+        if (input.recapAfterSeconds !== undefined &&
+            input.recapAfterSeconds !== null &&
+            input.recapAfterSeconds !== "" &&
+            (typeof input.recapAfterSeconds !== "number" ||
+                !Number.isFinite(input.recapAfterSeconds))) {
+            return null;
+        }
+        if (typeof input.recapAfterSeconds === "number" &&
+            Number.isFinite(input.recapAfterSeconds)) {
+            parsed.recapAfterSeconds = clampRecapAfterSeconds(input.recapAfterSeconds);
+        }
+    }
     if ("promptSuggestionMode" in input) {
         if (input.promptSuggestionMode !== undefined &&
             input.promptSuggestionMode !== null &&
@@ -211,25 +416,316 @@ function parseNewSessionDefaults(raw) {
                 input.promptSuggestionMode;
         }
     }
-    if ("helperSideModel" in input) {
-        if (input.helperSideModel !== undefined &&
-            input.helperSideModel !== null &&
-            input.helperSideModel !== "" &&
-            typeof input.helperSideModel !== "string") {
+    if ("providers" in input) {
+        if (input.providers !== undefined &&
+            input.providers !== null &&
+            input.providers !== "" &&
+            !isRecord(input.providers)) {
             return null;
         }
-        if (typeof input.helperSideModel === "string" &&
-            input.helperSideModel.length > 0) {
-            parsed.helperSideModel =
-                input.helperSideModel === HELPER_SIDE_MODEL_SAME_AS_MAIN
-                    ? HELPER_SIDE_MODEL_SAME_AS_MAIN
-                    : input.helperSideModel === HELPER_SIDE_MODEL_CHEAPEST
-                        ? HELPER_SIDE_MODEL_CHEAPEST
-                        : input.helperSideModel.slice(0, 200);
+        if (isRecord(input.providers)) {
+            const providers = {};
+            for (const [providerName, rawDefaults] of Object.entries(input.providers)) {
+                if (!ALL_PROVIDERS.includes(providerName)) {
+                    return null;
+                }
+                const parsedProviderDefaults = parseProviderSessionDefaults(rawDefaults);
+                if (parsedProviderDefaults === null)
+                    return null;
+                if (parsedProviderDefaults) {
+                    providers[providerName] = parsedProviderDefaults;
+                }
+            }
+            if (Object.keys(providers).length > 0) {
+                parsed.providers = providers;
+            }
+        }
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+function parseSpeechSmartTurnClientDefault(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (typeof raw.enabled !== "boolean" ||
+        typeof raw.threshold !== "number" ||
+        typeof raw.timeoutMs !== "number" ||
+        !Number.isFinite(raw.threshold) ||
+        !Number.isFinite(raw.timeoutMs) ||
+        raw.threshold < 0 ||
+        raw.threshold > 1 ||
+        raw.timeoutMs < 0 ||
+        raw.timeoutMs > MAX_SPEECH_SMART_TURN_TIMEOUT_MS) {
+        return null;
+    }
+    return {
+        enabled: raw.enabled,
+        threshold: raw.threshold,
+        timeoutMs: Math.round(raw.timeoutMs),
+    };
+}
+function parseGrokSpeechAudioClientDefault(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (raw.uplinkMode !== "pcm16" && raw.uplinkMode !== "browser-compressed") {
+        return null;
+    }
+    return { uplinkMode: raw.uplinkMode };
+}
+function parseSessionToolbarPresenceClientDefaults(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const allowedKeys = new Set(SESSION_TOOLBAR_PRESENCE_CLIENT_DEFAULT_KEYS);
+    for (const key of Object.keys(raw)) {
+        if (!allowedKeys.has(key))
+            return null;
+    }
+    const allowedPresences = new Set(TOOLBAR_CONTROL_PRESENCES);
+    const parsed = {};
+    for (const key of SESSION_TOOLBAR_PRESENCE_CLIENT_DEFAULT_KEYS) {
+        if (!(key in raw))
+            continue;
+        const value = raw[key];
+        if (typeof value !== "string" || !allowedPresences.has(value))
+            return null;
+        parsed[key] = value;
+    }
+    return Object.keys(parsed).length > 0 ? parsed : null;
+}
+// Per-model compaction thresholds: each value is "compact at X% of that
+// model's context window". Reject non-numbers (the slider only ever sends
+// numbers), but treat out-of-range like the load path does — keep 1–99 and
+// drop anything else (including >= 100 = "off"). An empty result clears the
+// setting. The returned map is authoritative: the client always sends the
+// full map, so mergeClientDefaults replaces rather than per-model merges,
+// which is what makes turning a model "off" (dropping its key) take effect.
+function parseCompactAtContextPercent(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const cleaned = {};
+    for (const [modelId, value] of Object.entries(raw)) {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            return null;
+        const pct = Math.round(value);
+        if (pct > 0 && pct < 100)
+            cleaned[modelId] = pct;
+    }
+    return Object.keys(cleaned).length > 0 ? cleaned : undefined;
+}
+function parseClientDefaults(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const allowedKeys = new Set(CLIENT_DEFAULT_KEYS);
+    for (const key of Object.keys(raw)) {
+        if (!allowedKeys.has(key))
+            return null;
+    }
+    if (Object.keys(raw).length === 0)
+        return null;
+    const parsed = {};
+    if ("speech" in raw) {
+        if (raw.speech === undefined || raw.speech === null || raw.speech === "") {
+            parsed.speech = undefined;
+        }
+        else if (!isRecord(raw.speech)) {
+            return null;
+        }
+        else {
+            const allowedSpeechKeys = new Set(SPEECH_CLIENT_DEFAULT_KEYS);
+            for (const key of Object.keys(raw.speech)) {
+                if (!allowedSpeechKeys.has(key))
+                    return null;
+            }
+            const speech = {};
+            if ("voiceInputEnabled" in raw.speech) {
+                if (typeof raw.speech.voiceInputEnabled !== "boolean")
+                    return null;
+                speech.voiceInputEnabled = raw.speech.voiceInputEnabled;
+            }
+            if ("speechMethod" in raw.speech) {
+                if (typeof raw.speech.speechMethod !== "string" ||
+                    raw.speech.speechMethod.trim().length === 0) {
+                    return null;
+                }
+                speech.speechMethod = raw.speech.speechMethod.trim().slice(0, 120);
+            }
+            if ("speechSmartTurnSettings" in raw.speech) {
+                const parsedSmartTurn = parseSpeechSmartTurnClientDefault(raw.speech.speechSmartTurnSettings);
+                if (!parsedSmartTurn)
+                    return null;
+                speech.speechSmartTurnSettings = parsedSmartTurn;
+            }
+            if ("grokSpeechAudioSettings" in raw.speech) {
+                const parsedGrokAudio = parseGrokSpeechAudioClientDefault(raw.speech.grokSpeechAudioSettings);
+                if (!parsedGrokAudio)
+                    return null;
+                speech.grokSpeechAudioSettings = parsedGrokAudio;
+            }
+            if (Object.keys(speech).length === 0)
+                return null;
+            parsed.speech = speech;
+        }
+    }
+    if ("busyComposerDefaultAction" in raw) {
+        if (raw.busyComposerDefaultAction === undefined ||
+            raw.busyComposerDefaultAction === null) {
+            parsed.busyComposerDefaultAction = undefined;
+        }
+        else if (!BUSY_COMPOSER_DEFAULT_ACTIONS.includes(raw.busyComposerDefaultAction)) {
+            return null;
+        }
+        else {
+            parsed.busyComposerDefaultAction =
+                raw.busyComposerDefaultAction;
+        }
+    }
+    if ("collapsedComposerButton" in raw) {
+        if (raw.collapsedComposerButton === undefined ||
+            raw.collapsedComposerButton === null) {
+            parsed.collapsedComposerButton = undefined;
+        }
+        else if (!COLLAPSED_COMPOSER_BUTTON_PREFERENCES.includes(raw.collapsedComposerButton)) {
+            return null;
+        }
+        else {
+            parsed.collapsedComposerButton =
+                raw.collapsedComposerButton;
+        }
+    }
+    if ("steerNowDefault" in raw) {
+        if (raw.steerNowDefault === undefined || raw.steerNowDefault === null) {
+            parsed.steerNowDefault = undefined;
+        }
+        else if (typeof raw.steerNowDefault !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.steerNowDefault = raw.steerNowDefault;
         }
     }
+    if ("patientQueueDefault" in raw) {
+        if (raw.patientQueueDefault === undefined ||
+            raw.patientQueueDefault === null) {
+            parsed.patientQueueDefault = undefined;
+        }
+        else if (typeof raw.patientQueueDefault !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.patientQueueDefault = raw.patientQueueDefault;
+        }
+    }
+    if ("projectQueueCtrlEnterEnabled" in raw) {
+        if (raw.projectQueueCtrlEnterEnabled === undefined ||
+            raw.projectQueueCtrlEnterEnabled === null) {
+            parsed.projectQueueCtrlEnterEnabled = undefined;
+        }
+        else if (typeof raw.projectQueueCtrlEnterEnabled !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.projectQueueCtrlEnterEnabled = raw.projectQueueCtrlEnterEnabled;
+        }
+    }
+    if ("sessionToolbarPresence" in raw) {
+        const parsedPresence = parseSessionToolbarPresenceClientDefaults(raw.sessionToolbarPresence);
+        if (parsedPresence === null)
+            return null;
+        parsed.sessionToolbarPresence = parsedPresence;
+    }
+    if ("compactAtContextPercent" in raw) {
+        const parsedCompact = parseCompactAtContextPercent(raw.compactAtContextPercent);
+        if (parsedCompact === null)
+            return null;
+        parsed.compactAtContextPercent = parsedCompact;
+    }
     return Object.keys(parsed).length > 0 ? parsed : undefined;
 }
+function mergeClientDefaults(current, update) {
+    if (!update)
+        return undefined;
+    const merged = { ...current };
+    if ("speech" in update) {
+        if (update.speech === undefined) {
+            delete merged.speech;
+        }
+        else {
+            merged.speech = {
+                ...current?.speech,
+                ...update.speech,
+            };
+        }
+    }
+    if ("busyComposerDefaultAction" in update) {
+        if (update.busyComposerDefaultAction === undefined) {
+            delete merged.busyComposerDefaultAction;
+        }
+        else {
+            merged.busyComposerDefaultAction = update.busyComposerDefaultAction;
+        }
+    }
+    if ("collapsedComposerButton" in update) {
+        if (update.collapsedComposerButton === undefined) {
+            delete merged.collapsedComposerButton;
+        }
+        else {
+            merged.collapsedComposerButton = update.collapsedComposerButton;
+        }
+    }
+    if ("steerNowDefault" in update) {
+        if (update.steerNowDefault === undefined) {
+            delete merged.steerNowDefault;
+        }
+        else {
+            merged.steerNowDefault = update.steerNowDefault;
+        }
+    }
+    if ("patientQueueDefault" in update) {
+        if (update.patientQueueDefault === undefined) {
+            delete merged.patientQueueDefault;
+        }
+        else {
+            merged.patientQueueDefault = update.patientQueueDefault;
+        }
+    }
+    if ("projectQueueCtrlEnterEnabled" in update) {
+        if (update.projectQueueCtrlEnterEnabled === undefined) {
+            delete merged.projectQueueCtrlEnterEnabled;
+        }
+        else {
+            merged.projectQueueCtrlEnterEnabled = update.projectQueueCtrlEnterEnabled;
+        }
+    }
+    if ("sessionToolbarPresence" in update) {
+        if (update.sessionToolbarPresence === undefined) {
+            delete merged.sessionToolbarPresence;
+        }
+        else {
+            merged.sessionToolbarPresence = {
+                ...current?.sessionToolbarPresence,
+                ...update.sessionToolbarPresence,
+            };
+        }
+    }
+    if ("compactAtContextPercent" in update) {
+        // Replace the whole map (not a per-model merge): the client always sends
+        // the complete map, so a model dropped from it means "off" for that model.
+        if (update.compactAtContextPercent === undefined) {
+            delete merged.compactAtContextPercent;
+        }
+        else {
+            merged.compactAtContextPercent = update.compactAtContextPercent;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
 function parseSpeechAudioRetention(raw) {
     if (raw === undefined || raw === null) {
         return DEFAULT_SERVER_SETTINGS.speechAudioRetention;
@@ -259,9 +755,152 @@ function parseSpeechAudioRetention(raw) {
     }
     return { enabled, maxAgeDays, maxBytes };
 }
+function parsePromptCacheKeepalive(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return undefined;
+    if (!isRecord(raw))
+        return null;
+    const rawProviders = raw.providers;
+    if (rawProviders === undefined || rawProviders === null)
+        return {};
+    if (!isRecord(rawProviders))
+        return null;
+    const providers = {};
+    for (const [providerName, rawProviderSetting] of Object.entries(rawProviders)) {
+        if (!ALL_PROVIDERS.includes(providerName))
+            return null;
+        if (rawProviderSetting === undefined || rawProviderSetting === null) {
+            continue;
+        }
+        if (!isRecord(rawProviderSetting))
+            return null;
+        const setting = {};
+        if ("mode" in rawProviderSetting) {
+            if (typeof rawProviderSetting.mode !== "string" ||
+                !PROMPT_CACHE_KEEPALIVE_MODES.includes(rawProviderSetting.mode)) {
+                return null;
+            }
+            setting.mode = rawProviderSetting.mode;
+        }
+        if ("inactivityMinutes" in rawProviderSetting) {
+            const value = rawProviderSetting.inactivityMinutes;
+            if (typeof value !== "number" ||
+                !Number.isInteger(value) ||
+                value < 1 ||
+                value > 1440) {
+                return null;
+            }
+            setting.inactivityMinutes = value;
+        }
+        if (Object.keys(setting).length > 0) {
+            providers[providerName] = setting;
+        }
+    }
+    return { providers };
+}
+function parseCacheMissBilling(raw) {
+    if (raw === undefined)
+        return null;
+    if (raw === null || raw === "")
+        return DEFAULT_CACHE_MISS_BILLING_SETTINGS;
+    if (!isRecord(raw))
+        return null;
+    const parsed = {};
+    if ("enabled" in raw) {
+        if (raw.enabled === undefined || raw.enabled === null) {
+            parsed.enabled = DEFAULT_CACHE_MISS_BILLING_SETTINGS.enabled;
+        }
+        else if (typeof raw.enabled !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.enabled = raw.enabled;
+        }
+    }
+    if ("showToasts" in raw) {
+        if (raw.showToasts === undefined || raw.showToasts === null) {
+            parsed.showToasts = DEFAULT_CACHE_MISS_BILLING_SETTINGS.showToasts;
+        }
+        else if (typeof raw.showToasts !== "boolean") {
+            return null;
+        }
+        else {
+            parsed.showToasts = raw.showToasts;
+        }
+    }
+    if ("freshWindowMinutes" in raw) {
+        if (raw.freshWindowMinutes === undefined ||
+            raw.freshWindowMinutes === null) {
+            parsed.freshWindowMinutes =
+                DEFAULT_CACHE_MISS_BILLING_SETTINGS.freshWindowMinutes;
+        }
+        else if (typeof raw.freshWindowMinutes !== "number" ||
+            !Number.isInteger(raw.freshWindowMinutes) ||
+            raw.freshWindowMinutes < 1 ||
+            raw.freshWindowMinutes > 1440) {
+            return null;
+        }
+        else {
+            parsed.freshWindowMinutes = raw.freshWindowMinutes;
+        }
+    }
+    if ("providerFreshWindowMinutes" in raw) {
+        if (raw.providerFreshWindowMinutes === undefined ||
+            raw.providerFreshWindowMinutes === null) {
+            parsed.providerFreshWindowMinutes =
+                DEFAULT_CACHE_MISS_BILLING_SETTINGS.providerFreshWindowMinutes;
+        }
+        else if (!isRecord(raw.providerFreshWindowMinutes)) {
+            return null;
+        }
+        else {
+            const providerFreshWindowMinutes = {};
+            for (const [providerName, value] of Object.entries(raw.providerFreshWindowMinutes)) {
+                if (!ALL_PROVIDERS.includes(providerName)) {
+                    return null;
+                }
+                if (typeof value !== "number" ||
+                    !Number.isInteger(value) ||
+                    value < 1 ||
+                    value > 1440) {
+                    return null;
+                }
+                providerFreshWindowMinutes[providerName] = value;
+            }
+            parsed.providerFreshWindowMinutes = providerFreshWindowMinutes;
+        }
+    }
+    if ("minimumInputTokens" in raw) {
+        if (raw.minimumInputTokens === undefined ||
+            raw.minimumInputTokens === null) {
+            parsed.minimumInputTokens =
+                DEFAULT_CACHE_MISS_BILLING_SETTINGS.minimumInputTokens;
+        }
+        else if (typeof raw.minimumInputTokens !== "number" ||
+            !Number.isInteger(raw.minimumInputTokens) ||
+            raw.minimumInputTokens < 1 ||
+            raw.minimumInputTokens > 5_000_000) {
+            return null;
+        }
+        else {
+            parsed.minimumInputTokens = raw.minimumInputTokens;
+        }
+    }
+    const result = {
+        ...DEFAULT_CACHE_MISS_BILLING_SETTINGS,
+        ...parsed,
+        providerFreshWindowMinutes: {
+            ...DEFAULT_CACHE_MISS_BILLING_SETTINGS.providerFreshWindowMinutes,
+            ...parsed.providerFreshWindowMinutes,
+        },
+    };
+    return result;
+}
 export function createSettingsRoutes(deps) {
     const app = new Hono();
-    const { serverSettingsService, onAllowedHostsChanged, onRemoteSessionPersistenceChanged, onOllamaUrlChanged, onOllamaSystemPromptChanged, onOllamaUseFullSystemPromptChanged, onGrokBuildUseXaiApiKeyChanged, publicShareService, } = deps;
+    const { serverSettingsService, sessionMetadataService, onAllowedHostsChanged, onFileAccessChanged, onRemoteSessionPersistenceChanged, onOllamaUrlChanged, onOllamaSystemPromptChanged, onOllamaUseFullSystemPromptChanged, onGrokBuildUseXaiApiKeyChanged, publicShareService, } = deps;
     /**
      * GET /api/settings
      * Get all server settings
@@ -270,6 +909,27 @@ export function createSettingsRoutes(deps) {
         const settings = serverSettingsService.getSettings();
         return c.json({ settings });
     });
+    /**
+     * GET /api/settings/cache-miss-billing/events
+     * Read the server-stored prompt-cache billing evidence log.
+     */
+    app.get("/cache-miss-billing/events", (c) => {
+        const rawLimit = Number(c.req.query("limit") ?? 200);
+        const limit = Number.isFinite(rawLimit) && rawLimit > 0
+            ? Math.min(Math.floor(rawLimit), 500)
+            : 200;
+        return c.json({
+            events: sessionMetadataService?.getCacheMissBillingEvents(limit) ?? [],
+        });
+    });
+    /**
+     * GET /api/settings/file-access
+     * Read-only info for the File access settings UI: whether an env var pins
+     * the allow-set, plus the resolved temp/uploads/home prefixes for hints.
+     */
+    app.get("/file-access", (c) => {
+        return c.json(getFileAccessInfo());
+    });
     /**
      * PUT /api/settings
      * Update server settings
@@ -287,9 +947,53 @@ export function createSettingsRoutes(deps) {
         if (typeof body.clientLogCollectionRequested === "boolean") {
             updates.clientLogCollectionRequested = body.clientLogCollectionRequested;
         }
+        if (typeof body.approvalAuditLogEnabled === "boolean") {
+            updates.approvalAuditLogEnabled = body.approvalAuditLogEnabled;
+        }
         if (typeof body.publicSharesEnabled === "boolean") {
             updates.publicSharesEnabled = body.publicSharesEnabled;
         }
+        if (typeof body.workstreamsEnabled === "boolean") {
+            updates.workstreamsEnabled = body.workstreamsEnabled;
+        }
+        if (typeof body.composeAnchorsEnabled === "boolean") {
+            updates.composeAnchorsEnabled = body.composeAnchorsEnabled;
+        }
+        if ("deferredJoinWindowSeconds" in body) {
+            if (body.deferredJoinWindowSeconds === undefined ||
+                body.deferredJoinWindowSeconds === null) {
+                updates.deferredJoinWindowSeconds = undefined;
+            }
+            else if (typeof body.deferredJoinWindowSeconds === "number" &&
+                Number.isFinite(body.deferredJoinWindowSeconds) &&
+                body.deferredJoinWindowSeconds >= 0) {
+                updates.deferredJoinWindowSeconds = body.deferredJoinWindowSeconds;
+            }
+            else {
+                return c.json({
+                    error: "deferredJoinWindowSeconds must be a non-negative number of seconds (0 = never join)",
+                }, 400);
+            }
+        }
+        if ("projectQueueQuietSeconds" in body) {
+            if (body.projectQueueQuietSeconds === undefined ||
+                body.projectQueueQuietSeconds === null) {
+                updates.projectQueueQuietSeconds = DEFAULT_PROJECT_QUEUE_QUIET_SECONDS;
+            }
+            else if (typeof body.projectQueueQuietSeconds === "number" &&
+                Number.isFinite(body.projectQueueQuietSeconds) &&
+                body.projectQueueQuietSeconds >= 0 &&
+                body.projectQueueQuietSeconds <= MAX_PROJECT_QUEUE_QUIET_SECONDS) {
+                updates.projectQueueQuietSeconds =
+                    clampProjectQueueQuietSeconds(body.projectQueueQuietSeconds) ??
+                        DEFAULT_PROJECT_QUEUE_QUIET_SECONDS;
+            }
+            else {
+                return c.json({
+                    error: `projectQueueQuietSeconds must be a number of seconds from 0 to ${MAX_PROJECT_QUEUE_QUIET_SECONDS}`,
+                }, 400);
+            }
+        }
         if ("yaClientBaseUrl" in body) {
             if (body.yaClientBaseUrl === undefined ||
                 body.yaClientBaseUrl === null ||
@@ -363,6 +1067,14 @@ export function createSettingsRoutes(deps) {
                 updates.allowedHosts = body.allowedHosts;
             }
         }
+        // Handle fileAccess object (checkbox model; undefined/null/"" = secure defaults)
+        if ("fileAccess" in body) {
+            const parsed = parseFileAccess(body.fileAccess);
+            if (parsed === null) {
+                return c.json({ error: "Invalid fileAccess setting" }, 400);
+            }
+            updates.fileAccess = parsed;
+        }
         // Handle globalInstructions string (free-form text, or undefined/null/"" to clear)
         if ("globalInstructions" in body) {
             if (body.globalInstructions === undefined ||
@@ -374,6 +1086,13 @@ export function createSettingsRoutes(deps) {
                 updates.globalInstructions = body.globalInstructions.slice(0, 10000);
             }
         }
+        if ("agentContextHints" in body) {
+            const parsedHints = parseAgentContextHints(body.agentContextHints, serverSettingsService.getSetting("agentContextHints"));
+            if (parsedHints === null) {
+                return c.json({ error: "Invalid agentContextHints setting" }, 400);
+            }
+            updates.agentContextHints = parsedHints;
+        }
         if ("heartbeatTurnsAfterMinutes" in body) {
             if (body.heartbeatTurnsAfterMinutes === undefined ||
                 body.heartbeatTurnsAfterMinutes === null) {
@@ -442,6 +1161,13 @@ export function createSettingsRoutes(deps) {
             }
             updates.newSessionDefaults = parsedDefaults;
         }
+        if ("clientDefaults" in body) {
+            const parsedDefaults = parseClientDefaults(body.clientDefaults);
+            if (parsedDefaults === null) {
+                return c.json({ error: "Invalid clientDefaults setting" }, 400);
+            }
+            updates.clientDefaults = mergeClientDefaults(serverSettingsService.getSetting("clientDefaults"), parsedDefaults);
+        }
         if ("speechAudioRetention" in body) {
             const parsedRetention = parseSpeechAudioRetention(body.speechAudioRetention);
             if (parsedRetention === null) {
@@ -456,6 +1182,24 @@ export function createSettingsRoutes(deps) {
             }
             updates.helperTargets = parsedTargets;
         }
+        if ("promptCacheKeepalive" in body) {
+            const parsedKeepalive = parsePromptCacheKeepalive(body.promptCacheKeepalive);
+            if (parsedKeepalive === null) {
+                return c.json({
+                    error: `promptCacheKeepalive must configure provider modes (${PROMPT_CACHE_KEEPALIVE_MODES.join(", ")}) and integer inactivityMinutes between 1 and 1440 (default ${DEFAULT_PROMPT_CACHE_KEEPALIVE_INACTIVITY_MINUTES})`,
+                }, 400);
+            }
+            updates.promptCacheKeepalive = parsedKeepalive;
+        }
+        if ("cacheMissBilling" in body) {
+            const parsedCacheMissBilling = parseCacheMissBilling(body.cacheMissBilling);
+            if (parsedCacheMissBilling === null) {
+                return c.json({
+                    error: "cacheMissBilling must use booleans for enabled/showToasts, freshness windows 1-1440, and minimumInputTokens 1-5000000",
+                }, 400);
+            }
+            updates.cacheMissBilling = parsedCacheMissBilling;
+        }
         if (typeof body.lifecycleWebhooksEnabled === "boolean") {
             updates.lifecycleWebhooksEnabled = body.lifecycleWebhooksEnabled;
         }
@@ -503,6 +1247,9 @@ export function createSettingsRoutes(deps) {
         if ("allowedHosts" in updates && onAllowedHostsChanged) {
             onAllowedHostsChanged(settings.allowedHosts);
         }
+        if ("fileAccess" in updates && onFileAccessChanged) {
+            onFileAccessChanged(settings.fileAccess);
+        }
         if ("persistRemoteSessionsToDisk" in updates &&
             onRemoteSessionPersistenceChanged) {
             await onRemoteSessionPersistenceChanged(settings.persistRemoteSessionsToDisk);
@@ -517,8 +1264,7 @@ export function createSettingsRoutes(deps) {
             onOllamaUseFullSystemPromptChanged) {
             onOllamaUseFullSystemPromptChanged(settings.ollamaUseFullSystemPrompt ?? false);
         }
-        if ("grokBuildUseXaiApiKey" in updates &&
-            onGrokBuildUseXaiApiKeyChanged) {
+        if ("grokBuildUseXaiApiKey" in updates && onGrokBuildUseXaiApiKeyChanged) {
             onGrokBuildUseXaiApiKeyChanged(settings.grokBuildUseXaiApiKey ?? false);
         }
         if (updates.publicSharesEnabled === false && publicShareService) {