openmates 0.12.0 → 0.12.1

package/dist/{chunk-UGEZLQKN.js → chunk-PHFCP5AM.js}

@@ -986,14 +986,14 @@ var OpenMatesWsClient = class {
     });
   }
   async open(timeoutMs = 1e4) {
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const timeout = setTimeout(
         () => reject(new Error("WebSocket open timeout")),
         timeoutMs
       );
       this.socket.once("open", () => {
         clearTimeout(timeout);
-        resolve5();
+        resolve6();
       });
       this.socket.once("error", (error) => {
         clearTimeout(timeout);
@@ -1022,15 +1022,15 @@ var OpenMatesWsClient = class {
     this.socket.send(JSON.stringify({ type, payload }));
   }
   sendAsync(type, payload) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       this.socket.send(JSON.stringify({ type, payload }), (error) => {
         if (error) reject(error);
-        else resolve5();
+        else resolve6();
       });
     });
   }
   waitForMessage(expectedType, predicate, timeoutMs = 2e4) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const onMessage = (rawData) => {
         try {
           const parsed = JSON.parse(rawData.toString());
@@ -1041,7 +1041,7 @@ var OpenMatesWsClient = class {
             return;
           }
           cleanup();
-          resolve5(parsed);
+          resolve6(parsed);
         } catch {
         }
       };
@@ -1074,14 +1074,14 @@ var OpenMatesWsClient = class {
    * Used by ensureSynced to consume the full phased-sync event stream.
    */
   collectMessages(terminatorType, timeoutMs = 9e4) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const collected = [];
       const onMessage = (rawData) => {
         try {
           const parsed = JSON.parse(rawData.toString());
           if (parsed.type === terminatorType) {
             cleanup();
-            resolve5(collected);
+            resolve6(collected);
             return;
           }
           collected.push(parsed);
@@ -1094,7 +1094,7 @@ var OpenMatesWsClient = class {
       };
       const onClose = () => {
         cleanup();
-        resolve5(collected);
+        resolve6(collected);
       };
       const timeout = setTimeout(() => {
         cleanup();
@@ -1132,7 +1132,7 @@ var OpenMatesWsClient = class {
     const timeoutMs = options?.timeoutMs ?? 9e4;
     const onStream = options?.onStream;
     const asyncEmbedWaitMs = options?.asyncEmbedWaitMs ?? 12e4;
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let latestContent = "";
       let messageId = null;
       let taskId = null;
@@ -1189,7 +1189,7 @@ var OpenMatesWsClient = class {
         if (waitingForUserPayload) {
           if (pendingSubChatHandlers.size > 0) return;
           cleanup();
-          resolve5({
+          resolve6({
             status: "waiting_for_user",
             messageId,
             taskId,
@@ -1209,7 +1209,7 @@ var OpenMatesWsClient = class {
         if (processingEmbedIds.size > 0 && !asyncEmbedTimer) {
           asyncEmbedTimer = setTimeout(() => {
             cleanup();
-            resolve5({
+            resolve6({
               status: "completed",
               messageId,
               taskId,
@@ -1226,7 +1226,7 @@ var OpenMatesWsClient = class {
         }
         if (processingEmbedIds.size > 0) return;
         cleanup();
-        resolve5({
+        resolve6({
           status: "completed",
           messageId,
           taskId,
@@ -1440,7 +1440,7 @@ var OpenMatesWsClient = class {
       const onClose = () => {
         if (aiResponseDone) {
           cleanup();
-          resolve5({
+          resolve6({
             status: "completed",
             messageId,
             taskId,
@@ -2805,13 +2805,21 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     const chatId = `anonymous-${randomUUID2()}`;
     const messageId = `anonymous-message-${randomUUID2()}`;
-    const response = await this.http.post("/v1/anonymous/chat/stream", {
+    const requestBody = {
       anonymous_id: anonymousId,
       client_chat_id: chatId,
       client_message_id: messageId,
       plaintext_message: params.message,
       message_history: []
-    });
+    };
+    if (params.learningMode?.enabled === true) {
+      requestBody.learning_mode = {
+        enabled: true,
+        age_group: params.learningMode.ageGroup ?? null,
+        source: params.learningMode.source ?? "anonymous_session"
+      };
+    }
+    const response = await this.http.post("/v1/anonymous/chat/stream", requestBody);
     if (!response.ok) {
       const detail = response.data.detail;
       const message = typeof detail === "object" && detail?.message ? detail.message : typeof detail === "string" ? detail : `Anonymous chat failed with HTTP ${response.status}`;
@@ -2979,6 +2987,41 @@ var OpenMatesClient = class _OpenMatesClient {
     saveSession(session);
     return response.data.user ?? {};
   }
+  async getLearningModeStatus() {
+    this.requireSession();
+    const response = await this.http.get(
+      "/v1/learning-mode",
+      this.getCliRequestHeaders()
+    );
+    if (!response.ok) {
+      throw new Error(`Learning Mode status failed with HTTP ${response.status}`);
+    }
+    return response.data;
+  }
+  async activateLearningMode(params) {
+    this.requireSession();
+    const response = await this.http.post(
+      "/v1/learning-mode/activate",
+      { age_group: params.ageGroup, passcode: params.passcode },
+      this.getCliRequestHeaders()
+    );
+    if (!response.ok) {
+      throw new Error(`Learning Mode activation failed with HTTP ${response.status}`);
+    }
+    return response.data;
+  }
+  async deactivateLearningMode(passcode) {
+    this.requireSession();
+    const response = await this.http.post(
+      "/v1/learning-mode/deactivate",
+      { passcode },
+      this.getCliRequestHeaders()
+    );
+    if (!response.ok) {
+      throw new Error(`Learning Mode deactivation failed with HTTP ${response.status}`);
+    }
+    return response.data;
+  }
   async logout() {
     if (this.session) {
       await this.http.post("/v1/auth/logout", {}, this.getCliRequestHeaders()).catch(() => void 0);
@@ -3677,6 +3720,29 @@ var OpenMatesClient = class _OpenMatesClient {
     if (connectedAccountTokenRefs.length > 0) {
       messagePayload.connected_account_token_refs = connectedAccountTokenRefs;
     }
+    if (params.benchmarkMetadata) {
+      messagePayload.benchmark_metadata = params.benchmarkMetadata;
+    }
+    if (params.learningMode) {
+      messagePayload.learning_mode = {
+        enabled: params.learningMode.enabled,
+        age_group: params.learningMode.ageGroup ?? null
+      };
+    }
+    if (params.incognito) {
+      const providedHistory = (params.messageHistory ?? []).map((historyMessage) => ({
+        ...historyMessage,
+        chat_id: historyMessage.chat_id ?? chatId
+      }));
+      messagePayload.message_history = [...providedHistory, {
+        message_id: messageId,
+        chat_id: chatId,
+        role: "user",
+        sender_name: "User",
+        content: params.message,
+        created_at: createdAt
+      }];
+    }
     let chatKeyBytes = null;
     let encryptedChatKey = null;
     let baselineMessagesV = 0;
@@ -3735,6 +3801,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (encryptedEmbeds.length > 0) {
       messagePayload.encrypted_embeds = encryptedEmbeds;
     }
+    const precollectedResponse = params.precollectResponse ? ws.collectAiResponse(messageId, chatId, { onStream: params.onStream }) : null;
     const confirmed = ws.waitForMessage(
       "chat_message_confirmed",
       (payload) => {
@@ -3949,7 +4016,7 @@ var OpenMatesClient = class _OpenMatesClient {
     };
     if (params.incognito) {
       try {
-        const resp = await ws.collectAiResponse(messageId, chatId, streamOpts);
+        const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId, chatId, streamOpts));
         assistantMessageId = resp.messageId;
         assistant = resp.content;
         category = resp.category;
@@ -4301,7 +4368,7 @@ var OpenMatesClient = class _OpenMatesClient {
       if (response.data.status === "failed") {
         throw new Error(response.data.error ?? "Task failed");
       }
-      await new Promise((resolve5) => setTimeout(resolve5, SKILL_TASK_POLL_INTERVAL_MS));
+      await new Promise((resolve6) => setTimeout(resolve6, SKILL_TASK_POLL_INTERVAL_MS));
     }
     throw new Error(`Task ${taskId} did not complete within ${SKILL_TASK_POLL_TIMEOUT_MS / 1e3}s`);
   }
@@ -4522,7 +4589,7 @@ var OpenMatesClient = class _OpenMatesClient {
         `Rate limited by settings API; retrying in ${Math.ceil(SETTINGS_GET_RATE_LIMIT_RETRY_MS / 1e3)}s...
 `
       );
-      await new Promise((resolve5) => setTimeout(resolve5, SETTINGS_GET_RATE_LIMIT_RETRY_MS));
+      await new Promise((resolve6) => setTimeout(resolve6, SETTINGS_GET_RATE_LIMIT_RETRY_MS));
       response = await this.http.get(normalizedPath, this.getCliRequestHeaders());
     }
     if (!response.ok) {
@@ -6023,7 +6090,7 @@ function filenameFromContentDisposition(header2) {
   return plain?.trim() ?? null;
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function printLogo() {
   const W = "\x1B[1;37m";
@@ -6039,9 +6106,9 @@ function printLogo() {
 
 // src/cli.ts
 import { createInterface as createInterface3 } from "readline/promises";
-import { realpathSync, writeFileSync as writeFileSync4 } from "fs";
-import { fileURLToPath } from "url";
-import { basename as basename3, dirname } from "path";
+import { realpathSync, writeFileSync as writeFileSync5 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { basename as basename3, dirname as dirname3 } from "path";
 import WebSocket2 from "ws";
 
 // ../secret-scanner/src/registry.ts
@@ -7741,8 +7808,8 @@ async function renderRemotionShareLink(embedId, client, ln) {
   }
 }
 function generateQr(value) {
-  return new Promise((resolve5) => {
-    qrcode2.generate(value, { small: true }, (qr) => resolve5(qr));
+  return new Promise((resolve6) => {
+    qrcode2.generate(value, { small: true }, (qr) => resolve6(qr));
   });
 }
 function remotionMeta(c) {
@@ -8510,8 +8577,9 @@ import { execSync, spawn as nodeSpawn } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createInterface as createInterface2 } from "readline";
+import { createInterface as createPromptInterface } from "readline/promises";
 import { homedir as homedir5 } from "os";
-import { join as join3, resolve as resolve3 } from "path";
+import { dirname, join as join3, resolve as resolve3 } from "path";
 var SOURCE_COMPOSE_FILE = join3("backend", "core", "docker-compose.yml");
 var IMAGE_COMPOSE_FILE = join3("backend", "core", "docker-compose.selfhost.yml");
 var COMPOSE_OVERRIDE = join3("backend", "core", "docker-compose.override.yml");
@@ -8528,6 +8596,43 @@ var IMAGE_CHANNEL_TAGS = {
   main: MAIN_BRANCH,
   dev: DEV_BRANCH
 };
+var BACKEND_CONFIG_FILE = join3("backend", "config", "backend_config.yml");
+var IMAGE_RUNTIME_CONFIG_FILE = join3("config", "backend_config.yml");
+var LOCAL_AI_MODELS_FILE = "local-ai-models.yml";
+var OFF_BY_DEFAULT_FEATURES = /* @__PURE__ */ new Map([
+  ["embed:code:application", "Application previews are still unstable"],
+  ["platform:projects", "Projects workspace is not ready by default"],
+  ["platform:workflows", "Workflows workspace is not implemented yet"],
+  ["platform:tasks", "Tasks workspace is not implemented yet"]
+]);
+var LOCAL_MODEL_RUNTIME_DEFAULTS = {
+  ollama: {
+    label: "Ollama",
+    serverId: "ollama",
+    baseUrl: "http://host.docker.internal:11434/v1",
+    apiKey: "ollama"
+  },
+  "lm-studio": {
+    label: "LM Studio",
+    serverId: "lm_studio",
+    baseUrl: "http://host.docker.internal:1234/v1",
+    apiKey: "lm-studio"
+  },
+  custom: {
+    label: "Custom OpenAI-compatible API",
+    serverId: "custom_openai_compatible",
+    baseUrl: "",
+    apiKey: "local"
+  }
+};
+var MODEL_CREATOR_OPTIONS = [
+  { id: "alibaba", name: "Alibaba / Qwen", match: /(^|[-_:/])qwen/i },
+  { id: "google", name: "Google / Gemma", match: /(^|[-_:/])gemma/i },
+  { id: "mistral", name: "Mistral", match: /(^|[-_:/])(mistral|mixtral|ministral)/i },
+  { id: "openai", name: "OpenAI", match: /(^|[-_:/])gpt-oss/i },
+  { id: "deepseek", name: "DeepSeek", match: /(^|[-_:/])deepseek/i },
+  { id: "custom", name: "Custom", match: null }
+];
 var MINIMAL_ENV_TEMPLATE = `# OpenMates self-host image-mode environment
 SECRET__MISTRAL_AI__API_KEY=
 SECRET__CEREBRAS__API_KEY=
@@ -8597,9 +8702,9 @@ function exec(cmd, cwd) {
   return execSync(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
 }
 function runInteractive(cmd, args, cwd) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = nodeSpawn(cmd, args, { cwd, stdio: "inherit", shell: false });
-    child.on("close", (code) => resolve5(code ?? 1));
+    child.on("close", (code) => resolve6(code ?? 1));
     child.on("error", reject);
   });
 }
@@ -8615,6 +8720,65 @@ function getInstallMode(installPath, config = loadConfigForInstallPath(installPa
 function shouldPullImages() {
   return process.env.OPENMATES_SKIP_IMAGE_PULL !== "1";
 }
+function normalizeFeatureList(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const item of items) {
+    const value = item.trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    normalized.push(value);
+  }
+  return normalized;
+}
+function parseListBlock(content, key) {
+  const match = content.match(new RegExp(`^${key}:\\n((?:[ \\t]+.*\\n?)*)`, "m"));
+  if (!match) return [];
+  const block = match[1] ?? "";
+  return normalizeFeatureList(
+    [...block.matchAll(/^\s*-\s*["']?([^"'\n#]+)["']?/gm)].map((item) => item[1] ?? "")
+  );
+}
+function parseFeatureOverrides(content) {
+  const overridesMatch = content.match(/^feature_overrides:\n((?:[ \t]+.*\n?)*)/m);
+  const overridesBlock = overridesMatch?.[1] ?? "";
+  const enabled = parseListBlock(overridesBlock.replace(/^ {2}/gm, ""), "enabled");
+  const disabled = parseListBlock(overridesBlock.replace(/^ {2}/gm, ""), "disabled");
+  const legacyDisabledApps = parseListBlock(content, "disabled_apps").map(
+    (appId) => appId.startsWith("app:") ? appId : `app:${appId}`
+  );
+  return {
+    enabled: normalizeFeatureList(enabled),
+    disabled: normalizeFeatureList([...disabled, ...legacyDisabledApps])
+  };
+}
+function renderFeatureOverrides(overrides) {
+  const renderList = (key, items) => {
+    if (!items.length) return `  ${key}: []`;
+    return [`  ${key}:`, ...items.map((item) => `    - "${item}"`)].join("\n");
+  };
+  return [
+    "# Admin feature overrides. Changes require a server restart.",
+    "feature_overrides:",
+    renderList("enabled", overrides.enabled),
+    renderList("disabled", overrides.disabled),
+    ""
+  ].join("\n");
+}
+function removeConfigBlock(content, key) {
+  return content.replace(new RegExp(`(?:^|\\n)#.*\\n${key}:\\n(?:[ \\t]+.*\\n?)*`, "m"), "\n").replace(new RegExp(`^${key}:\\n(?:[ \\t]+.*\\n?)*`, "m"), "");
+}
+function updateFeatureOverridesContent(content, overrides) {
+  let next = removeConfigBlock(content, "feature_overrides");
+  next = removeConfigBlock(next, "disabled_apps");
+  next = next.trimEnd();
+  return `${next}
+
+${renderFeatureOverrides(overrides)}`;
+}
+function featureKind(featureId) {
+  return featureId.split(":", 1)[0] || "unknown";
+}
 function composeArgs(installPath, withOverrides, installMode = getInstallMode(installPath)) {
   const composeFile = installMode === "image" ? IMAGE_COMPOSE_FILE : SOURCE_COMPOSE_FILE;
   const args = ["compose", "--env-file", ".env", "-f", composeFile];
@@ -8765,8 +8929,10 @@ async function writeImageModeRuntimeFiles(installPath, imageTag) {
   const coreDir = join3(installPath, "backend", "core");
   const vaultConfigDir = join3(coreDir, "vault", "config");
   mkdirSync3(vaultConfigDir, { recursive: true });
+  mkdirSync3(join3(installPath, "config", "providers"), { recursive: true });
   writeFileSync3(join3(coreDir, "docker-compose.selfhost.yml"), await loadSelfHostComposeTemplate(templateRefForImageTag(imageTag, getPackageVersion())));
   writeFileSync3(join3(vaultConfigDir, "vault.hcl"), VAULT_CONFIG_TEMPLATE);
+  ensureImageRuntimeConfig(installPath);
   const envPath = join3(installPath, ".env");
   let envContent = existsSync5(envPath) ? readFileSync5(envPath, "utf-8") : MINIMAL_ENV_TEMPLATE;
   envContent = setEnvIfEmpty(envContent, "DATABASE_ADMIN_PASSWORD", randomHex(12));
@@ -8830,6 +8996,7 @@ function defaultCloneBranchForVersion(version) {
 }
 function hasLlmCredentials(envPath) {
   if (!existsSync5(envPath)) return false;
+  if (hasLocalAiModels(dirname(envPath))) return true;
   const content = readFileSync5(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -8854,22 +9021,180 @@ function warnIfMissingLlmCredentials(installPath) {
   }
   if (!hasLlmCredentials(envPath)) {
     console.error(
-      "No LLM provider API key found in .env.\nOpenMates will start, but AI chat/model processing will stay unavailable until you add one.\n\nAdd at least one of these to your .env file:\n  SECRET__OPENAI__API_KEY=sk-...\n  SECRET__ANTHROPIC__API_KEY=sk-ant-...\n  SECRET__GOOGLE_AI_STUDIO__API_KEY=...\n\nAfter updating .env, run 'openmates server restart'."
+      "No LLM provider API key found in .env.\nOpenMates will start, but AI chat/model processing will stay unavailable until you add one.\n\nRun 'openmates server ai models add' to add a local Ollama/LM Studio model, or add at least one of these to your .env file:\n  SECRET__OPENAI__API_KEY=sk-...\n  SECRET__ANTHROPIC__API_KEY=sk-ant-...\n  SECRET__GOOGLE_AI_STUDIO__API_KEY=...\n\nAfter updating .env, run 'openmates server restart'."
     );
   }
 }
 async function confirmDestructive(phrase) {
   const rl = createInterface2({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     rl.question(`Type "${phrase}" to confirm: `, (answer) => {
       rl.close();
-      resolve5(answer.trim() === phrase);
+      resolve6(answer.trim() === phrase);
     });
   });
 }
 function printJson(data) {
   console.log(JSON.stringify(data, null, 2));
 }
+function localModelsOverlayPath(installPath, installMode = getInstallMode(installPath)) {
+  if (installMode === "source") return join3(installPath, "backend", "providers", LOCAL_AI_MODELS_FILE);
+  return join3(installPath, "config", "providers", LOCAL_AI_MODELS_FILE);
+}
+function imageBackendConfigPath(installPath) {
+  return join3(installPath, IMAGE_RUNTIME_CONFIG_FILE);
+}
+function ensureImageRuntimeConfig(installPath) {
+  const configPath = imageBackendConfigPath(installPath);
+  if (existsSync5(configPath)) return;
+  mkdirSync3(dirname(configPath), { recursive: true });
+  writeFileSync3(configPath, renderFeatureOverrides({ enabled: [], disabled: [] }));
+}
+function readLocalModelOverlay(path) {
+  if (!existsSync5(path)) return { providers: [] };
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    return { providers: Array.isArray(parsed.providers) ? parsed.providers : [] };
+  } catch (error) {
+    throw new Error(
+      `Could not parse ${path}. This file is managed by the OpenMates CLI and must remain JSON-compatible YAML. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function writeLocalModelOverlay(path, overlay) {
+  mkdirSync3(dirname(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(overlay, null, 2)}
+`);
+}
+function hasLocalAiModels(installPath) {
+  const imagePath = join3(installPath, "config", "providers", LOCAL_AI_MODELS_FILE);
+  const sourcePath = join3(installPath, "backend", "providers", LOCAL_AI_MODELS_FILE);
+  return [imagePath, sourcePath].some((path) => {
+    if (!existsSync5(path)) return false;
+    try {
+      return readLocalModelOverlay(path).providers.some((provider) => provider.models.length > 0);
+    } catch {
+      return false;
+    }
+  });
+}
+function sanitizeModelId(raw) {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "local-model";
+}
+function inferCreatorId(modelId) {
+  return MODEL_CREATOR_OPTIONS.find((option) => option.match?.test(modelId))?.id ?? "custom";
+}
+function creatorDisplayName(creatorId) {
+  return MODEL_CREATOR_OPTIONS.find((option) => option.id === creatorId)?.name ?? creatorId;
+}
+function normalizeCreatorId(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "custom_local";
+}
+function normalizeRuntimeKey(value) {
+  const normalized = value.trim().toLowerCase().replace(/_/g, "-");
+  if (normalized === "lmstudio" || normalized === "lm-studio") return "lm-studio";
+  if (normalized === "ollama") return "ollama";
+  return "custom";
+}
+function boolFromFlag(value, defaultValue = false) {
+  if (value === void 0) return defaultValue;
+  if (value === true) return true;
+  if (value === false) return false;
+  const normalized = value.toLowerCase();
+  return ["1", "true", "yes", "y", "on"].includes(normalized);
+}
+async function promptText(question, defaultValue = "") {
+  const rl = createPromptInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    const answer = await rl.question(`${question}${suffix}: `);
+    return answer.trim() || defaultValue;
+  } finally {
+    rl.close();
+  }
+}
+async function promptChoice(question, choices, defaultValue) {
+  console.error(question);
+  choices.forEach((choice, index) => {
+    const marker = choice.value === defaultValue ? " [default]" : "";
+    console.error(`  ${index + 1}. ${choice.label}${marker}`);
+  });
+  const answer = await promptText("Choose number or value", defaultValue);
+  const numeric = Number.parseInt(answer, 10);
+  if (Number.isInteger(numeric) && numeric >= 1 && numeric <= choices.length) {
+    return choices[numeric - 1].value;
+  }
+  const direct = choices.find((choice) => choice.value === answer || choice.label.toLowerCase() === answer.toLowerCase());
+  return direct?.value ?? answer;
+}
+async function fetchLocalModelIds(baseUrl, apiKey) {
+  const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/models`, {
+    headers: { Authorization: `Bearer ${apiKey || "local"}` }
+  });
+  if (!response.ok) throw new Error(`Failed to fetch local models: HTTP ${response.status}`);
+  const body = await response.json();
+  return (body.data ?? []).map((model) => model.id).filter((id) => Boolean(id));
+}
+async function testLocalModel(baseUrl, apiKey, modelId) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        Authorization: `Bearer ${apiKey || "local"}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: modelId,
+        messages: [
+          { role: "system", content: "Answer with only the number." },
+          { role: "user", content: "1+2?" }
+        ],
+        stream: false,
+        temperature: 0
+      })
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    const body = await response.json();
+    return body.choices?.[0]?.message?.content?.trim() ?? "";
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function upsertLocalModel(path, providerId, providerName, model) {
+  const overlay = readLocalModelOverlay(path);
+  let provider = overlay.providers.find((item) => item.provider_id === providerId);
+  if (!provider) {
+    provider = {
+      provider_id: providerId,
+      name: providerName,
+      description: `Local self-hosted models for ${providerName}.`,
+      models: []
+    };
+    overlay.providers.push(provider);
+  }
+  const modelId = model.id;
+  provider.models = provider.models.filter((existing) => existing.id !== modelId);
+  provider.models.push(model);
+  writeLocalModelOverlay(path, overlay);
+}
+function removeLocalModel(path, fullModelId) {
+  const [providerId, modelId] = fullModelId.split("/", 2);
+  if (!providerId || !modelId) throw new Error("Use provider/model-id format.");
+  const overlay = readLocalModelOverlay(path);
+  const provider = overlay.providers.find((item) => item.provider_id === providerId);
+  if (!provider) return false;
+  const before = provider.models.length;
+  provider.models = provider.models.filter((model) => model.id !== modelId);
+  writeLocalModelOverlay(path, overlay);
+  return provider.models.length !== before;
+}
+function localModelsFromOverlay(overlay) {
+  return overlay.providers.flatMap((provider) => provider.models.map((model) => ({ providerId: provider.provider_id, model })));
+}
 async function serverStatus(flags) {
   requireDocker();
   const installPath = resolveServerPath(flags);
@@ -9324,6 +9649,245 @@ async function serverMakeAdmin(rest, flags) {
     console.log(`Admin privileges granted to ${email}.`);
   }
 }
+async function serverFeatures(rest, flags) {
+  const action = rest[0] ?? "list";
+  const featureId = rest[1];
+  const installPath = resolveServerPath(flags);
+  const installMode = getInstallMode(installPath);
+  if (installMode === "image") ensureImageRuntimeConfig(installPath);
+  const configPath = installMode === "image" ? imageBackendConfigPath(installPath) : join3(installPath, BACKEND_CONFIG_FILE);
+  if (!existsSync5(configPath)) {
+    throw new Error(`Backend config not found at ${configPath}. Run 'openmates server install' first or pass --path <dir>.`);
+  }
+  const content = readFileSync5(configPath, "utf-8");
+  const overrides = parseFeatureOverrides(content);
+  const writeOverrides = (nextOverrides) => {
+    writeFileSync3(configPath, updateFeatureOverridesContent(content, nextOverrides));
+    console.log(`Updated ${configPath}`);
+    console.log("Restart the server for feature changes to take effect: openmates server restart");
+  };
+  if (action === "list") {
+    console.log("Feature overrides:");
+    console.log(`  enabled: ${overrides.enabled.length ? overrides.enabled.join(", ") : "none"}`);
+    console.log(`  disabled: ${overrides.disabled.length ? overrides.disabled.join(", ") : "none"}`);
+    console.log("\nKnown off-by-default features:");
+    for (const [id, reason] of OFF_BY_DEFAULT_FEATURES.entries()) {
+      const override = overrides.enabled.includes(id) ? "enabled override" : overrides.disabled.includes(id) ? "disabled override" : "default off";
+      console.log(`  ${id} (${featureKind(id)}): ${override} - ${reason}`);
+    }
+    return;
+  }
+  if (!featureId) {
+    throw new Error(`Usage: openmates server features ${action} <feature-id>`);
+  }
+  if (action === "enable") {
+    writeOverrides({
+      enabled: normalizeFeatureList([...overrides.enabled, featureId]),
+      disabled: overrides.disabled.filter((id) => id !== featureId)
+    });
+    return;
+  }
+  if (action === "disable") {
+    writeOverrides({
+      enabled: overrides.enabled.filter((id) => id !== featureId),
+      disabled: normalizeFeatureList([...overrides.disabled, featureId])
+    });
+    return;
+  }
+  if (action === "reset") {
+    writeOverrides({
+      enabled: overrides.enabled.filter((id) => id !== featureId),
+      disabled: overrides.disabled.filter((id) => id !== featureId)
+    });
+    return;
+  }
+  if (action === "explain") {
+    const defaultReason = OFF_BY_DEFAULT_FEATURES.get(featureId);
+    const override = overrides.enabled.includes(featureId) ? "enabled" : overrides.disabled.includes(featureId) ? "disabled" : "none";
+    const defaultState = defaultReason ? "off" : "on";
+    const effective = override === "enabled" ? "enabled" : override === "disabled" ? "disabled" : defaultState === "on" ? "enabled" : "disabled";
+    console.log(`Feature: ${featureId}`);
+    console.log(`Kind: ${featureKind(featureId)}`);
+    console.log(`Default: ${defaultState}${defaultReason ? ` (${defaultReason})` : ""}`);
+    console.log(`Override: ${override}`);
+    console.log(`Effective after restart: ${effective}`);
+    return;
+  }
+  throw new Error(`Unknown server features command '${action}'. Use list, enable, disable, reset, or explain.`);
+}
+async function serverAiModelsAdd(flags) {
+  const installPath = resolveServerPath(flags);
+  const installMode = getInstallMode(installPath);
+  const overlayPath = localModelsOverlayPath(installPath, installMode);
+  const runtimeInput = typeof flags.runtime === "string" ? flags.runtime : await promptChoice(
+    "Which local runtime should OpenMates use?",
+    [
+      { value: "ollama", label: "Ollama" },
+      { value: "lm-studio", label: "LM Studio" },
+      { value: "custom", label: "Custom OpenAI-compatible API" }
+    ],
+    "ollama"
+  );
+  const runtimeKey = normalizeRuntimeKey(runtimeInput);
+  const runtime = LOCAL_MODEL_RUNTIME_DEFAULTS[runtimeKey];
+  const baseUrl = typeof flags["base-url"] === "string" ? flags["base-url"] : await promptText("OpenAI-compatible base URL", runtime.baseUrl);
+  const apiKey = typeof flags["api-key"] === "string" ? flags["api-key"] : runtimeKey === "custom" ? await promptText("API key", runtime.apiKey) : runtime.apiKey;
+  let availableModels = [];
+  try {
+    availableModels = await fetchLocalModelIds(baseUrl, apiKey);
+  } catch (error) {
+    console.error(`Could not fetch /v1/models: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const rawModelId = typeof flags.model === "string" ? flags.model : availableModels.length ? await promptChoice(
+    "Which installed model should OpenMates add?",
+    [...availableModels.map((id) => ({ value: id, label: id })), { value: "manual", label: "Enter manually" }],
+    availableModels[0]
+  ) : await promptText("Local model ID");
+  const serverModelId = rawModelId === "manual" ? await promptText("Local model ID") : rawModelId;
+  if (!serverModelId) throw new Error("Model ID is required.");
+  const inferredCreator = inferCreatorId(serverModelId);
+  const creatorInput = typeof flags.creator === "string" ? flags.creator : await promptChoice(
+    "Who created the model?",
+    MODEL_CREATOR_OPTIONS.map((option) => ({ value: option.id, label: option.name })),
+    inferredCreator
+  );
+  const providerId = creatorInput === "custom" ? normalizeCreatorId(await promptText("Custom creator/provider ID", "custom_local")) : normalizeCreatorId(creatorInput);
+  const providerName = providerId === creatorInput ? creatorDisplayName(providerId) : providerId;
+  const internalModelId = typeof flags.id === "string" ? sanitizeModelId(flags.id) : `${sanitizeModelId(serverModelId)}-local`;
+  const displayName = typeof flags.name === "string" ? flags.name : await promptText("Display name", serverModelId);
+  const supportsImages = boolFromFlag(flags.images ?? flags.image ?? flags.vision, false);
+  const supportsTools = boolFromFlag(flags.tools ?? flags["tool-use"], false);
+  const contextWindowInput = typeof flags["context-window"] === "string" ? flags["context-window"] : await promptText("Context window tokens", "32768");
+  const contextWindow = Number.parseInt(contextWindowInput, 10) || 32768;
+  if (flags["skip-test"] !== true) {
+    console.error(`Testing ${runtime.label} model '${serverModelId}'...`);
+    const testOutput = await testLocalModel(baseUrl, apiKey, serverModelId);
+    if (!testOutput) throw new Error("Local model test returned no content. Not saving model.");
+    console.error(`Test response: ${testOutput}`);
+  }
+  const model = {
+    id: internalModelId,
+    name: displayName,
+    description: `${displayName} served locally through ${runtime.label}.`,
+    country_origin: "local",
+    for_app_skill: "ai.ask",
+    allow_auto_select: false,
+    local: true,
+    self_hosted: true,
+    input_types: supportsImages ? ["text", "image"] : ["text"],
+    output_types: ["text"],
+    default_server: runtime.serverId,
+    servers: [
+      {
+        id: runtime.serverId,
+        name: runtime.label,
+        model_id: serverModelId,
+        region: "local",
+        base_url: baseUrl.replace(/\/+$/, ""),
+        api_key: apiKey,
+        supports_tools: supportsTools
+      }
+    ],
+    pricing: { fixed: { credits: 0 } },
+    costs: {
+      input_per_million_token: { price: 0, currency: "USD", max_context: contextWindow },
+      output_per_million_token: { price: 0, currency: "USD", max_context: contextWindow }
+    },
+    features: {
+      streaming: true,
+      tool_use: supportsTools,
+      max_context: contextWindow
+    }
+  };
+  upsertLocalModel(overlayPath, providerId, providerName, model);
+  if (installMode === "image") ensureImageRuntimeConfig(installPath);
+  if (flags.json === true) {
+    printJson({ command: "server ai models add", status: "success", model: `${providerId}/${internalModelId}`, overlayPath });
+  } else {
+    console.log(`Added local model: ${providerId}/${internalModelId}`);
+    console.log(`Updated ${overlayPath}`);
+    console.log("Restart the server for model changes to take effect: openmates server restart");
+    console.log("Self-hosted local models charge 0 credits; token usage may still be recorded in usage history.");
+  }
+}
+async function serverAiModelsList(flags) {
+  const installPath = resolveServerPath(flags);
+  const overlayPath = localModelsOverlayPath(installPath);
+  const overlay = readLocalModelOverlay(overlayPath);
+  const models = localModelsFromOverlay(overlay).map(({ providerId, model }) => ({
+    id: `${providerId}/${String(model.id ?? "")}`,
+    name: model.name ?? model.id,
+    server: Array.isArray(model.servers) ? model.servers[0]?.id : void 0,
+    serverModelId: Array.isArray(model.servers) ? model.servers[0]?.model_id : void 0
+  }));
+  if (flags.json === true) {
+    printJson({ overlayPath, models });
+    return;
+  }
+  if (!models.length) {
+    console.log("No local AI models configured. Add one with: openmates server ai models add");
+    return;
+  }
+  console.log("Local AI models:");
+  for (const model of models) {
+    console.log(`  ${model.id} (${model.server}: ${model.serverModelId})`);
+  }
+}
+async function serverAiModelsTest(rest, flags) {
+  const installPath = resolveServerPath(flags);
+  const overlayPath = localModelsOverlayPath(installPath);
+  const fullModelId = rest[0];
+  if (!fullModelId || !fullModelId.includes("/")) throw new Error("Usage: openmates server ai models test <provider/model-id>");
+  const [providerId, modelId] = fullModelId.split("/", 2);
+  const overlay = readLocalModelOverlay(overlayPath);
+  const provider = overlay.providers.find((item) => item.provider_id === providerId);
+  const model = provider?.models.find((item) => item.id === modelId);
+  const server = Array.isArray(model?.servers) ? model.servers[0] : void 0;
+  if (!server) throw new Error(`Local model not found in ${overlayPath}: ${fullModelId}`);
+  const baseUrl = String(server.base_url ?? "");
+  const apiKey = String(server.api_key ?? "local");
+  const serverModelId = String(server.model_id ?? "");
+  const output = await testLocalModel(baseUrl, apiKey, serverModelId);
+  if (flags.json === true) {
+    printJson({ model: fullModelId, status: "success", output });
+  } else {
+    console.log(`Model test succeeded: ${fullModelId}`);
+    console.log(`Response: ${output}`);
+  }
+}
+async function serverAiModelsRemove(rest, flags) {
+  const installPath = resolveServerPath(flags);
+  const overlayPath = localModelsOverlayPath(installPath);
+  const fullModelId = rest[0];
+  if (!fullModelId) throw new Error("Usage: openmates server ai models remove <provider/model-id>");
+  const removed = removeLocalModel(overlayPath, fullModelId);
+  if (flags.json === true) {
+    printJson({ command: "server ai models remove", status: removed ? "success" : "not_found", model: fullModelId });
+  } else if (removed) {
+    console.log(`Removed local model: ${fullModelId}`);
+    console.log("Restart the server for model changes to take effect: openmates server restart");
+  } else {
+    console.log(`Local model not found: ${fullModelId}`);
+  }
+}
+async function serverAi(rest, flags) {
+  const area = rest[0];
+  const action = rest[1] ?? "list";
+  const args = rest.slice(2);
+  if (area !== "models") throw new Error("Usage: openmates server ai models <add|list|test|remove>");
+  switch (action) {
+    case "add":
+      return serverAiModelsAdd(flags);
+    case "list":
+      return serverAiModelsList(flags);
+    case "test":
+      return serverAiModelsTest(args, flags);
+    case "remove":
+      return serverAiModelsRemove(args, flags);
+    default:
+      throw new Error(`Unknown server ai models command '${action}'. Use add, list, test, or remove.`);
+  }
+}
 async function serverUninstall(flags) {
   requireDocker();
   const installPath = resolveServerPath(flags);
@@ -9391,6 +9955,7 @@ Commands:
   logs            Display server logs
   update          Update to latest version (pull images, or git pull + rebuild for source installs)
   make-admin      Grant admin privileges to a user
+  ai              Manage self-hosted local AI models
   reset           Reset server data (requires confirmation)
   uninstall       Completely remove OpenMates (requires confirmation)
 
@@ -9435,11 +10000,27 @@ Command Options:
   make-admin:
     openmates server make-admin <email>
 
+  features:
+    openmates server features list
+    openmates server features enable <feature-id>
+    openmates server features disable <feature-id>
+    openmates server features reset <feature-id>
+    openmates server features explain <feature-id>
+
+  ai models:
+    openmates server ai models add
+    openmates server ai models list
+    openmates server ai models test <provider/model-id>
+    openmates server ai models remove <provider/model-id>
+
 Examples:
   openmates server install
   openmates server start --with-overrides
   openmates server logs --container api --follow
   openmates server make-admin user@example.com
+  openmates server features disable app:videos
+  openmates server ai models add
+  openmates server features enable embed:code:application
   openmates server update
   openmates server update --dry-run
   openmates server update --image-tag v0.12.0-alpha.1
@@ -9471,6 +10052,10 @@ async function handleServer(subcommand, rest, flags) {
       return serverReset(flags);
     case "make-admin":
       return serverMakeAdmin(rest, flags);
+    case "ai":
+      return serverAi(rest, flags);
+    case "features":
+      return serverFeatures(rest, flags);
     case "uninstall":
       return serverUninstall(flags);
     default:
@@ -20671,7 +21256,7 @@ line_count: 37`,
   metadata: {
     featured: true,
     order: 2,
-    content_embed_examples: ["code.application"]
+    content_embed_examples: []
   }
 };
 
@@ -26232,6 +26817,9 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     anonymous_free_usage: {
       feature_notice: {
         text: "You are using free anonymous credits. File uploads, memories, chat sync, and some other features require creating an account."
+      },
+      daily_credits_exhausted: {
+        text: "You used up your free daily credits. Sign up & buy credits to make full use of OpenMates."
       }
     },
     interactive_question_failed: {
@@ -27900,6 +28488,50 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     account_created: {
       text: "Account created"
     },
+    account_created_second_login_title: {
+      text: "Add a second login method"
+    },
+    account_created_second_login_info: {
+      text: "If you signed up with a passkey, add password plus 2FA as a backup. If you signed up with password plus 2FA, add a passkey for faster secure login."
+    },
+    existing_account: {
+      subject: {
+        text: "An OpenMates account already exists for this email"
+      },
+      title: {
+        text: "An account with your email already exists"
+      },
+      intro: {
+        text: "Someone tried to create a new OpenMates account with this email address, but this email is already connected to an existing account."
+      },
+      saved_logins_title: {
+        text: "Check your saved logins"
+      },
+      saved_logins_body: {
+        text: "Your browser, password manager, or device may already have the login saved. Look for OpenMates in saved passwords or passkeys before creating a new account."
+      },
+      login_methods_title: {
+        text: "Try your login methods"
+      },
+      login_methods_body: {
+        text: "You can log in with a passkey, or with your password plus 2FA. If you set up backup codes, keep them ready for the 2FA step."
+      },
+      login_button: {
+        text: "Log in to OpenMates"
+      },
+      recovery_key_title: {
+        text: "Have your recovery key?"
+      },
+      recovery_key_body: {
+        text: "If you do not remember your password or passkey but still have your recovery key, use recovery key login. It preserves your encrypted chats and account data."
+      },
+      recovery_button: {
+        text: "Open login and use recovery key"
+      },
+      reset_warning: {
+        text: "If you lost every login method and your recovery key, account reset is the last resort. Because OpenMates encrypts your data, resetting the account can permanently delete encrypted chats, memories, app settings, embeds, passkeys, and API keys."
+      }
+    },
     password_security_reminder: {
       subject: {
         text: "Action needed to secure your OpenMates account"
@@ -28129,10 +28761,7 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
       text: "Welcome to OpenMates!"
     },
     complete_signup_info: {
-      text: "Once you completed the signup process by purchasing usage credits or redeeming a gift card, you can start using OpenMates!"
-    },
-    auto_delete_warning: {
-      text: "Please note: Accounts that haven't completed the signup process will be automatically deleted after 7 days."
+      text: "Your account is ready. Here are a few helpful next steps to protect your access and keep a copy of your data."
     },
     want_to_delete_account: {
       text: "Want to delete your account?"
@@ -28920,6 +29549,9 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     }
   },
   embeds: {
+    learning_mode_shortened_notice: {
+      text: "Shortened since Learning Mode is active."
+    },
     weather: {
       rain_radar: {
         no_rain: {
@@ -29262,6 +29894,15 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     copy_failed: {
       text: "Failed to copy to clipboard"
     },
+    code_file_downloaded: {
+      text: "Code file downloaded successfully"
+    },
+    code_file_download_failed: {
+      text: "Failed to download code file"
+    },
+    action_failed: {
+      text: "Failed to perform action"
+    },
     download_itinerary: {
       text: "Download itinerary"
     },
@@ -37618,6 +38259,99 @@ As of mid-2026, the severe supply shocks from the 2024\u20132025 avian flu have
     incognito: {
       text: "Incognito"
     },
+    learning_mode: {
+      text: "Learning"
+    },
+    learning_mode_active: {
+      text: "Active for all chats on this account"
+    },
+    learning_mode_inactive: {
+      text: "Teach step-by-step instead of giving complete answers"
+    },
+    learning_mode_load_error: {
+      text: "Could not load Learning Mode status."
+    },
+    learning_mode_save_error: {
+      text: "Could not update Learning Mode."
+    },
+    learning_mode_enabled: {
+      text: "Learning Mode enabled."
+    },
+    learning_mode_disabled: {
+      text: "Learning Mode disabled."
+    },
+    learning_mode_age_group_prompt: {
+      text: "Learner age group: under_10, 10_12, 13_15, 16_18, or adult"
+    },
+    learning_mode_enable_passcode_prompt: {
+      text: "Set a Learning Mode passcode."
+    },
+    learning_mode_disable_passcode_prompt: {
+      text: "Enter the Learning Mode passcode to disable it."
+    },
+    learning_mode_invalid_age_group: {
+      text: "Invalid age group. Use under_10, 10_12, 13_15, 16_18, or adult."
+    },
+    learning_mode_enable_description: {
+      text: "Choose the learner age group and set a passcode. Learning Mode will apply to every chat on this account."
+    },
+    learning_mode_disable_description: {
+      text: "Enter the Learning Mode passcode to turn it off for this account."
+    },
+    learning_mode_guest_description: {
+      text: "Choose the learner age group. For guests, Learning Mode lasts only for this browser session and has no passcode."
+    },
+    learning_mode_active_detail: {
+      text: "Learning Mode is active for every chat on this account. Answers stay teaching-first and selected tools are restricted."
+    },
+    learning_mode_inactive_detail: {
+      text: "When enabled, OpenMates guides the learner step by step instead of giving complete answers."
+    },
+    learning_mode_guest_active_detail: {
+      text: "Learning Mode is active for anonymous chats in this browser session. Create an account to lock it with a passcode across devices."
+    },
+    learning_mode_guest_inactive_detail: {
+      text: "Guests can try Learning Mode for anonymous chats in this browser session. Create an account to lock it with a passcode."
+    },
+    learning_mode_age_group_label: {
+      text: "Learner age group"
+    },
+    learning_mode_age_under_10: {
+      text: "Under 10"
+    },
+    learning_mode_age_10_12: {
+      text: "10 to 12"
+    },
+    learning_mode_age_13_15: {
+      text: "13 to 15"
+    },
+    learning_mode_age_16_18: {
+      text: "16 to 18"
+    },
+    learning_mode_age_adult: {
+      text: "Adult"
+    },
+    learning_mode_enable_passcode_label: {
+      text: "Set passcode"
+    },
+    learning_mode_disable_passcode_label: {
+      text: "Enter passcode"
+    },
+    learning_mode_enable_passcode_placeholder: {
+      text: "Create a passcode"
+    },
+    learning_mode_disable_passcode_placeholder: {
+      text: "Learning Mode passcode"
+    },
+    learning_mode_passcode_required: {
+      text: "Enter a passcode to continue."
+    },
+    learning_mode_enable_button: {
+      text: "Start Learning Mode"
+    },
+    learning_mode_disable_button: {
+      text: "Turn off Learning Mode"
+    },
     incognito_explainer_description: {
       text: "Incognito mode applies only to new chats you create. New chats created while incognito mode is active are not synced across devices, not stored on the server, and not cached. These chats exist only in your current browser session. Existing chats remain unchanged."
     },
@@ -41455,7 +42189,12 @@ function isInteractiveQuestionPayload(value) {
   if (!isQuestionType(payload.type)) return false;
   if (typeof payload.id !== "string" || payload.id.trim().length === 0) return false;
   if (payload.type === "choice") {
-    return typeof payload.question === "string" && payload.question.trim().length > 0 && Array.isArray(payload.options) && payload.options.length > 0;
+    if (typeof payload.question !== "string" || payload.question.trim().length === 0) return false;
+    if (!Array.isArray(payload.options) || payload.options.length === 0) return false;
+    if (payload.custom_option_id !== void 0) {
+      return typeof payload.custom_option_id === "string" && payload.options.some((option) => option.id === payload.custom_option_id);
+    }
+    return true;
   }
   if (payload.type === "input") return Array.isArray(payload.fields) && payload.fields.length > 0;
   if (payload.type === "slider") {
@@ -41463,13 +42202,27 @@ function isInteractiveQuestionPayload(value) {
   }
   if (payload.type === "swipe") return Array.isArray(payload.cards) && payload.cards.length > 0;
   if (payload.type === "rating") {
-    return typeof payload.question === "string" && payload.question.trim().length > 0 && (typeof payload.max === "number" || typeof payload.scale === "number");
+    return typeof payload.question === "string" && payload.question.trim().length > 0 && (typeof payload.max_stars === "number" || typeof payload.max === "number" || typeof payload.scale === "number");
   }
   return false;
 }
 function isQuestionType(value) {
   return value === "choice" || value === "input" || value === "slider" || value === "swipe" || value === "rating";
 }
+function formatInteractiveQuestionAnswer(question, answer) {
+  const responsePayload = buildResponsePayload(question, answer);
+  const displayText = buildDisplayText(question, answer);
+  const protocol = JSON.stringify(responsePayload, null, 2);
+  return {
+    displayText,
+    messageContent: `${displayText}
+
+\`\`\`interactive_response
+${protocol}
+\`\`\``,
+    responsePayload
+  };
+}
 function toWaitingForUserResult(params) {
   return {
     status: "waiting_for_user",
@@ -41479,6 +42232,50 @@ function toWaitingForUserResult(params) {
     question: params.question
   };
 }
+function buildResponsePayload(question, answer) {
+  return {
+    id: question.id,
+    ...answer
+  };
+}
+function buildDisplayText(question, answer) {
+  if (question.type === "choice") {
+    const selection = Array.isArray(answer.selection) ? answer.selection.map(String) : [];
+    const optionsById = new Map((question.options ?? []).map((option) => [option.id, option.text]));
+    const customAnswer = answer.custom_answer == null ? "" : String(answer.custom_answer).trim();
+    return selection.map((id) => customAnswer && isCustomChoiceOption(question, id) ? customAnswer : optionsById.get(id) ?? id).join(", ");
+  }
+  if (question.type === "input") {
+    const values = answer.inputs && typeof answer.inputs === "object" ? answer.inputs : answer.values && typeof answer.values === "object" ? answer.values : answer;
+    return Object.entries(values).filter(([key]) => key !== "id").map(([, value]) => String(value)).filter(Boolean).join("\n");
+  }
+  if (question.type === "slider") {
+    return answer.value == null ? "" : String(answer.value);
+  }
+  if (question.type === "swipe") {
+    const liked = Array.isArray(answer.liked) ? answer.liked.map(String) : [];
+    const cardsById = new Map((question.cards ?? []).map((card) => [card.id, card.text]));
+    return liked.map((id) => cardsById.get(id) ?? id).join(", ");
+  }
+  if (question.type === "rating") {
+    const rating = answer.rating == null ? "" : String(answer.rating);
+    const comment = answer.comment == null ? "" : String(answer.comment).trim();
+    return [rating, comment].filter(Boolean).join("\n");
+  }
+  return "";
+}
+function isCustomChoiceOption(question, optionId) {
+  if (question.custom_option_id) return optionId === question.custom_option_id;
+  const optionText = (question.options ?? []).find((option) => option.id === optionId)?.text.trim().toLowerCase() ?? "";
+  return [
+    "i give you my own answer",
+    "my own answer",
+    "own answer",
+    "custom answer",
+    "something else",
+    "other"
+  ].some((pattern) => optionText === pattern || optionText.includes(pattern));
+}
 
 // src/feedback.ts
 var ASSISTANT_FEEDBACK_THANKS = "Thanks for the feedback!";
@@ -41502,6 +42299,1022 @@ function buildAssistantFeedbackDecision(rating) {
   };
 }
 
+// src/benchmark.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync6, mkdtempSync, readFileSync as readFileSync6, readdirSync, writeFileSync as writeFileSync4 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, join as join4, resolve as resolve5 } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_JUDGE_MODEL = "google/gemini-3-flash-preview";
+var DEFAULT_EXTENSIVE_SIZE = 10;
+var DEFAULT_PARALLEL = 4;
+var FIXTURE_IMAGE_SVG = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="800" viewBox="0 0 1200 800">
+  <rect width="1200" height="800" fill="#d8ecff"/>
+  <rect y="560" width="1200" height="240" fill="#d7c39a"/>
+  <text x="600" y="88" text-anchor="middle" font-family="Arial, sans-serif" font-size="44" font-weight="700" fill="#23344d">Brandenburger Tor, Berlin</text>
+  <g transform="translate(160 170)" fill="#c9aa6a" stroke="#5d4522" stroke-width="8">
+    <rect x="80" y="160" width="800" height="58"/>
+    <rect x="120" y="218" width="720" height="48"/>
+    <rect x="150" y="266" width="660" height="42"/>
+    <g fill="#d9bd7d">
+      <rect x="170" y="308" width="54" height="250"/>
+      <rect x="285" y="308" width="54" height="250"/>
+      <rect x="400" y="308" width="54" height="250"/>
+      <rect x="515" y="308" width="54" height="250"/>
+      <rect x="630" y="308" width="54" height="250"/>
+      <rect x="745" y="308" width="54" height="250"/>
+    </g>
+    <rect x="130" y="558" width="700" height="50"/>
+    <path d="M480 30 C530 72 620 88 682 48 L720 84 C652 142 530 124 456 78 Z" fill="#3e6f5f"/>
+    <circle cx="510" cy="92" r="22" fill="#3e6f5f"/>
+    <circle cx="625" cy="92" r="22" fill="#3e6f5f"/>
+    <path d="M565 38 l26 78 h-52 z" fill="#3e6f5f"/>
+  </g>
+  <text x="600" y="740" text-anchor="middle" font-family="Arial, sans-serif" font-size="32" fill="#23344d">Neoclassical gate with Quadriga on top</text>
+</svg>
+`;
+var QUICK_CASES = [
+  {
+    id: "quick-exact-token",
+    suite: "quick",
+    title: "Exact token smoke test",
+    prompt: "Reply with exactly this token and no extra text: BENCHMARK_SMOKE_OK",
+    complexity: "basic",
+    category: "smoke",
+    expectedIncludes: "BENCHMARK_SMOKE_OK",
+    judge: true,
+    estimatedInputTokens: 12e3,
+    estimatedOutputTokens: 64
+  },
+  {
+    id: "quick-arithmetic",
+    suite: "quick",
+    title: "Arithmetic direct answer",
+    prompt: "Compute 19 * 23. Reply with only the integer result.",
+    complexity: "basic",
+    category: "math",
+    expectedIncludes: "437",
+    judge: true,
+    estimatedInputTokens: 12e3,
+    estimatedOutputTokens: 64
+  },
+  {
+    id: "quick-code",
+    suite: "quick",
+    title: "Small code generation",
+    prompt: "Write a TypeScript function isPalindrome(input: string): boolean that ignores spaces, punctuation, and case. Include only the function and one short usage example.",
+    complexity: "medium",
+    category: "coding",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 650
+  },
+  {
+    id: "quick-image-brandenburger-tor",
+    suite: "quick",
+    title: "Default image understanding",
+    prompt: "Look at the attached image. What landmark is shown, when was it built, and who designed it? Answer in three concise bullet points.",
+    complexity: "medium",
+    category: "image",
+    image: "default",
+    expectedIncludes: "Brandenburg",
+    judge: true,
+    estimatedInputTokens: 13500,
+    estimatedOutputTokens: 350
+  },
+  {
+    id: "quick-followup-continuity",
+    suite: "quick",
+    title: "Short multi-turn continuity",
+    prompt: "Create a three-step plan for evaluating whether a new AI model is ready for production use.",
+    complexity: "medium",
+    category: "multi_turn",
+    judge: true,
+    estimatedInputTokens: 14e3,
+    estimatedOutputTokens: 900,
+    followUps: [
+      { prompt: "Now make step 2 more concrete with two measurable checks." },
+      { prompt: "Summarize the final plan in one sentence." }
+    ]
+  }
+];
+var EXTENSIVE_CASES = [
+  ...QUICK_CASES,
+  {
+    id: "extensive-coding-debug",
+    suite: "extensive",
+    title: "Debug a JavaScript bug",
+    prompt: "A JavaScript function returns NaN when summing prices from [{price: '12.50'}, {price: undefined}]. Explain the bug and write a corrected function.",
+    complexity: "medium",
+    category: "coding",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 850
+  },
+  {
+    id: "extensive-coding-api-design",
+    suite: "extensive",
+    title: "Design a small API contract",
+    prompt: "Design a minimal JSON API for creating and listing benchmark runs. Include request/response examples and one validation error.",
+    complexity: "advanced",
+    category: "coding",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 1e3
+  },
+  {
+    id: "extensive-reasoning-tradeoffs",
+    suite: "extensive",
+    title: "Reason about benchmark tradeoffs",
+    prompt: "Compare deterministic assertions and LLM-as-judge evaluation for model benchmarks. Give two strengths and two risks for each.",
+    complexity: "medium",
+    category: "reasoning",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 800
+  },
+  {
+    id: "extensive-planning",
+    suite: "extensive",
+    title: "Operational rollout plan",
+    prompt: "Create a rollout checklist for switching a production chatbot from one model to another. Include monitoring, rollback, and user-visible risk checks.",
+    complexity: "advanced",
+    category: "synthesis",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 950
+  },
+  {
+    id: "extensive-long-context-followup",
+    suite: "extensive",
+    title: "Prebuilt 20-message long chat follow-up",
+    prompt: "Based on the earlier discussion, choose the best launch strategy and explain why in five bullets.",
+    complexity: "advanced",
+    category: "long_context",
+    longContext: true,
+    judge: true,
+    estimatedInputTokens: 18500,
+    estimatedOutputTokens: 900
+  },
+  {
+    id: "extensive-policy-summary",
+    suite: "extensive",
+    title: "Policy summarization",
+    prompt: "Summarize why privacy-preserving benchmark logs should avoid raw user prompts. Include a concrete safer alternative.",
+    complexity: "medium",
+    category: "reasoning",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 650
+  },
+  {
+    id: "extensive-structured-output",
+    suite: "extensive",
+    title: "Structured JSON output",
+    prompt: "Return only JSON with keys risk, mitigation, and confidence for the risk: benchmark results are biased by prompt wording.",
+    complexity: "medium",
+    category: "synthesis",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 350
+  },
+  {
+    id: "extensive-creative-constraint",
+    suite: "extensive",
+    title: "Creative constrained response",
+    prompt: "Write a six-line product note announcing model comparisons. Each line must be under 70 characters and avoid hype words like revolutionary or magical.",
+    complexity: "medium",
+    category: "synthesis",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 500
+  },
+  {
+    id: "extensive-data-reasoning",
+    suite: "extensive",
+    title: "Interpret metrics",
+    prompt: "A benchmark has pass rates 8/10, 7/10, and 9/10 across three runs. Explain what you can and cannot conclude from this sample.",
+    complexity: "medium",
+    category: "reasoning",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 600
+  },
+  {
+    id: "extensive-security-review",
+    suite: "extensive",
+    title: "Security review",
+    prompt: "Review this benchmark design for security risks: it logs prompts, outputs, model ids, and usage costs to a shared file. List risks and safer defaults.",
+    complexity: "advanced",
+    category: "reasoning",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 850
+  },
+  {
+    id: "extensive-followup-requirements",
+    suite: "extensive",
+    title: "Three-turn requirements refinement",
+    prompt: "Draft acceptance criteria for a CLI benchmark comparison feature.",
+    complexity: "advanced",
+    category: "multi_turn",
+    judge: true,
+    estimatedInputTokens: 14500,
+    estimatedOutputTokens: 1100,
+    followUps: [
+      { prompt: "Add one criterion about cost estimation before live runs." },
+      { prompt: "Add one criterion about partial results after interruption." },
+      { prompt: "Now compress the criteria to five bullets total." }
+    ]
+  },
+  {
+    id: "extensive-coding-tests",
+    suite: "extensive",
+    title: "Write tests for parser behavior",
+    prompt: "Write Node.js test cases for a function parseSuites(value) that accepts quick, extensive, all, and comma-separated lists, and rejects unknown suites.",
+    complexity: "medium",
+    category: "coding",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 950
+  },
+  {
+    id: "extensive-coding-refactor",
+    suite: "extensive",
+    title: "Refactor duplicated code",
+    prompt: "Given two duplicated TypeScript loops that build arrays of result objects, explain when to extract a helper and write the helper signature.",
+    complexity: "medium",
+    category: "coding",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 750
+  },
+  {
+    id: "extensive-comparison-analysis",
+    suite: "extensive",
+    title: "Compare two model outputs",
+    prompt: "Explain how you would compare two model outputs when one is concise but misses caveats and the other is verbose but complete.",
+    complexity: "medium",
+    category: "reasoning",
+    judge: true,
+    estimatedInputTokens: 12200,
+    estimatedOutputTokens: 650
+  },
+  {
+    id: "extensive-failure-mode",
+    suite: "extensive",
+    title: "Failure-mode analysis",
+    prompt: "List five failure modes for image-understanding benchmarks and one mitigation for each.",
+    complexity: "advanced",
+    category: "image",
+    judge: true,
+    estimatedInputTokens: 12300,
+    estimatedOutputTokens: 900
+  }
+];
+async function handleBenchmark(client, subcommand, rest, flags) {
+  if (!subcommand || subcommand === "help" || flags.help === true) {
+    printBenchmarkHelp();
+    return;
+  }
+  if (subcommand !== "model") {
+    throw new Error(`Unknown benchmark command '${subcommand}'. Run 'openmates benchmark --help'.`);
+  }
+  const targetModels = rest.filter((arg) => !arg.startsWith("--"));
+  if (targetModels.length === 0) {
+    throw new Error("Missing target model. Usage: openmates benchmark model <provider/model> [model-b] --confirm-spend-credits");
+  }
+  const compare = flags.compare === true;
+  if (targetModels.length > 1 && !compare) {
+    throw new Error("Multiple target models require --compare.");
+  }
+  if (compare && targetModels.length < 2) {
+    throw new Error("--compare requires at least two target models.");
+  }
+  const judgeModel = typeof flags["judge-model"] === "string" ? flags["judge-model"] : DEFAULT_JUDGE_MODEL;
+  const suites = parseSuites(flags.suite);
+  const runs = parseRuns(flags.runs);
+  const extensiveSize = parseExtensiveSize(flags["extensive-size"]);
+  const parallel = parseParallel(flags.parallel);
+  const caseIds = parseCaseIds(flags.case);
+  const dryRun = flags["dry-run"] === true;
+  const output = typeof flags.output === "string" ? flags.output : void 0;
+  const runId = typeof flags["run-id"] === "string" ? flags["run-id"] : randomUUID3();
+  const imagePath = typeof flags.image === "string" ? resolve5(flags.image) : defaultImageFixturePath();
+  if (!dryRun && flags["confirm-spend-credits"] !== true) {
+    throw new Error(
+      "Benchmark runs spend real credits from the logged-in account. Rerun with --confirm-spend-credits, or use --dry-run to preview the plan."
+    );
+  }
+  const cases = filterCases(expandCases(suites, runs, extensiveSize), caseIds);
+  const pricing = loadPricingForModels([...targetModels, judgeModel]);
+  const estimate = estimateCredits(cases, targetModels, judgeModel, pricing);
+  const result = makeBaseResult({
+    runId,
+    targetModels,
+    judgeModel,
+    suites,
+    runs,
+    compare,
+    parallel,
+    extensiveSize,
+    dryRun,
+    estimate,
+    totalJobs: cases.length * targetModels.length
+  });
+  if (dryRun) {
+    writeBenchmarkResult(result, flags, output);
+    return;
+  }
+  if (!client.hasSession()) {
+    throw new Error("Benchmark runs require login. Run 'openmates login' first.");
+  }
+  let interrupted = false;
+  const onInterrupt = () => {
+    interrupted = true;
+  };
+  process.once("SIGINT", onInterrupt);
+  try {
+    const jobs = cases.flatMap((benchmarkCase) => targetModels.map((model) => ({ model, benchmarkCase })));
+    await runPool(jobs, parallel, async (job) => {
+      if (interrupted) return;
+      const caseResult = await runCaseJob({ client, job, judgeModel, runId, imagePath });
+      result.cases.push(caseResult);
+      recomputeResult(result, jobs.length, interrupted);
+    });
+  } finally {
+    process.off("SIGINT", onInterrupt);
+  }
+  recomputeResult(result, cases.length * targetModels.length, interrupted);
+  writeBenchmarkResult(result, flags, output);
+}
+function printBenchmarkHelp() {
+  console.log(`Benchmark commands:
+  openmates benchmark model <provider/model> [provider/model...] --confirm-spend-credits [--compare] [--suite quick|extensive|all] [--json]
+
+Runs real incognito chat requests through the OpenMates product path. Live runs
+spend the logged-in user's credits and usage entries are grouped as benchmark spend.
+
+Options:
+  --confirm-spend-credits       Required for live benchmark runs
+  --dry-run                     Preview the benchmark plan without inference or spend
+  --compare                     Compare two or more target models
+  --suite <list>                Comma-separated suites: quick, extensive, all (default: quick)
+  --case <id[,id...]>           Run only specific case id(s) from the selected suites
+  --extensive-size <n>          Extensive cases to run: 5, 10, or 20 (default: ${DEFAULT_EXTENSIVE_SIZE})
+  --runs <n>                    Repeat each selected case (default: 1)
+  --parallel <n>                Concurrent target case requests (default: ${DEFAULT_PARALLEL})
+  --judge-model <provider/model> Judge for evaluated cases (default: ${DEFAULT_JUDGE_MODEL})
+  --image <path>                Override default Brandenburger Tor image fixture
+  --run-id <id>                 Reuse a benchmark run id for grouping
+  --output <path>               Save JSON result to a file
+  --json                        Print JSON result`);
+}
+function parseSuites(value) {
+  if (value === void 0 || value === false) return ["quick"];
+  if (value === true) throw new Error("--suite requires a value");
+  const suites = value.split(",").map((suite) => suite.trim()).filter(Boolean);
+  if (suites.includes("all")) return ["quick", "extensive"];
+  const allowed = /* @__PURE__ */ new Set(["quick", "extensive"]);
+  const invalid = suites.filter((suite) => !allowed.has(suite));
+  if (invalid.length > 0 || suites.length === 0) {
+    throw new Error("Invalid --suite. Use quick, extensive, or all.");
+  }
+  return [...new Set(suites)];
+}
+function parseRuns(value) {
+  if (value === void 0 || value === false) return 1;
+  if (value === true) throw new Error("--runs requires a value");
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 20) {
+    throw new Error("--runs must be an integer from 1 to 20");
+  }
+  return parsed;
+}
+function parseExtensiveSize(value) {
+  if (value === void 0 || value === false) return DEFAULT_EXTENSIVE_SIZE;
+  if (value === true) throw new Error("--extensive-size requires a value");
+  const parsed = Number.parseInt(value, 10);
+  if (![5, 10, 20].includes(parsed)) {
+    throw new Error("--extensive-size must be 5, 10, or 20");
+  }
+  return parsed;
+}
+function parseParallel(value) {
+  if (value === void 0 || value === false) return DEFAULT_PARALLEL;
+  if (value === true) throw new Error("--parallel requires a value");
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 20) {
+    throw new Error("--parallel must be an integer from 1 to 20");
+  }
+  return parsed;
+}
+function parseCaseIds(value) {
+  if (value === void 0 || value === false) return [];
+  if (value === true) throw new Error("--case requires a case id");
+  const caseIds = value.split(",").map((caseId) => caseId.trim()).filter(Boolean);
+  if (caseIds.length === 0) throw new Error("--case requires at least one case id");
+  return [...new Set(caseIds)];
+}
+function filterCases(cases, caseIds) {
+  if (caseIds.length === 0) return cases;
+  const availableIds = new Set(cases.map((benchmarkCase) => benchmarkCase.id));
+  const missing = caseIds.filter((caseId) => !availableIds.has(caseId));
+  if (missing.length > 0) {
+    throw new Error(
+      `Unknown benchmark case id(s): ${missing.join(", ")}. Available in selected suite(s): ${[...availableIds].sort().join(", ")}`
+    );
+  }
+  return cases.filter((benchmarkCase) => caseIds.includes(benchmarkCase.id));
+}
+function expandCases(suites, runs, extensiveSize) {
+  const selected = [];
+  if (suites.includes("quick")) selected.push(...QUICK_CASES);
+  if (suites.includes("extensive")) selected.push(...selectExtensiveCases(extensiveSize));
+  const uniqueSelected = dedupeCases(selected);
+  const expanded = [];
+  for (let run = 1; run <= runs; run += 1) {
+    for (const benchmarkCase of uniqueSelected) expanded.push({ ...benchmarkCase, run });
+  }
+  return expanded;
+}
+function selectExtensiveCases(size) {
+  const cases = dedupeCases(EXTENSIVE_CASES).slice(0, size);
+  const minimumCoding = Math.ceil(size * 0.15);
+  const codingCount = cases.filter((benchmarkCase) => benchmarkCase.category === "coding").length;
+  if (codingCount >= minimumCoding) return cases;
+  const selectedIds = new Set(cases.map((benchmarkCase) => benchmarkCase.id));
+  const codingBackfill = EXTENSIVE_CASES.filter(
+    (benchmarkCase) => benchmarkCase.category === "coding" && !selectedIds.has(benchmarkCase.id)
+  );
+  const result = [...cases];
+  for (const codingCase of codingBackfill) {
+    let replaceIndex = -1;
+    for (let index = result.length - 1; index >= 0; index -= 1) {
+      if (result[index]?.category !== "coding") {
+        replaceIndex = index;
+        break;
+      }
+    }
+    if (replaceIndex === -1) break;
+    result[replaceIndex] = codingCase;
+    if (result.filter((benchmarkCase) => benchmarkCase.category === "coding").length >= minimumCoding) break;
+  }
+  return result;
+}
+function dedupeCases(cases) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const benchmarkCase of cases) {
+    if (seen.has(benchmarkCase.id)) continue;
+    seen.add(benchmarkCase.id);
+    result.push(benchmarkCase);
+  }
+  return result;
+}
+async function runCaseJob(params) {
+  const { client, job, judgeModel, runId, imagePath } = params;
+  const { model, benchmarkCase } = job;
+  const startedAt = Date.now();
+  const turns = [];
+  const history = benchmarkCase.longContext ? buildLongContextHistory() : [];
+  let chatId;
+  try {
+    const initialPrompt = await buildPromptWithAttachments(client, benchmarkCase, model, imagePath);
+    const targetResponse = await sendBenchmarkTurn({
+      client,
+      model,
+      judgeModel,
+      runId,
+      benchmarkCase,
+      prompt: initialPrompt.message,
+      chatId,
+      history,
+      preparedEmbeds: initialPrompt.embeds,
+      caseId: benchmarkCase.id
+    });
+    chatId = targetResponse.chatId;
+    turns.push(targetResponse.turn);
+    appendHistory(history, "user", initialPrompt.message);
+    appendHistory(history, "assistant", targetResponse.turn.assistant);
+    for (const [index, followUp] of (benchmarkCase.followUps ?? []).entries()) {
+      const response = await sendBenchmarkTurn({
+        client,
+        model,
+        judgeModel,
+        runId,
+        benchmarkCase,
+        prompt: `${modelMention(model)} ${followUp.prompt}`,
+        chatId,
+        history,
+        caseId: `${benchmarkCase.id}:followup-${index + 1}`
+      });
+      chatId = response.chatId;
+      turns.push(response.turn);
+      appendHistory(history, "user", response.rawPrompt);
+      appendHistory(history, "assistant", response.turn.assistant);
+    }
+    const assistant = turns.at(-1)?.assistant ?? "";
+    const caseResult = {
+      id: benchmarkCase.id,
+      suite: benchmarkCase.suite,
+      title: benchmarkCase.title,
+      model,
+      run: benchmarkCase.run,
+      complexity: benchmarkCase.complexity,
+      category: benchmarkCase.category,
+      prompt: benchmarkCase.prompt,
+      assistant,
+      modelName: turns.at(-1)?.modelName ?? null,
+      passed: benchmarkCase.expectedIncludes ? assistant.includes(benchmarkCase.expectedIncludes) : true,
+      durationMs: Date.now() - startedAt,
+      expectedIncludes: benchmarkCase.expectedIncludes,
+      turns
+    };
+    if (benchmarkCase.judge) {
+      caseResult.judge = await judgeCase({ client, judgeModel, targetModel: model, benchmarkCase, caseResult, runId });
+      caseResult.passed = caseResult.judge.score !== null && caseResult.judge.score >= 4 && caseResult.passed;
+    }
+    return caseResult;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      id: benchmarkCase.id,
+      suite: benchmarkCase.suite,
+      title: benchmarkCase.title,
+      model,
+      run: benchmarkCase.run,
+      complexity: benchmarkCase.complexity,
+      category: benchmarkCase.category,
+      prompt: benchmarkCase.prompt,
+      assistant: turns.at(-1)?.assistant ?? "",
+      modelName: turns.at(-1)?.modelName ?? null,
+      passed: false,
+      durationMs: Date.now() - startedAt,
+      expectedIncludes: benchmarkCase.expectedIncludes,
+      turns,
+      error: message
+    };
+  }
+}
+async function sendBenchmarkTurn(params) {
+  const startedAt = Date.now();
+  const response = await params.client.sendMessage({
+    message: params.prompt,
+    chatId: params.chatId,
+    incognito: true,
+    autoApproveSubChats: true,
+    benchmarkMetadata: benchmarkMetadata({
+      runId: params.runId,
+      suite: params.benchmarkCase.suite,
+      caseId: params.caseId,
+      targetModel: params.model,
+      judgeModel: params.judgeModel
+    }),
+    messageHistory: params.history,
+    preparedEmbeds: params.preparedEmbeds,
+    precollectResponse: true
+  });
+  return {
+    chatId: response.chatId,
+    rawPrompt: params.prompt,
+    turn: {
+      prompt: params.prompt,
+      assistant: response.assistant,
+      modelName: response.modelName,
+      durationMs: Date.now() - startedAt
+    }
+  };
+}
+async function buildPromptWithAttachments(client, benchmarkCase, model, imagePath) {
+  const baseMessage = `${modelMention(model)} ${benchmarkCase.prompt}`;
+  if (benchmarkCase.image !== "default") return { message: baseMessage };
+  const attachment = await prepareImageAttachment(client, imagePath);
+  return { message: `${baseMessage}
+
+${attachment.messageSuffix}`, embeds: attachment.embeds };
+}
+async function prepareImageAttachment(client, imagePath) {
+  if (!existsSync6(imagePath)) throw new Error(`Benchmark image not found: ${imagePath}`);
+  const processed = processFiles([imagePath], null);
+  if (processed.blocked.length > 0 || processed.errors.length > 0 || processed.embeds.length === 0) {
+    const reason = [...processed.blocked, ...processed.errors].map((entry) => entry.error).join("; ") || "no image embed produced";
+    throw new Error(`Failed to prepare benchmark image: ${reason}`);
+  }
+  const fileEmbed = processed.embeds[0];
+  if (!fileEmbed.requiresUpload || !fileEmbed.localPath) {
+    return { messageSuffix: fileEmbed.referenceBlock, embeds: [fileEmbed.embed] };
+  }
+  await uploadBenchmarkImage(client, fileEmbed);
+  return { messageSuffix: fileEmbed.referenceBlock, embeds: [fileEmbed.embed] };
+}
+async function uploadBenchmarkImage(client, fileEmbed) {
+  if (!fileEmbed.localPath) return;
+  const uploadResult = await uploadFile(fileEmbed.localPath, client.getSession());
+  const embedRef = fileEmbed.embed.embedRef ?? `benchmark-image-${uploadResult.embed_id.slice(0, 8)}`;
+  fileEmbed.embed.embedRef = embedRef;
+  fileEmbed.embed.content = toonEncodeContent({
+    type: "image",
+    app_id: "images",
+    skill_id: "upload",
+    status: "finished",
+    filename: fileEmbed.displayName,
+    embed_ref: embedRef,
+    content_hash: uploadResult.content_hash,
+    s3_base_url: uploadResult.s3_base_url,
+    files: uploadResult.files,
+    aes_key: uploadResult.aes_key,
+    aes_nonce: uploadResult.aes_nonce,
+    vault_wrapped_aes_key: uploadResult.vault_wrapped_aes_key,
+    ai_detection: uploadResult.ai_detection
+  });
+  fileEmbed.embed.status = "finished";
+  fileEmbed.embed.contentHash = uploadResult.content_hash;
+  fileEmbed.embed.embedId = uploadResult.embed_id;
+  fileEmbed.referenceBlock = createBenchmarkEmbedReferenceBlock(fileEmbed.embed.embedId, fileEmbed.embed.type);
+}
+function createBenchmarkEmbedReferenceBlock(embedId, embedType) {
+  return `
+
+\`\`\`json
+${JSON.stringify({ type: embedType, embed_id: embedId })}
+\`\`\``;
+}
+async function judgeCase(params) {
+  const startedAt = Date.now();
+  const judgeResponse = await params.client.sendMessage({
+    message: `${modelMention(params.judgeModel)} ${judgePrompt(params.targetModel, params.benchmarkCase, params.caseResult)}`,
+    incognito: true,
+    autoApproveSubChats: true,
+    benchmarkMetadata: benchmarkMetadata({
+      runId: params.runId,
+      suite: params.benchmarkCase.suite,
+      caseId: `${params.benchmarkCase.id}:judge:${params.targetModel}`,
+      targetModel: params.targetModel,
+      judgeModel: params.judgeModel
+    }),
+    precollectResponse: true
+  });
+  const judgment = parseJudgment(judgeResponse.assistant);
+  return {
+    model: params.judgeModel,
+    score: judgment.score,
+    reason: judgment.reason,
+    raw: judgeResponse.assistant,
+    durationMs: Date.now() - startedAt
+  };
+}
+async function runPool(items, parallel, worker) {
+  let index = 0;
+  const workers = Array.from({ length: Math.min(parallel, items.length) }, async () => {
+    while (index < items.length) {
+      const item = items[index];
+      index += 1;
+      await worker(item);
+    }
+  });
+  await Promise.all(workers);
+}
+function buildLongContextHistory() {
+  const now = Math.floor(Date.now() / 1e3) - 2e3;
+  const topics = [
+    ["user", "We need to launch a CLI benchmark for model comparisons."],
+    ["assistant", "The first goal should be a quick suite with deterministic checks."],
+    ["user", "The benchmark also needs image inference."],
+    ["assistant", "Use a public fixture image and ask a factual visual question."],
+    ["user", "We should avoid wasting credits."],
+    ["assistant", "Run a pricing preflight and require explicit spend confirmation."],
+    ["user", "What about longer conversations?"],
+    ["assistant", "Add a 20-message predefined history and a dependent follow-up."],
+    ["user", "The extensive suite should not be too small."],
+    ["assistant", "Default to 10 cases and allow 5 or 20 as alternatives."],
+    ["user", "Coding quality matters."],
+    ["assistant", "Reserve at least 15 percent of extensive cases for coding prompts."],
+    ["user", "We also need comparison mode."],
+    ["assistant", "Accept multiple models with --compare and run target jobs in parallel."],
+    ["user", "How should judging work?"],
+    ["assistant", "Judge each completed case immediately with Gemini so partial results remain useful."],
+    ["user", "What if the process is interrupted?"],
+    ["assistant", "Print or write a partial summary with completed judgments and skipped counts."],
+    ["user", "What is the best launch strategy?"],
+    ["assistant", "Ship quick and comparison first, then use extensive for slower releases."]
+  ];
+  return topics.map(([role, content], index) => ({
+    message_id: `benchmark-history-${index + 1}`,
+    role,
+    sender_name: role === "user" ? "User" : "Assistant",
+    content,
+    created_at: now + index * 30
+  }));
+}
+function appendHistory(history, role, content) {
+  history.push({
+    message_id: randomUUID3(),
+    role,
+    sender_name: role === "user" ? "User" : "Assistant",
+    content,
+    created_at: Math.floor(Date.now() / 1e3)
+  });
+}
+function modelMention(model) {
+  const separator = model.indexOf("/");
+  if (separator === -1) return `@ai-model:${model}`;
+  const provider = model.slice(0, separator);
+  const modelId = model.slice(separator + 1);
+  if (!provider || !modelId) return `@ai-model:${model}`;
+  return `@ai-model:${modelId}:${provider}`;
+}
+function benchmarkMetadata(params) {
+  return {
+    source: "benchmark",
+    benchmark_run_id: params.runId,
+    benchmark_suite: params.suite,
+    benchmark_case: params.caseId,
+    benchmark_target_model: params.targetModel,
+    benchmark_judge_model: params.judgeModel
+  };
+}
+function judgePrompt(targetModel, benchmarkCase, result) {
+  return [
+    "You are judging a real OpenMates model benchmark response.",
+    "Return exactly two plain-text lines, with no markdown, no code block, and no tool use.",
+    "Line 1 format: BENCHMARK_SCORE=<integer from 1 to 5>",
+    "Line 2 format: BENCHMARK_REASON=<one short sentence>",
+    "Score for correctness, instruction-following, usefulness, and continuity where relevant.",
+    `Target model: ${targetModel}`,
+    `Benchmark case: ${benchmarkCase.id} (${benchmarkCase.category}, ${benchmarkCase.complexity})`,
+    `Initial prompt: ${JSON.stringify(benchmarkCase.prompt)}`,
+    `Turns: ${JSON.stringify(result.turns.map((turn) => ({ prompt: turn.prompt, assistant: turn.assistant })))}`
+  ].join("\n");
+}
+function parseJudgment(answer) {
+  const markerScore = answer.match(/BENCHMARK_SCORE\s*=\s*([1-5])/i);
+  if (markerScore) {
+    const reasonMatch = answer.match(/BENCHMARK_REASON\s*=\s*(.+)/i);
+    return {
+      score: Number.parseInt(markerScore[1], 10),
+      reason: reasonMatch?.[1]?.trim() ?? null
+    };
+  }
+  const jsonText = extractJsonObject(answer);
+  if (!jsonText) return { score: null, reason: null };
+  try {
+    const parsed = JSON.parse(jsonText);
+    const score = typeof parsed.score === "number" && Number.isFinite(parsed.score) ? parsed.score : null;
+    const reason = typeof parsed.reason === "string" ? parsed.reason : null;
+    return { score, reason };
+  } catch {
+    return { score: null, reason: null };
+  }
+}
+function extractJsonObject(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fenced) return fenced[1];
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+  return text.slice(start, end + 1);
+}
+function loadPricingForModels(models) {
+  const availablePricing = loadProviderPricing();
+  const pricing = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const model of [...new Set(models)]) {
+    const key = normalizeModelKey(model);
+    const modelPricing = availablePricing.get(key);
+    if (!modelPricing) {
+      missing.push(model);
+      continue;
+    }
+    pricing.set(model, modelPricing);
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Cannot estimate benchmark cost because pricing metadata is unavailable for: ${missing.join(", ")}. Use provider/model ids with backend provider pricing metadata.`
+    );
+  }
+  return pricing;
+}
+function loadProviderPricing() {
+  const providersDir = findProvidersDir();
+  const pricing = /* @__PURE__ */ new Map();
+  if (!providersDir) return pricing;
+  for (const fileName of readdirSync(providersDir)) {
+    if (!fileName.endsWith(".yml")) continue;
+    const filePath = join4(providersDir, fileName);
+    const text = readFileSync6(filePath, "utf-8");
+    const provider = parseProviderId(text) ?? fileName.replace(/\.yml$/, "");
+    for (const modelPricing of parseModelPricing(text, provider)) {
+      pricing.set(`${modelPricing.provider}/${modelPricing.modelId}`, modelPricing);
+      pricing.set(modelPricing.modelId, modelPricing);
+    }
+  }
+  return pricing;
+}
+function parseProviderId(text) {
+  const match = text.match(/^provider_id:\s*["']?([^"'\n]+)["']?/m);
+  return match?.[1]?.trim() ?? null;
+}
+function parseModelPricing(text, provider) {
+  const lines = text.split("\n");
+  const results = [];
+  let modelId = null;
+  let inModel = false;
+  let inputTokensPerCredit = null;
+  let outputTokensPerCredit = null;
+  for (const line of lines) {
+    const modelMatch = line.match(/^\s{2}-\s+id:\s*["']?([^"'\n#]+)["']?/);
+    if (modelMatch) {
+      if (inModel && modelId && inputTokensPerCredit && outputTokensPerCredit) {
+        results.push({ provider, modelId, inputTokensPerCredit, outputTokensPerCredit });
+      }
+      inModel = true;
+      modelId = modelMatch[1].trim();
+      inputTokensPerCredit = null;
+      outputTokensPerCredit = null;
+      continue;
+    }
+    if (!inModel) continue;
+    const inputMatch = line.match(/^\s{10}per_credit_unit:\s*(\d+)/);
+    if (inputMatch && inputTokensPerCredit === null) {
+      inputTokensPerCredit = Number.parseInt(inputMatch[1], 10);
+      continue;
+    }
+    if (inputMatch && inputTokensPerCredit !== null && outputTokensPerCredit === null) {
+      outputTokensPerCredit = Number.parseInt(inputMatch[1], 10);
+    }
+  }
+  if (inModel && modelId && inputTokensPerCredit && outputTokensPerCredit) {
+    results.push({ provider, modelId, inputTokensPerCredit, outputTokensPerCredit });
+  }
+  return results;
+}
+function normalizeModelKey(model) {
+  return model.includes("/") ? model : model;
+}
+function findProvidersDir() {
+  const currentFile = fileURLToPath(import.meta.url);
+  let current = dirname2(currentFile);
+  for (let index = 0; index < 8; index += 1) {
+    const candidate = join4(current, "backend", "providers");
+    if (existsSync6(candidate)) return candidate;
+    const parentCandidate = join4(current, "..", "..", "backend", "providers");
+    if (existsSync6(parentCandidate)) return resolve5(parentCandidate);
+    const next = dirname2(current);
+    if (next === current) break;
+    current = next;
+  }
+  return null;
+}
+function estimateCredits(cases, targetModels, judgeModel, pricing) {
+  let targetCredits = 0;
+  let judgeCredits = 0;
+  let targetInputTokens = 0;
+  let targetOutputTokens = 0;
+  let judgeInputTokens = 0;
+  let judgeOutputTokens = 0;
+  for (const benchmarkCase of cases) {
+    const turnCount = 1 + (benchmarkCase.followUps?.length ?? 0);
+    for (const model of targetModels) {
+      const modelPricing = pricing.get(model);
+      if (!modelPricing) continue;
+      const input = benchmarkCase.estimatedInputTokens * turnCount;
+      const output = benchmarkCase.estimatedOutputTokens * turnCount;
+      targetInputTokens += input;
+      targetOutputTokens += output;
+      targetCredits += creditsFor(modelPricing, input, output);
+      if (benchmarkCase.judge) {
+        const judgePricing = pricing.get(judgeModel);
+        if (!judgePricing) continue;
+        const judgeInput = Math.max(2e3, Math.ceil(output * 1.5));
+        const judgeOutput = 350;
+        judgeInputTokens += judgeInput;
+        judgeOutputTokens += judgeOutput;
+        judgeCredits += creditsFor(judgePricing, judgeInput, judgeOutput);
+      }
+    }
+  }
+  return {
+    targetCredits,
+    judgeCredits,
+    totalCredits: targetCredits + judgeCredits,
+    assumptions: { targetInputTokens, targetOutputTokens, judgeInputTokens, judgeOutputTokens }
+  };
+}
+function creditsFor(pricing, inputTokens, outputTokens) {
+  return Math.ceil(inputTokens / pricing.inputTokensPerCredit) + Math.ceil(outputTokens / pricing.outputTokensPerCredit);
+}
+function makeBaseResult(params) {
+  return {
+    command: "benchmark model",
+    status: params.dryRun ? "planned" : "completed",
+    runId: params.runId,
+    targetModel: params.targetModels[0],
+    targetModels: params.targetModels,
+    judgeModel: params.judgeModel,
+    suites: params.suites,
+    runs: params.runs,
+    compare: params.compare,
+    parallel: params.parallel,
+    extensiveSize: params.extensiveSize,
+    spendsCredits: !params.dryRun,
+    estimatedCredits: params.estimate,
+    cases: [],
+    modelSummaries: params.targetModels.map((model) => ({
+      model,
+      total: 0,
+      passed: 0,
+      failed: 0,
+      averageJudgeScore: null,
+      averageDurationMs: null
+    })),
+    summary: {
+      total: params.totalJobs,
+      completed: 0,
+      passed: 0,
+      failed: 0,
+      skipped: params.dryRun ? params.totalJobs : 0,
+      interrupted: false
+    }
+  };
+}
+function recomputeResult(result, totalJobs, interrupted) {
+  const completed = result.cases.length;
+  const passed = result.cases.filter((caseResult) => caseResult.passed).length;
+  const failed = result.cases.filter((caseResult) => !caseResult.passed).length;
+  result.summary = {
+    total: totalJobs,
+    completed,
+    passed,
+    failed,
+    skipped: Math.max(0, totalJobs - completed),
+    interrupted
+  };
+  result.status = interrupted || completed < totalJobs ? "partial" : "completed";
+  result.modelSummaries = result.targetModels.map((model) => summarizeModel(model, result.cases));
+  if (result.compare) result.comparison = buildComparison(result.modelSummaries);
+}
+function summarizeModel(model, cases) {
+  const modelCases = cases.filter((caseResult) => caseResult.model === model);
+  const scores = modelCases.map((caseResult) => caseResult.judge?.score).filter((score) => typeof score === "number" && Number.isFinite(score));
+  const durations = modelCases.map((caseResult) => caseResult.durationMs).filter((value) => value > 0);
+  return {
+    model,
+    total: modelCases.length,
+    passed: modelCases.filter((caseResult) => caseResult.passed).length,
+    failed: modelCases.filter((caseResult) => !caseResult.passed).length,
+    averageJudgeScore: scores.length > 0 ? round2(scores.reduce((sum, score) => sum + score, 0) / scores.length) : null,
+    averageDurationMs: durations.length > 0 ? Math.round(durations.reduce((sum, value) => sum + value, 0) / durations.length) : null
+  };
+}
+function buildComparison(summaries) {
+  const ranking = [...summaries].sort((a, b) => (b.averageJudgeScore ?? -1) - (a.averageJudgeScore ?? -1) || b.passed - a.passed).map((summary) => ({
+    model: summary.model,
+    averageJudgeScore: summary.averageJudgeScore,
+    passed: summary.passed,
+    total: summary.total
+  }));
+  const notes = ranking.length > 0 ? [`Top model so far: ${ranking[0].model} (${ranking[0].passed}/${ranking[0].total} passed).`] : [];
+  return { ranking, notes };
+}
+function round2(value) {
+  return Math.round(value * 100) / 100;
+}
+function defaultImageFixturePath() {
+  const fixtureDir = join4(dirname2(fileURLToPath(import.meta.url)), "..", "fixtures");
+  const fixturePath = join4(fixtureDir, "brandenburger-tor.png");
+  if (existsSync6(fixturePath)) return fixturePath;
+  const tempDir = mkdtempSync(join4(tmpdir(), "openmates-benchmark-"));
+  const tempPath = join4(tempDir, "brandenburger-tor.svg");
+  writeFileSync4(tempPath, FIXTURE_IMAGE_SVG, "utf-8");
+  return tempPath;
+}
+function writeBenchmarkResult(result, flags, output) {
+  const json = `${JSON.stringify(result, null, 2)}
+`;
+  if (output) writeFileSync4(output, json, "utf-8");
+  if (flags.json === true || output) {
+    process.stdout.write(json);
+    return;
+  }
+  console.log(`Benchmark ${result.status}: ${result.targetModels.join(", ")}`);
+  console.log(`Run ID: ${result.runId}`);
+  console.log(`Suites: ${result.suites.join(", ")}`);
+  console.log(`Judge: ${result.judgeModel}`);
+  console.log(`Estimated credits: ${result.estimatedCredits.totalCredits}`);
+  console.log(`Spend credits: ${result.spendsCredits ? "yes" : "no"}`);
+  if (result.status !== "planned") {
+    console.log(`Passed: ${result.summary.passed}/${result.summary.completed} completed (${result.summary.skipped} skipped)`);
+    for (const benchmarkCase of result.cases) {
+      const mark = benchmarkCase.passed ? "PASS" : "FAIL";
+      const judge = benchmarkCase.judge ? ` judge=${benchmarkCase.judge.score ?? "unparsed"}` : "";
+      const error = benchmarkCase.error ? ` error=${benchmarkCase.error}` : "";
+      console.log(`${mark} ${benchmarkCase.model} ${benchmarkCase.suite}/${benchmarkCase.id} (${benchmarkCase.durationMs}ms)${judge}${error}`);
+    }
+  }
+}
+
 // src/cli.ts
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
@@ -41536,6 +43349,10 @@ async function main() {
       printSettingsHelp(client);
       return;
     }
+    if (command === "learning-mode") {
+      printLearningModeHelp();
+      return;
+    }
     if (command === "signup") {
       printSignupHelp();
       return;
@@ -41572,6 +43389,10 @@ async function main() {
       printDocsHelp();
       return;
     }
+    if (command === "benchmark") {
+      printBenchmarkHelp();
+      return;
+    }
     printHelp();
     return;
   }
@@ -41630,6 +43451,10 @@ async function main() {
     await handleSettings(client, subcommand, rest, parsed.flags);
     return;
   }
+  if (command === "learning-mode") {
+    await handleLearningMode(client, subcommand, parsed.flags);
+    return;
+  }
   if (command === "inspirations") {
     await handleInspirations(client, parsed.flags);
     return;
@@ -41642,10 +43467,22 @@ async function main() {
     handleFeedback(subcommand, rest, parsed.flags);
     return;
   }
+  if (command === "benchmark") {
+    await handleBenchmark(client, subcommand, rest, parsed.flags);
+    return;
+  }
   throw new Error(`Unknown command '${command}'. Run 'openmates help'.`);
 }
 function shouldInitializeRedactor(command, subcommand) {
-  return command === "chats" && ["new", "send", "incognito"].includes(subcommand ?? "");
+  return command === "chats" && ["new", "send", "answer-interactive", "incognito"].includes(subcommand ?? "");
+}
+function parseJsonFlag(value, flagName) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON for ${flagName}: ${message}`);
+  }
 }
 async function handleChats(client, subcommand, rest, flags, redactor) {
   if (!subcommand || subcommand === "help" || flags.help === true) {
@@ -41698,7 +43535,8 @@ async function handleChats(client, subcommand, rest, flags, redactor) {
         json: flags.json === true,
         autoApproveSubChats: flags["auto-approve"] === true,
         autoApproveMemories: flags["auto-approve-memories"] === true,
-        piiDetection: flags["no-pii-detection"] !== true
+        piiDetection: flags["no-pii-detection"] !== true,
+        anonymousLearningMode: client.hasSession() ? void 0 : parseAnonymousLearningModeFlags(flags)
       },
       redactor
     );
@@ -41779,6 +43617,34 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
     if (flags.json === true) printJson2(result);
     return;
   }
+  if (subcommand === "answer-interactive") {
+    const chatId = typeof flags.chat === "string" ? flags.chat : void 0;
+    const questionJson = typeof flags["question-json"] === "string" ? flags["question-json"] : void 0;
+    const answerJson = typeof flags["answer-json"] === "string" ? flags["answer-json"] : void 0;
+    if (!chatId || !questionJson || !answerJson) {
+      throw new Error(
+        "Missing interactive answer data. Usage: openmates chats answer-interactive --chat <id> --question-json '<json>' --answer-json '<json>'"
+      );
+    }
+    const question = parseJsonFlag(questionJson, "--question-json");
+    const answer = parseJsonFlag(answerJson, "--answer-json");
+    const formatted = formatInteractiveQuestionAnswer(question, answer);
+    const result = await sendMessageStreaming(
+      client,
+      {
+        message: formatted.messageContent,
+        chatId,
+        incognito: false,
+        json: flags.json === true,
+        autoApproveSubChats: flags["auto-approve"] === true,
+        autoApproveMemories: flags["auto-approve-memories"] === true,
+        piiDetection: flags["no-pii-detection"] !== true
+      },
+      redactor
+    );
+    if (flags.json === true) printJson2(result);
+    return;
+  }
   if (subcommand === "incognito") {
     const message = rest.join(" ").trim();
     if (!message)
@@ -41878,10 +43744,10 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         input: process.stdin,
         output: process.stdout
       });
-      const answer = await new Promise((resolve5) => {
+      const answer = await new Promise((resolve6) => {
         iface.question(
           `Delete ${resolved.length} chat(s)? This cannot be undone. [y/N] `,
-          resolve5
+          resolve6
         );
       });
       iface.close();
@@ -42041,16 +43907,16 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
       }
     }
     const { mkdir, writeFile } = await import("fs/promises");
-    const { join: join4 } = await import("path");
+    const { join: join5 } = await import("path");
     if (useZip) {
-      const tmpDir = join4(outputDir, `.${filenameBase}_tmp`);
+      const tmpDir = join5(outputDir, `.${filenameBase}_tmp`);
       await mkdir(tmpDir, { recursive: true });
-      await writeFile(join4(tmpDir, `${filenameBase}.yml`), yamlContent);
-      await writeFile(join4(tmpDir, `${filenameBase}.md`), mdContent);
+      await writeFile(join5(tmpDir, `${filenameBase}.yml`), yamlContent);
+      await writeFile(join5(tmpDir, `${filenameBase}.md`), mdContent);
       if (codeEmbeds.length > 0) {
         for (const ce of codeEmbeds) {
           const fpath = ce.filePath ?? ce.filename ?? `${ce.embedId.slice(0, 8)}.${getExtForLang(ce.language)}`;
-          const fullPath = join4(tmpDir, "code", fpath);
+          const fullPath = join5(tmpDir, "code", fpath);
           await mkdir(fullPath.substring(0, fullPath.lastIndexOf("/")), {
             recursive: true
           });
@@ -42058,13 +43924,13 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
         }
       }
       if (transcriptEmbeds.length > 0) {
-        const tDir = join4(tmpDir, "transcripts");
+        const tDir = join5(tmpDir, "transcripts");
         await mkdir(tDir, { recursive: true });
         for (const te of transcriptEmbeds) {
-          await writeFile(join4(tDir, te.filename), te.content);
+          await writeFile(join5(tDir, te.filename), te.content);
         }
       }
-      const zipPath = join4(outputDir, `${filenameBase}.zip`);
+      const zipPath = join5(outputDir, `${filenameBase}.zip`);
       const { execSync: execSync2 } = await import("child_process");
       try {
         execSync2(`cd "${tmpDir}" && zip -r "${zipPath}" .`, { stdio: "pipe" });
@@ -42079,17 +43945,17 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
         );
       }
     } else {
-      const chatDir = join4(outputDir, filenameBase);
+      const chatDir = join5(outputDir, filenameBase);
       await mkdir(chatDir, { recursive: true });
       const written = [];
-      await writeFile(join4(chatDir, `${filenameBase}.yml`), yamlContent);
+      await writeFile(join5(chatDir, `${filenameBase}.yml`), yamlContent);
       written.push(`${filenameBase}.yml`);
-      await writeFile(join4(chatDir, `${filenameBase}.md`), mdContent);
+      await writeFile(join5(chatDir, `${filenameBase}.md`), mdContent);
       written.push(`${filenameBase}.md`);
       if (codeEmbeds.length > 0) {
         for (const ce of codeEmbeds) {
           const fpath = ce.filePath ?? ce.filename ?? `${ce.embedId.slice(0, 8)}.${getExtForLang(ce.language)}`;
-          const fullPath = join4(chatDir, "code", fpath);
+          const fullPath = join5(chatDir, "code", fpath);
           await mkdir(fullPath.substring(0, fullPath.lastIndexOf("/")), {
             recursive: true
           });
@@ -42098,10 +43964,10 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
         }
       }
       if (transcriptEmbeds.length > 0) {
-        const tDir = join4(chatDir, "transcripts");
+        const tDir = join5(chatDir, "transcripts");
         await mkdir(tDir, { recursive: true });
         for (const te of transcriptEmbeds) {
-          await writeFile(join4(tDir, te.filename), te.content);
+          await writeFile(join5(tDir, te.filename), te.content);
           written.push(`transcripts/${te.filename}`);
         }
       }
@@ -42137,7 +44003,7 @@ ${deleted}/${resolved.length} chat(s) deleted.`);
       printJson2({
         chat_id: chat.id,
         title: chat.title,
-        output_dir: useZip ? join4(outputDir, `${filenameBase}.zip`) : join4(outputDir, filenameBase),
+        output_dir: useZip ? join5(outputDir, `${filenameBase}.zip`) : join5(outputDir, filenameBase),
         files,
         code_embeds: codeEmbeds.length,
         transcript_embeds: transcriptEmbeds.length
@@ -42658,7 +44524,7 @@ async function handleCodeRun(client, flags, apiKey) {
   }
 }
 async function streamCodeRunToTerminal(url, jsonMode) {
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve6, reject) => {
     const ws = new WebSocket2(url);
     let lastStatus = {};
     ws.on("message", (data) => {
@@ -42677,7 +44543,7 @@ async function streamCodeRunToTerminal(url, jsonMode) {
           const status = String(payload.status ?? "");
           if (["finished", "failed", "timeout", "cancelled"].includes(status)) {
             ws.close();
-            resolve5(lastStatus);
+            resolve6(lastStatus);
           }
         }
       } catch (err) {
@@ -42687,7 +44553,7 @@ async function streamCodeRunToTerminal(url, jsonMode) {
     });
     ws.on("error", () => reject(new Error("Code Run stream failed.")));
     ws.on("close", () => {
-      if (Object.keys(lastStatus).length > 0) resolve5(lastStatus);
+      if (Object.keys(lastStatus).length > 0) resolve6(lastStatus);
     });
   });
 }
@@ -42698,7 +44564,7 @@ async function pollCodeRunStatus(client, statusPath, apiKey, jsonMode) {
     if (!jsonMode && value) process.stderr.write(`Code Run status: ${value}
 `);
     if (["finished", "failed", "timeout", "cancelled"].includes(value)) return status;
-    await new Promise((resolve5) => setTimeout(resolve5, 1e3));
+    await new Promise((resolve6) => setTimeout(resolve6, 1e3));
   }
 }
 function buildSkillInput(flags, inlineTokens, schemaParams) {
@@ -42898,7 +44764,7 @@ async function handleEmbeds(client, subcommand, rest, flags) {
         throw new Error("Embed version content was not available after local reconstruction.");
       }
       if (typeof flags.output === "string") {
-        writeFileSync4(flags.output, result.content, "utf-8");
+        writeFileSync5(flags.output, result.content, "utf-8");
         if (flags.json === true) {
           printJson2({ ...result, output: flags.output });
         } else {
@@ -43039,6 +44905,25 @@ async function printSettingsMutationResult(resultPromise, flags) {
   process.stdout.write("\x1B[32m\u2713\x1B[0m Settings updated\n");
   if (result && typeof result === "object") printGenericObject(result);
 }
+function printReportIssueCreateResult(result, flags) {
+  if (flags.json === true) {
+    printJson2(result);
+    return;
+  }
+  process.stdout.write("\x1B[32m\u2713\x1B[0m Issue reported\n");
+  const obj = result && typeof result === "object" ? result : {};
+  const issueId = typeof obj.issue_id === "string" ? obj.issue_id : "";
+  const shortIssueId = typeof obj.short_issue_id === "string" ? obj.short_issue_id : "";
+  if (shortIssueId || issueId) {
+    console.log(`Issue reference: ${shortIssueId || issueId}`);
+  }
+  if (issueId && shortIssueId && issueId !== shortIssueId) {
+    console.log(`Internal issue ID: ${issueId}`);
+  }
+  if (typeof obj.message === "string") {
+    console.log(obj.message);
+  }
+}
 function addQueryParam(params, key, value) {
   if (typeof value === "string" && value.length > 0) params.set(key, value);
 }
@@ -43182,11 +45067,11 @@ function parseYamlScalar(value) {
 }
 async function saveDownloadedDocument(document, output) {
   const { mkdir, writeFile } = await import("fs/promises");
-  const { join: join4, basename: basename4, dirname: dirname2 } = await import("path");
+  const { join: join5, basename: basename4, dirname: dirname4 } = await import("path");
   const target = typeof output === "string" ? output : ".";
   const filename = basename4(document.filename || "document.pdf");
-  const filePath = target.endsWith(".pdf") ? target : join4(target, filename);
-  await mkdir(dirname2(filePath), { recursive: true });
+  const filePath = target.endsWith(".pdf") ? target : join5(target, filename);
+  await mkdir(dirname4(filePath), { recursive: true });
   await writeFile(filePath, document.data);
   return filePath;
 }
@@ -43214,7 +45099,7 @@ function printMateInfo(mateId, json) {
 async function confirmOrExit(question) {
   const rl = await import("readline");
   const iface = rl.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve5) => iface.question(question, resolve5));
+  const answer = await new Promise((resolve6) => iface.question(question, resolve6));
   iface.close();
   if (answer.trim().toLowerCase() !== "y") {
     console.log("Aborted.");
@@ -43224,7 +45109,7 @@ async function confirmOrExit(question) {
 async function promptLine(question) {
   const rl = await import("readline");
   const iface = rl.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve5) => iface.question(question, resolve5));
+  const answer = await new Promise((resolve6) => iface.question(question, resolve6));
   iface.close();
   return answer.trim();
 }
@@ -43232,7 +45117,7 @@ async function promptSecret(question) {
   if (!process.stdin.isTTY) {
     return promptLine(question);
   }
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const stdin2 = process.stdin;
     const wasRaw = stdin2.isRaw;
     let value = "";
@@ -43245,7 +45130,7 @@ async function promptSecret(question) {
         stdin2.off("data", onData);
         stdin2.setRawMode(wasRaw);
         process.stdout.write("\n");
-        resolve5(value);
+        resolve6(value);
         return;
       }
       if (char === "") {
@@ -43265,7 +45150,7 @@ async function promptSecret(question) {
 }
 async function writeSecretFile(filePath, content, force = false) {
   const { mkdir, writeFile, stat: stat2 } = await import("fs/promises");
-  const { dirname: dirname2 } = await import("path");
+  const { dirname: dirname4 } = await import("path");
   try {
     await stat2(filePath);
     if (!force) throw new Error(`${filePath} already exists. Use --force to overwrite.`);
@@ -43275,7 +45160,7 @@ async function writeSecretFile(filePath, content, force = false) {
     }
     if (error instanceof Error && !("code" in error)) throw error;
   }
-  await mkdir(dirname2(filePath), { recursive: true });
+  await mkdir(dirname4(filePath), { recursive: true });
   await writeFile(filePath, content, { mode: 384 });
   return filePath;
 }
@@ -43902,7 +45787,8 @@ async function handleSettings(client, subcommand, rest, flags) {
     const title = typeof flags.title === "string" ? flags.title : void 0;
     const body = typeof flags.body === "string" ? flags.body : void 0;
     if (!title || !body) throw new Error("Provide --title and --body.");
-    await printSettingsMutationResult(client.settingsPost("issues", { title, description: body }), flags);
+    const result = await client.settingsPost("issues", { title, description: body });
+    printReportIssueCreateResult(result, flags);
     return;
   }
   if (matches(tokens, ["report-issue", "status"])) {
@@ -43973,6 +45859,79 @@ async function handleSettings(client, subcommand, rest, flags) {
   printSettingsHelp(client, [subcommand]);
   process.exit(1);
 }
+var LEARNING_MODE_AGE_GROUPS = /* @__PURE__ */ new Set([
+  "under_10",
+  "10_12",
+  "13_15",
+  "16_18",
+  "adult"
+]);
+async function handleLearningMode(client, subcommand, flags) {
+  if (!subcommand || subcommand === "help" || flags.help === true) {
+    printLearningModeHelp();
+    return;
+  }
+  if (subcommand === "status") {
+    printLearningModeStatus(await client.getLearningModeStatus(), flags.json === true);
+    return;
+  }
+  if (subcommand === "enable") {
+    const ageGroup = parseLearningModeAgeGroup(flags["age-group"]);
+    const passcode = parseRequiredStringFlag(flags.passcode, "--passcode");
+    printLearningModeStatus(
+      await client.activateLearningMode({ ageGroup, passcode }),
+      flags.json === true
+    );
+    return;
+  }
+  if (subcommand === "disable") {
+    const passcode = parseRequiredStringFlag(flags.passcode, "--passcode");
+    printLearningModeStatus(await client.deactivateLearningMode(passcode), flags.json === true);
+    return;
+  }
+  console.error(`Unknown learning-mode command '${subcommand}'.
+`);
+  printLearningModeHelp();
+  process.exit(1);
+}
+function parseLearningModeAgeGroup(value) {
+  if (typeof value !== "string" || !LEARNING_MODE_AGE_GROUPS.has(value)) {
+    throw new Error("Provide --age-group as one of: under_10, 10_12, 13_15, 16_18, adult.");
+  }
+  return value;
+}
+function parseAnonymousLearningModeFlags(flags) {
+  if (flags["learning-mode"] !== true) return void 0;
+  return {
+    enabled: true,
+    ageGroup: parseLearningModeAgeGroup(flags["age-group"]),
+    source: "anonymous_session"
+  };
+}
+function parseRequiredStringFlag(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Provide ${name}.`);
+  }
+  return value;
+}
+function printLearningModeStatus(status, json) {
+  if (json) {
+    printJson2(status);
+    return;
+  }
+  console.log(`Learning Mode: ${status.enabled ? "enabled" : "disabled"}`);
+  if (status.age_group) console.log(`Age group: ${status.age_group}`);
+  if (status.failed_attempts > 0) console.log(`Failed disable attempts: ${status.failed_attempts}`);
+  if (status.deactivation_blocked_until) {
+    console.log(`Disable blocked until: ${new Date(status.deactivation_blocked_until * 1e3).toISOString()}`);
+  }
+}
+function learningModeStatusToContext(status) {
+  return {
+    enabled: status.enabled,
+    ageGroup: status.age_group
+  };
+}
 async function handleMemories(client, rest, flags) {
   const action = rest[0];
   if (!action || action === "help") {
@@ -44563,7 +46522,10 @@ async function sendMessageStreaming(client, params, redactor) {
   if (!client.hasSession()) {
     let result2;
     try {
-      result2 = await client.sendAnonymousMessage({ message: finalMessage });
+      result2 = await client.sendAnonymousMessage({
+        message: finalMessage,
+        learningMode: params.anonymousLearningMode
+      });
     } finally {
       clearTyping();
     }
@@ -44584,6 +46546,7 @@ async function sendMessageStreaming(client, params, redactor) {
   const urlResult = prepareUrlEmbeds(finalMessage);
   finalMessage = urlResult.message;
   preparedEmbeds.push(...urlResult.embeds);
+  const learningMode = learningModeStatusToContext(await client.getLearningModeStatus());
   const result = await client.sendMessage({
     message: finalMessage,
     chatId: params.chatId,
@@ -44593,6 +46556,7 @@ async function sendMessageStreaming(client, params, redactor) {
     onSubChatApprovalRequest,
     autoApproveSubChats: params.autoApproveSubChats,
     autoApproveMemories: params.autoApproveMemories,
+    learningMode,
     preparedEmbeds: preparedEmbeds.length > 0 ? preparedEmbeds : void 0,
     piiMappings: piiResult.mappings.map((mapping) => ({
       placeholder: mapping.placeholder,
@@ -45899,9 +47863,11 @@ Commands:
   openmates mentions [--help]                List available @mentions
   openmates embeds [--help]                  Embed commands (show)
   openmates settings [--help]                Predefined settings commands
+  openmates learning-mode [--help]           Account-wide Learning Mode controls
   openmates inspirations [--lang <code>] [--json]   Daily inspirations
   openmates newchatsuggestions [--limit <n>] [--json]   Personalized new chat suggestions
   openmates feedback [--help]                Assistant response feedback helpers
+  openmates benchmark [--help]               Run real model benchmarks with usage tagged as benchmark spend
   openmates server [--help]                   Server management (install, start, stop, ...)
   openmates docs [--help]                     Browse, search, and download documentation
   openmates e2e provision-auth-accounts       Provision local E2E auth-account artifacts
@@ -45924,6 +47890,22 @@ Options:
   --rating <1-5>  Required star rating
   --json          Output the decision contract as JSON`);
 }
+function printLearningModeHelp() {
+  console.log(`Learning Mode commands:
+  openmates learning-mode status [--json]
+  openmates learning-mode enable --age-group <group> --passcode <passcode> [--json]
+  openmates learning-mode disable --passcode <passcode> [--json]
+
+Learning Mode is account-wide and applies to CLI, web, Apple, and API chat requests.
+
+Age groups:
+  under_10, 10_12, 13_15, 16_18, adult
+
+Options:
+  --age-group <group>  Required for enable
+  --passcode <value>   Required for enable and disable
+  --json               Output backend status JSON`);
+}
 function printSignupHelp() {
   console.log(`Signup command:
   openmates signup --email <email> --username <name> --invite-code <code>
@@ -45964,9 +47946,10 @@ function printChatsHelp() {
   openmates chats show <chat-id> [--raw] [--json]
   openmates chats open [<n|example-id|slug>] [--json]
   openmates chats search <query> [--json]
-  openmates chats new <message> [--json] [--auto-approve] [--auto-approve-memories] [--no-pii-detection]
+  openmates chats new <message> [--json] [--learning-mode --age-group <group>] [--auto-approve] [--auto-approve-memories] [--no-pii-detection]
   openmates chats send [--chat <id>] [--incognito] <message> [--json] [--auto-approve] [--auto-approve-memories] [--no-pii-detection]
   openmates chats send --chat <id> --followup <n> [--json] [--auto-approve] [--auto-approve-memories]
+  openmates chats answer-interactive --chat <id> --question-json '<json>' --answer-json '<json>' [--json]
   openmates chats download <chat-id> [--output <path>] [--zip] [--json]
   openmates chats delete <id1> [id2] [id3] ... [--yes]
   openmates chats share [<chat-id>] [--expires <seconds>] [--password <pwd>] [--json]
@@ -45995,6 +47978,11 @@ Options for 'send':
                    typing the full message (requires --chat)
   --incognito      Send without saving to chat history
 
+Options for 'answer-interactive':
+  --chat <id>           Chat containing the interactive question
+  --question-json       The question payload returned by 'chats send --json'
+  --answer-json         Structured answer JSON, for example '{"selection":["opt_a"]}'
+
 Options for 'new', 'send', and 'incognito':
   --auto-approve           Automatically approve server-requested sub-chat batches.
                            Without this, the CLI prompts in the terminal like the web app.
@@ -46004,6 +47992,11 @@ Options for 'new', 'send', and 'incognito':
   --no-pii-detection       Send the message exactly as typed. By default, the CLI
                             replaces detected PII with placeholders before send.
 
+Guest-only options for logged-out 'new':
+  --learning-mode          Opt anonymous chat into request-scoped Learning Mode.
+  --age-group <group>      Required with --learning-mode: under_10, 10_12,
+                            13_15, 16_18, or adult.
+
 Options for 'download':
   --output <path>  Target directory (default: current directory)
   --zip            Create a .zip archive instead of a folder
@@ -46040,6 +48033,7 @@ Examples:
   openmates chats show "Flight Connections Berlin to Bangkok"
   openmates chats search "Madrid"
   openmates chats new "Hello, what can you help me with?"
+  openmates chats new "Help me understand fractions" --learning-mode --age-group 10_12
   openmates chats send --chat d262cb68 "follow-up question"
   openmates chats send --chat d262cb68 --followup 1
   openmates chats send --chat d262cb68 --followup 3
@@ -46232,7 +48226,7 @@ async function handleDocs(client, subcommand, rest, flags) {
   }
   if (subcommand === "download") {
     const { writeFile, mkdir } = await import("fs/promises");
-    const { join: join4, dirname: dirname2 } = await import("path");
+    const { join: join5, dirname: dirname4 } = await import("path");
     if (flags.all === true) {
       const outputDir = typeof flags.output === "string" ? flags.output : "./openmates-docs";
       const tree = await client.listDocs();
@@ -46241,8 +48235,8 @@ async function handleDocs(client, subcommand, rest, flags) {
       let count = 0;
       for (const slug2 of slugs) {
         const content2 = await client.getDoc(slug2);
-        const filePath = join4(outputDir, `${slug2}.md`);
-        await mkdir(dirname2(filePath), { recursive: true });
+        const filePath = join5(outputDir, `${slug2}.md`);
+        await mkdir(dirname4(filePath), { recursive: true });
         await writeFile(filePath, content2, "utf-8");
         count++;
         process.stderr.write(`\r  Downloaded ${count}/${slugs.length}`);
@@ -46314,8 +48308,8 @@ function isCliEntrypoint() {
   if (!entrypoint) return false;
   try {
     const invokedPath = realpathSync(entrypoint);
-    const modulePath = realpathSync(fileURLToPath(import.meta.url));
-    return invokedPath === modulePath || basename3(invokedPath) === "cli.js" && dirname(invokedPath) === dirname(modulePath);
+    const modulePath = realpathSync(fileURLToPath2(import.meta.url));
+    return invokedPath === modulePath || basename3(invokedPath) === "cli.js" && dirname3(invokedPath) === dirname3(modulePath);
   } catch {
     return false;
   }