@proxysoul/soulforge 2.15.1 → 2.15.2

package/dist/index.js

@@ -4544,6 +4544,566 @@ var init_protocol = __esm(() => {
   HEARTH_MAX_FRAME_BYTES = 1024 * 1024;
 });
 
+// src/core/utils/ensure-soulforge-dir.ts
+import { execSync as execSync2 } from "child_process";
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
+function ensureSoulforgeDir(cwd) {
+  const dir = join6(cwd, ENTRY);
+  if (!existsSync6(dir))
+    mkdirSync5(dir, { recursive: true });
+  if (!patched.has(cwd)) {
+    patched.add(cwd);
+    try {
+      ensureGitignore(cwd);
+    } catch {}
+  }
+  return dir;
+}
+function ensureGitignore(cwd) {
+  const status = gitCheckIgnoreStatus(cwd);
+  if (status !== 1)
+    return;
+  const gitignorePath = join6(cwd, ".gitignore");
+  if (existsSync6(gitignorePath)) {
+    const content = readFileSync6(gitignorePath, "utf-8");
+    const eol = content.includes(`\r
+`) ? `\r
+` : `
+`;
+    const prefix = content.length > 0 && !content.endsWith(`
+`) ? eol : "";
+    appendFileSync2(gitignorePath, `${prefix}.soulforge${eol}`);
+  } else {
+    writeFileSync5(gitignorePath, `.soulforge
+`);
+  }
+}
+function gitCheckIgnoreStatus(cwd) {
+  try {
+    execSync2("git check-ignore -q .soulforge", { cwd, stdio: "pipe", timeout: 3000 });
+    return 0;
+  } catch (err2) {
+    return err2.status ?? 128;
+  }
+}
+var ENTRY = ".soulforge", patched;
+var init_ensure_soulforge_dir = __esm(() => {
+  patched = new Set;
+});
+
+// src/config/index.ts
+var exports_config2 = {};
+__export(exports_config2, {
+  stripConfigKeys: () => stripConfigKeys,
+  saveProjectConfig: () => saveProjectConfig,
+  saveGlobalConfig: () => saveGlobalConfig,
+  saveConfig: () => saveConfig,
+  removeProjectConfigKeys: () => removeProjectConfigKeys,
+  removeGlobalConfigKeys: () => removeGlobalConfigKeys,
+  mergeConfigs: () => mergeConfigs,
+  loadProjectConfig: () => loadProjectConfig,
+  loadConfig: () => loadConfig,
+  applyConfigPatch: () => applyConfigPatch,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG
+});
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+function mergeProviders(base, overlay) {
+  if (!base && !overlay)
+    return;
+  if (!overlay)
+    return base;
+  if (!base)
+    return overlay;
+  const map = new Map(base.map((p) => [p.id, p]));
+  for (const p of overlay)
+    map.set(p.id, p);
+  return [...map.values()];
+}
+function mergeMCPServers(base, overlay) {
+  if (!base && !overlay)
+    return;
+  if (!overlay)
+    return base;
+  if (!base)
+    return overlay;
+  const map = new Map(base.map((s) => [s.name, s]));
+  for (const s of overlay)
+    map.set(s.name, s);
+  return [...map.values()];
+}
+function loadConfig() {
+  if (!existsSync7(CONFIG_DIR)) {
+    mkdirSync6(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  if (!existsSync7(CONFIG_FILE)) {
+    writeFileSync6(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const raw = readFileSync7(CONFIG_FILE, "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch (err2) {
+    logBackgroundError("config", `Failed to parse ${CONFIG_FILE}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 using defaults`);
+    return DEFAULT_CONFIG;
+  }
+}
+function loadProjectConfig(cwd) {
+  const projectFile = join7(cwd, ".soulforge", "config.json");
+  if (!existsSync7(projectFile))
+    return null;
+  try {
+    const raw = readFileSync7(projectFile, "utf-8");
+    return JSON.parse(raw);
+  } catch (err2) {
+    logBackgroundError("config", `Failed to parse ${projectFile}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 ignoring project config`);
+    return null;
+  }
+}
+function mergeConfigs(global2, project) {
+  const layers = [global2];
+  if (project)
+    layers.push(project);
+  let merged = { ...global2 };
+  for (const layer of layers.slice(1)) {
+    const ei = layer.editorIntegration ? { ...merged.editorIntegration, ...layer.editorIntegration } : merged.editorIntegration;
+    const ci = layer.codeIntelligence ? { ...merged.codeIntelligence, ...layer.codeIntelligence } : merged.codeIntelligence;
+    const th = layer.thinking ? { ...merged.thinking, ...layer.thinking } : merged.thinking;
+    const perf = layer.performance ? { ...merged.performance, ...layer.performance } : merged.performance;
+    const cm = layer.contextManagement ? { ...merged.contextManagement, ...layer.contextManagement } : merged.contextManagement;
+    const comp = layer.compaction ? { ...merged.compaction, ...layer.compaction } : merged.compaction;
+    const retry = layer.retry ? { ...merged.retry, ...layer.retry } : merged.retry;
+    const providers = mergeProviders(merged.providers, layer.providers);
+    const mcpServers = mergeMCPServers(merged.mcpServers, layer.mcpServers);
+    merged = {
+      ...merged,
+      ...layer,
+      editor: { ...merged.editor, ...layer.editor },
+      theme: { ...merged.theme, ...layer.theme },
+      editorIntegration: ei,
+      codeIntelligence: ci,
+      thinking: th,
+      performance: perf,
+      contextManagement: cm,
+      compaction: comp,
+      retry,
+      providers,
+      mcpServers
+    };
+  }
+  return merged;
+}
+function saveConfig(config) {
+  if (!existsSync7(CONFIG_DIR)) {
+    mkdirSync6(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+  writeFileSync6(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function saveProjectConfig(cwd, patch) {
+  const dir = ensureSoulforgeDir(cwd);
+  const file = join7(dir, "config.json");
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync7(file, "utf-8"));
+  } catch {}
+  const merged = { ...existing, ...patch };
+  if (patch.thinking)
+    merged.thinking = { ...existing.thinking, ...patch.thinking };
+  if (patch.performance)
+    merged.performance = { ...existing.performance, ...patch.performance };
+  if (patch.contextManagement)
+    merged.contextManagement = { ...existing.contextManagement, ...patch.contextManagement };
+  if (patch.agentFeatures)
+    merged.agentFeatures = { ...existing.agentFeatures, ...patch.agentFeatures };
+  if (patch.retry)
+    merged.retry = { ...existing.retry, ...patch.retry };
+  writeFileSync6(file, JSON.stringify(merged, null, 2));
+}
+function saveGlobalConfig(patch) {
+  if (!existsSync7(CONFIG_DIR))
+    mkdirSync6(CONFIG_DIR, { recursive: true, mode: 448 });
+  let existing = DEFAULT_CONFIG;
+  try {
+    existing = { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync7(CONFIG_FILE, "utf-8")) };
+  } catch {}
+  const merged = { ...existing, ...patch };
+  if (patch.thinking)
+    merged.thinking = { ...existing.thinking, ...patch.thinking };
+  if (patch.performance)
+    merged.performance = { ...existing.performance, ...patch.performance };
+  if (patch.contextManagement)
+    merged.contextManagement = { ...existing.contextManagement, ...patch.contextManagement };
+  if (patch.agentFeatures)
+    merged.agentFeatures = { ...existing.agentFeatures, ...patch.agentFeatures };
+  if (patch.retry)
+    merged.retry = { ...existing.retry, ...patch.retry };
+  writeFileSync6(CONFIG_FILE, JSON.stringify(merged, null, 2));
+}
+function removeProjectConfigKeys(cwd, keys) {
+  const file = join7(cwd, ".soulforge", "config.json");
+  if (!existsSync7(file))
+    return;
+  try {
+    const existing = JSON.parse(readFileSync7(file, "utf-8"));
+    for (const k of keys)
+      delete existing[k];
+    writeFileSync6(file, JSON.stringify(existing, null, 2));
+  } catch {}
+}
+function removeGlobalConfigKeys(keys) {
+  if (!existsSync7(CONFIG_FILE))
+    return;
+  try {
+    const existing = JSON.parse(readFileSync7(CONFIG_FILE, "utf-8"));
+    for (const k of keys)
+      delete existing[k];
+    writeFileSync6(CONFIG_FILE, JSON.stringify(existing, null, 2));
+  } catch {}
+}
+function applyConfigPatch(base, patch) {
+  const result = { ...base, ...patch };
+  for (const key of NESTED_KEYS) {
+    const b = base[key];
+    const p = patch[key];
+    if (p && b && typeof b === "object" && typeof p === "object") {
+      result[key] = { ...b, ...p };
+    }
+  }
+  return result;
+}
+function stripConfigKeys(config, keys) {
+  const result = { ...config };
+  for (const k of keys)
+    delete result[k];
+  return result;
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_CONFIG, NESTED_KEYS;
+var init_config2 = __esm(() => {
+  init_ensure_soulforge_dir();
+  init_errors();
+  CONFIG_DIR = join7(homedir6(), ".soulforge");
+  CONFIG_FILE = join7(CONFIG_DIR, "config.json");
+  DEFAULT_CONFIG = {
+    defaultModel: "none",
+    routerRules: [],
+    editor: {
+      command: "nvim",
+      args: []
+    },
+    theme: {
+      name: "dark",
+      transparent: true
+    },
+    nvimConfig: "default",
+    editorIntegration: {
+      diagnostics: true,
+      symbols: true,
+      hover: true,
+      references: true,
+      definition: true,
+      codeActions: true,
+      editorContext: true,
+      rename: true,
+      lspStatus: true,
+      format: true,
+      syncEditorOnEdit: false
+    },
+    codeExecution: true,
+    webSearch: true,
+    compaction: {
+      strategy: "v2",
+      triggerThreshold: 0.7,
+      resetThreshold: 0.4,
+      keepRecent: 4,
+      maxToolResults: 30,
+      llmExtraction: true
+    }
+  };
+  NESTED_KEYS = [
+    "editor",
+    "theme",
+    "editorIntegration",
+    "codeIntelligence",
+    "thinking",
+    "performance",
+    "contextManagement",
+    "agentFeatures",
+    "compaction",
+    "retry"
+  ];
+});
+
+// src/hearth/provider-commands.ts
+function showBool(v, fallback = false) {
+  return v ?? fallback ? "on" : "off";
+}
+function parseBool(raw) {
+  const v = raw.trim().toLowerCase();
+  if (v === "on" || v === "true" || v === "1" || v === "yes")
+    return true;
+  if (v === "off" || v === "false" || v === "0" || v === "no")
+    return false;
+  return null;
+}
+function findSetting(cmdName) {
+  const bare = cmdName.startsWith("/") ? cmdName.slice(1) : cmdName;
+  return SETTINGS.find((s) => s.cmd === bare);
+}
+function validateSettingValue(setting, raw) {
+  const v = raw.trim();
+  if (!v)
+    return { ok: false, error: "missing value" };
+  if (setting.type === "toggle") {
+    const b = parseBool(v);
+    if (b === null)
+      return { ok: false, error: `expected on|off, got "${v}"` };
+    return { ok: true, value: b ? "on" : "off" };
+  }
+  if (setting.type === "cycle") {
+    const lower = v.toLowerCase();
+    const match = setting.options?.find((o) => o.toLowerCase() === lower);
+    if (!match) {
+      return {
+        ok: false,
+        error: `expected ${setting.options?.join("|") ?? "(none)"} \u2014 got "${v}"`
+      };
+    }
+    return { ok: true, value: match };
+  }
+  const n = Number.parseInt(v, 10);
+  if (!Number.isFinite(n) || n < 1024) {
+    return { ok: false, error: "expected integer \u2265 1024" };
+  }
+  return { ok: true, value: String(n) };
+}
+function renderSettingsOverview(cfg) {
+  const lines = ["\u2501\u2501 Provider settings \u2501\u2501"];
+  for (const s of SETTINGS) {
+    lines.push(`/${s.cmd.padEnd(15)} ${s.read(cfg).padEnd(10)} ${s.label}`);
+  }
+  lines.push("");
+  lines.push("set:   /<cmd> <value>");
+  lines.push("show:  /<cmd>");
+  return lines.join(`
+`);
+}
+async function handleSettingsCommand(cmdName, args2, notify, opts = {}) {
+  const load = opts.load ?? loadConfig;
+  const save = opts.save ?? saveGlobalConfig;
+  if (cmdName === "/settings") {
+    await notify(renderSettingsOverview(load()));
+    return true;
+  }
+  const setting = findSetting(cmdName);
+  if (!setting)
+    return false;
+  const raw = args2.join(" ").trim();
+  if (!raw) {
+    const current = setting.read(load());
+    const opts2 = setting.options?.join("|") ?? (setting.type === "toggle" ? "on|off" : "<int>");
+    await notify(`/${setting.cmd}: ${current}
+options: ${opts2}`);
+    return true;
+  }
+  const parsed = validateSettingValue(setting, raw);
+  if (!parsed.ok) {
+    await notify(`\u2717 ${parsed.error}`);
+    return true;
+  }
+  try {
+    save(setting.patch(parsed.value));
+  } catch (err2) {
+    await notify(`\u2717 save failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    return true;
+  }
+  await notify(`\u2713 ${setting.cmd} \u2192 ${parsed.value}`);
+  return true;
+}
+function settingsHelpLines() {
+  return [
+    "\u2501\u2501 Provider settings \u2501\u2501",
+    "/settings              show all current values",
+    "/thinking [mode]       off | auto | enabled | adaptive | disabled",
+    "/budget [N]            thinking budget tokens (\u22651024)",
+    "/effort [level]        off | low | medium | high | xhigh | max",
+    "/speed [mode]          off | standard | fast (Opus 4.6)",
+    "/reasoning [level]     OpenAI reasoning effort",
+    "/tier [tier]           OpenAI service tier (flex|priority|auto\u2026)",
+    "/sendreasoning on|off  send reasoning across turns",
+    "/toolstream on|off     stream tool args incrementally",
+    "/seqtools on|off       sequential tool use",
+    "/codeexec on|off       code execution tool",
+    "/websearch on|off      web search tool",
+    "/computeruse on|off    computer use tool",
+    "/compact on|off        server-side context compaction",
+    "/cleartools on|off     clear old tool results (server)",
+    "/clearthinking on|off  preserve thinking blocks",
+    "/pruning [target]      none | main | subagents | both"
+  ];
+}
+var THINKING_MODES, EFFORT_LEVELS, SPEEDS, OAI_EFFORTS, SERVICE_TIERS, PRUNING, SETTINGS, SETTINGS_COMMAND_NAMES;
+var init_provider_commands = __esm(() => {
+  init_config2();
+  THINKING_MODES = ["off", "disabled", "auto", "adaptive", "enabled"];
+  EFFORT_LEVELS = ["off", "low", "medium", "high", "xhigh", "max"];
+  SPEEDS = ["off", "standard", "fast"];
+  OAI_EFFORTS = ["off", "none", "minimal", "low", "medium", "high", "xhigh"];
+  SERVICE_TIERS = ["off", "auto", "default", "flex", "priority"];
+  PRUNING = ["none", "main", "subagents", "both"];
+  SETTINGS = [
+    {
+      cmd: "thinking",
+      label: "thinking mode",
+      type: "cycle",
+      options: THINKING_MODES,
+      read: (c) => c.thinking?.mode ?? "off",
+      patch: (raw) => ({ thinking: { mode: raw } })
+    },
+    {
+      cmd: "budget",
+      label: "thinking budget tokens",
+      type: "budget",
+      read: (c) => String(c.thinking?.budgetTokens ?? 1e4),
+      patch: (raw) => ({
+        thinking: { mode: "enabled", budgetTokens: Number.parseInt(raw, 10) }
+      })
+    },
+    {
+      cmd: "effort",
+      label: "reasoning effort",
+      type: "cycle",
+      options: EFFORT_LEVELS,
+      read: (c) => c.performance?.effort ?? "off",
+      patch: (raw) => ({
+        performance: { effort: raw }
+      })
+    },
+    {
+      cmd: "speed",
+      label: "speed (Opus 4.6)",
+      type: "cycle",
+      options: SPEEDS,
+      read: (c) => c.performance?.speed ?? "off",
+      patch: (raw) => ({
+        performance: { speed: raw }
+      })
+    },
+    {
+      cmd: "reasoning",
+      label: "OpenAI reasoning effort",
+      type: "cycle",
+      options: OAI_EFFORTS,
+      read: (c) => c.performance?.openaiReasoningEffort ?? "off",
+      patch: (raw) => ({
+        performance: { openaiReasoningEffort: raw }
+      })
+    },
+    {
+      cmd: "tier",
+      label: "OpenAI service tier",
+      type: "cycle",
+      options: SERVICE_TIERS,
+      read: (c) => c.performance?.serviceTier ?? "off",
+      patch: (raw) => ({
+        performance: { serviceTier: raw }
+      })
+    },
+    {
+      cmd: "sendreasoning",
+      label: "send reasoning across turns",
+      type: "toggle",
+      read: (c) => showBool(c.performance?.sendReasoning),
+      patch: (raw) => ({
+        performance: { sendReasoning: parseBool(raw) ?? false }
+      })
+    },
+    {
+      cmd: "toolstream",
+      label: "tool arg streaming",
+      type: "toggle",
+      read: (c) => showBool(c.performance?.toolStreaming, true),
+      patch: (raw) => ({
+        performance: { toolStreaming: parseBool(raw) ?? true }
+      })
+    },
+    {
+      cmd: "seqtools",
+      label: "sequential tool use",
+      type: "toggle",
+      read: (c) => showBool(c.performance?.disableParallelToolUse),
+      patch: (raw) => ({
+        performance: { disableParallelToolUse: parseBool(raw) ?? false }
+      })
+    },
+    {
+      cmd: "codeexec",
+      label: "code execution tool",
+      type: "toggle",
+      read: (c) => showBool(c.codeExecution, true),
+      patch: (raw) => ({ codeExecution: parseBool(raw) ?? true })
+    },
+    {
+      cmd: "websearch",
+      label: "web search tool",
+      type: "toggle",
+      read: (c) => showBool(c.webSearch, true),
+      patch: (raw) => ({ webSearch: parseBool(raw) ?? true })
+    },
+    {
+      cmd: "computeruse",
+      label: "computer use tool",
+      type: "toggle",
+      read: (c) => showBool(c.computerUse),
+      patch: (raw) => ({ computerUse: parseBool(raw) ?? false })
+    },
+    {
+      cmd: "compact",
+      label: "server-side compaction",
+      type: "toggle",
+      read: (c) => showBool(c.contextManagement?.compact),
+      patch: (raw) => ({
+        contextManagement: { compact: parseBool(raw) ?? false }
+      })
+    },
+    {
+      cmd: "cleartools",
+      label: "clear old tool results (server)",
+      type: "toggle",
+      read: (c) => showBool(c.contextManagement?.clearToolUses),
+      patch: (raw) => ({
+        contextManagement: { clearToolUses: parseBool(raw) ?? false }
+      })
+    },
+    {
+      cmd: "clearthinking",
+      label: "preserve thinking blocks",
+      type: "toggle",
+      read: (c) => showBool(c.contextManagement?.clearThinking, true),
+      patch: (raw) => ({
+        contextManagement: { clearThinking: parseBool(raw) ?? true }
+      })
+    },
+    {
+      cmd: "pruning",
+      label: "tool-result pruning target",
+      type: "cycle",
+      options: PRUNING,
+      read: (c) => c.contextManagement?.pruningTarget ?? "none",
+      patch: (raw) => ({
+        contextManagement: {
+          pruningTarget: raw
+        }
+      })
+    }
+  ];
+  SETTINGS_COMMAND_NAMES = [
+    ...SETTINGS.map((s) => `/${s.cmd}`),
+    "/settings"
+  ];
+});
+
 // src/hearth/redact.ts
 var exports_redact = {};
 __export(exports_redact, {
@@ -5678,9 +6238,9 @@ data: ${payload}
 });
 
 // src/hearth/adapters/telegram.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname3, join as join6 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname3, join as join8 } from "path";
 function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -5801,14 +6361,14 @@ var init_telegram = __esm(() => {
       this.loadCallbackState();
     }
     callbackStatePath() {
-      return join6(homedir6(), ".soulforge", `hearth-callbacks-${this.botId}.json`);
+      return join8(homedir7(), ".soulforge", `hearth-callbacks-${this.botId}.json`);
     }
     loadCallbackState() {
       const path = this.callbackStatePath();
-      if (!existsSync6(path))
+      if (!existsSync8(path))
         return;
       try {
-        const raw = readFileSync6(path, "utf-8");
+        const raw = readFileSync8(path, "utf-8");
         const parsed = JSON.parse(raw);
         for (const [chatId, entry] of Object.entries(parsed)) {
           this.lastCallbackByChat.set(chatId, entry);
@@ -5818,11 +6378,11 @@ var init_telegram = __esm(() => {
     persistCallbackState() {
       try {
         const path = this.callbackStatePath();
-        mkdirSync5(dirname3(path), { recursive: true, mode: 448 });
+        mkdirSync7(dirname3(path), { recursive: true, mode: 448 });
         const obj = {};
         for (const [k, v] of this.lastCallbackByChat)
           obj[k] = v;
-        writeFileSync5(path, JSON.stringify(obj), { mode: 384 });
+        writeFileSync7(path, JSON.stringify(obj), { mode: 384 });
       } catch {}
     }
     getRendererFor(externalId) {
@@ -6525,297 +7085,6 @@ var init_surface_host = __esm(() => {
   init_surface_factory();
 });
 
-// src/core/utils/ensure-soulforge-dir.ts
-import { execSync as execSync2 } from "child_process";
-import { appendFileSync as appendFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join7 } from "path";
-function ensureSoulforgeDir(cwd) {
-  const dir = join7(cwd, ENTRY);
-  if (!existsSync7(dir))
-    mkdirSync6(dir, { recursive: true });
-  if (!patched.has(cwd)) {
-    patched.add(cwd);
-    try {
-      ensureGitignore(cwd);
-    } catch {}
-  }
-  return dir;
-}
-function ensureGitignore(cwd) {
-  const status = gitCheckIgnoreStatus(cwd);
-  if (status !== 1)
-    return;
-  const gitignorePath = join7(cwd, ".gitignore");
-  if (existsSync7(gitignorePath)) {
-    const content = readFileSync7(gitignorePath, "utf-8");
-    const eol = content.includes(`\r
-`) ? `\r
-` : `
-`;
-    const prefix = content.length > 0 && !content.endsWith(`
-`) ? eol : "";
-    appendFileSync2(gitignorePath, `${prefix}.soulforge${eol}`);
-  } else {
-    writeFileSync6(gitignorePath, `.soulforge
-`);
-  }
-}
-function gitCheckIgnoreStatus(cwd) {
-  try {
-    execSync2("git check-ignore -q .soulforge", { cwd, stdio: "pipe", timeout: 3000 });
-    return 0;
-  } catch (err2) {
-    return err2.status ?? 128;
-  }
-}
-var ENTRY = ".soulforge", patched;
-var init_ensure_soulforge_dir = __esm(() => {
-  patched = new Set;
-});
-
-// src/config/index.ts
-var exports_config2 = {};
-__export(exports_config2, {
-  stripConfigKeys: () => stripConfigKeys,
-  saveProjectConfig: () => saveProjectConfig,
-  saveGlobalConfig: () => saveGlobalConfig,
-  saveConfig: () => saveConfig,
-  removeProjectConfigKeys: () => removeProjectConfigKeys,
-  removeGlobalConfigKeys: () => removeGlobalConfigKeys,
-  mergeConfigs: () => mergeConfigs,
-  loadProjectConfig: () => loadProjectConfig,
-  loadConfig: () => loadConfig,
-  applyConfigPatch: () => applyConfigPatch,
-  DEFAULT_CONFIG: () => DEFAULT_CONFIG
-});
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
-function mergeProviders(base, overlay) {
-  if (!base && !overlay)
-    return;
-  if (!overlay)
-    return base;
-  if (!base)
-    return overlay;
-  const map = new Map(base.map((p) => [p.id, p]));
-  for (const p of overlay)
-    map.set(p.id, p);
-  return [...map.values()];
-}
-function mergeMCPServers(base, overlay) {
-  if (!base && !overlay)
-    return;
-  if (!overlay)
-    return base;
-  if (!base)
-    return overlay;
-  const map = new Map(base.map((s) => [s.name, s]));
-  for (const s of overlay)
-    map.set(s.name, s);
-  return [...map.values()];
-}
-function loadConfig() {
-  if (!existsSync8(CONFIG_DIR)) {
-    mkdirSync7(CONFIG_DIR, { recursive: true, mode: 448 });
-  }
-  if (!existsSync8(CONFIG_FILE)) {
-    writeFileSync7(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
-    return DEFAULT_CONFIG;
-  }
-  try {
-    const raw = readFileSync8(CONFIG_FILE, "utf-8");
-    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
-  } catch (err2) {
-    logBackgroundError("config", `Failed to parse ${CONFIG_FILE}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 using defaults`);
-    return DEFAULT_CONFIG;
-  }
-}
-function loadProjectConfig(cwd) {
-  const projectFile = join8(cwd, ".soulforge", "config.json");
-  if (!existsSync8(projectFile))
-    return null;
-  try {
-    const raw = readFileSync8(projectFile, "utf-8");
-    return JSON.parse(raw);
-  } catch (err2) {
-    logBackgroundError("config", `Failed to parse ${projectFile}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 ignoring project config`);
-    return null;
-  }
-}
-function mergeConfigs(global2, project) {
-  const layers = [global2];
-  if (project)
-    layers.push(project);
-  let merged = { ...global2 };
-  for (const layer of layers.slice(1)) {
-    const ei = layer.editorIntegration ? { ...merged.editorIntegration, ...layer.editorIntegration } : merged.editorIntegration;
-    const ci = layer.codeIntelligence ? { ...merged.codeIntelligence, ...layer.codeIntelligence } : merged.codeIntelligence;
-    const th = layer.thinking ? { ...merged.thinking, ...layer.thinking } : merged.thinking;
-    const perf = layer.performance ? { ...merged.performance, ...layer.performance } : merged.performance;
-    const cm = layer.contextManagement ? { ...merged.contextManagement, ...layer.contextManagement } : merged.contextManagement;
-    const comp = layer.compaction ? { ...merged.compaction, ...layer.compaction } : merged.compaction;
-    const retry = layer.retry ? { ...merged.retry, ...layer.retry } : merged.retry;
-    const providers = mergeProviders(merged.providers, layer.providers);
-    const mcpServers = mergeMCPServers(merged.mcpServers, layer.mcpServers);
-    merged = {
-      ...merged,
-      ...layer,
-      editor: { ...merged.editor, ...layer.editor },
-      theme: { ...merged.theme, ...layer.theme },
-      editorIntegration: ei,
-      codeIntelligence: ci,
-      thinking: th,
-      performance: perf,
-      contextManagement: cm,
-      compaction: comp,
-      retry,
-      providers,
-      mcpServers
-    };
-  }
-  return merged;
-}
-function saveConfig(config) {
-  if (!existsSync8(CONFIG_DIR)) {
-    mkdirSync7(CONFIG_DIR, { recursive: true, mode: 448 });
-  }
-  writeFileSync7(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-function saveProjectConfig(cwd, patch) {
-  const dir = ensureSoulforgeDir(cwd);
-  const file = join8(dir, "config.json");
-  let existing = {};
-  try {
-    existing = JSON.parse(readFileSync8(file, "utf-8"));
-  } catch {}
-  const merged = { ...existing, ...patch };
-  if (patch.thinking)
-    merged.thinking = { ...existing.thinking, ...patch.thinking };
-  if (patch.performance)
-    merged.performance = { ...existing.performance, ...patch.performance };
-  if (patch.contextManagement)
-    merged.contextManagement = { ...existing.contextManagement, ...patch.contextManagement };
-  if (patch.agentFeatures)
-    merged.agentFeatures = { ...existing.agentFeatures, ...patch.agentFeatures };
-  if (patch.retry)
-    merged.retry = { ...existing.retry, ...patch.retry };
-  writeFileSync7(file, JSON.stringify(merged, null, 2));
-}
-function saveGlobalConfig(patch) {
-  if (!existsSync8(CONFIG_DIR))
-    mkdirSync7(CONFIG_DIR, { recursive: true, mode: 448 });
-  let existing = DEFAULT_CONFIG;
-  try {
-    existing = { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync8(CONFIG_FILE, "utf-8")) };
-  } catch {}
-  const merged = { ...existing, ...patch };
-  if (patch.thinking)
-    merged.thinking = { ...existing.thinking, ...patch.thinking };
-  if (patch.performance)
-    merged.performance = { ...existing.performance, ...patch.performance };
-  if (patch.contextManagement)
-    merged.contextManagement = { ...existing.contextManagement, ...patch.contextManagement };
-  if (patch.agentFeatures)
-    merged.agentFeatures = { ...existing.agentFeatures, ...patch.agentFeatures };
-  if (patch.retry)
-    merged.retry = { ...existing.retry, ...patch.retry };
-  writeFileSync7(CONFIG_FILE, JSON.stringify(merged, null, 2));
-}
-function removeProjectConfigKeys(cwd, keys) {
-  const file = join8(cwd, ".soulforge", "config.json");
-  if (!existsSync8(file))
-    return;
-  try {
-    const existing = JSON.parse(readFileSync8(file, "utf-8"));
-    for (const k of keys)
-      delete existing[k];
-    writeFileSync7(file, JSON.stringify(existing, null, 2));
-  } catch {}
-}
-function removeGlobalConfigKeys(keys) {
-  if (!existsSync8(CONFIG_FILE))
-    return;
-  try {
-    const existing = JSON.parse(readFileSync8(CONFIG_FILE, "utf-8"));
-    for (const k of keys)
-      delete existing[k];
-    writeFileSync7(CONFIG_FILE, JSON.stringify(existing, null, 2));
-  } catch {}
-}
-function applyConfigPatch(base, patch) {
-  const result = { ...base, ...patch };
-  for (const key of NESTED_KEYS) {
-    const b = base[key];
-    const p = patch[key];
-    if (p && b && typeof b === "object" && typeof p === "object") {
-      result[key] = { ...b, ...p };
-    }
-  }
-  return result;
-}
-function stripConfigKeys(config, keys) {
-  const result = { ...config };
-  for (const k of keys)
-    delete result[k];
-  return result;
-}
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_CONFIG, NESTED_KEYS;
-var init_config2 = __esm(() => {
-  init_ensure_soulforge_dir();
-  init_errors();
-  CONFIG_DIR = join8(homedir7(), ".soulforge");
-  CONFIG_FILE = join8(CONFIG_DIR, "config.json");
-  DEFAULT_CONFIG = {
-    defaultModel: "none",
-    routerRules: [],
-    editor: {
-      command: "nvim",
-      args: []
-    },
-    theme: {
-      name: "dark",
-      transparent: true
-    },
-    nvimConfig: "default",
-    editorIntegration: {
-      diagnostics: true,
-      symbols: true,
-      hover: true,
-      references: true,
-      definition: true,
-      codeActions: true,
-      editorContext: true,
-      rename: true,
-      lspStatus: true,
-      format: true,
-      syncEditorOnEdit: false
-    },
-    codeExecution: true,
-    webSearch: true,
-    compaction: {
-      strategy: "v2",
-      triggerThreshold: 0.7,
-      resetThreshold: 0.4,
-      keepRecent: 4,
-      maxToolResults: 30,
-      llmExtraction: true
-    }
-  };
-  NESTED_KEYS = [
-    "editor",
-    "theme",
-    "editorIntegration",
-    "codeIntelligence",
-    "thinking",
-    "performance",
-    "contextManagement",
-    "agentFeatures",
-    "compaction",
-    "retry"
-  ];
-});
-
 // src/stores/workers.ts
 var exports_workers = {};
 __export(exports_workers, {
@@ -62231,7 +62500,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@proxysoul/soulforge",
-    version: "2.15.1",
+    version: "2.15.2",
     description: "Graph-powered code intelligence \u2014 multi-agent coding with codebase-aware AI",
     repository: {
       type: "git",
@@ -62680,6 +62949,74 @@ var init_version = __esm(() => {
   CURRENT_VERSION = _currentVersion;
 });
 
+// src/core/llm/compat-reasoning.ts
+function parseProvider(modelId) {
+  const slash = modelId.indexOf("/");
+  if (slash === -1)
+    return { provider: "", model: modelId };
+  return { provider: modelId.slice(0, slash), model: modelId.slice(slash + 1) };
+}
+function baseModel(modelId) {
+  const slash = modelId.lastIndexOf("/");
+  return (slash >= 0 ? modelId.slice(slash + 1) : modelId).toLowerCase();
+}
+function getCompatReasoningBody(modelId, config2) {
+  const { provider } = parseProvider(modelId);
+  if (!COMPAT_PROVIDERS.has(provider))
+    return {};
+  const base = baseModel(modelId);
+  let effort = config2.performance?.compatReasoningEffort;
+  if (provider === "groq") {
+    const g = config2.performance?.groqReasoningEffort;
+    if (g)
+      effort = g === "off" ? "off" : g;
+  }
+  if (!effort || effort === "off") {
+    const e = config2.performance?.effort;
+    if (e && e !== "off") {
+      effort = e === "max" ? "xhigh" : e;
+    }
+  }
+  if (!effort || effort === "off")
+    return {};
+  const isClaude = base.startsWith("claude");
+  if (isClaude && provider === "opencode-zen") {
+    const explicitBudget = config2.thinking?.budgetTokens;
+    const budget = explicitBudget ?? { low: 2048, medium: 5000, high: 1e4, xhigh: 20000 }[effort] ?? 5000;
+    return { thinking: { type: "enabled", budget_tokens: budget } };
+  }
+  if (isClaude && provider !== "proxy") {
+    return {};
+  }
+  if (provider === "groq" && /qwen3/.test(base)) {
+    return { reasoning_effort: "default" };
+  }
+  const isDashscope = /qwen|glm-|kimi-/.test(base);
+  const body2 = {
+    reasoning_effort: effort,
+    reasoning: { effort }
+  };
+  if (isDashscope)
+    body2.enable_thinking = true;
+  return body2;
+}
+var COMPAT_PROVIDERS;
+var init_compat_reasoning = __esm(() => {
+  COMPAT_PROVIDERS = new Set([
+    "deepseek",
+    "groq",
+    "fireworks",
+    "minimax",
+    "copilot",
+    "github-models",
+    "opencode-go",
+    "opencode-zen",
+    "lmstudio",
+    "ollama",
+    "proxy"
+  ]);
+});
+
 // src/core/llm/providers/copilot.ts
 async function exchangeToken(githubToken) {
   if (cachedBearer && Date.now() / 1000 < cachedBearer.expiresAt - 60) {
@@ -62736,7 +63073,8 @@ function detectInitiator(body2) {
   } catch {}
   return "user";
 }
-function createCopilotFetch(githubToken) {
+function createCopilotFetch(githubToken, reasoningBody) {
+  const injectReasoning = Object.keys(reasoningBody).length > 0;
   return async (url2, init2) => {
     let bearer;
     try {
@@ -62745,18 +63083,25 @@ function createCopilotFetch(githubToken) {
       invalidateBearer();
       bearer = await exchangeToken(githubToken);
     }
+    let patchedBody = init2?.body;
+    if (injectReasoning && typeof init2?.body === "string") {
+      try {
+        const parsed = JSON.parse(init2.body);
+        patchedBody = JSON.stringify({ ...parsed, ...reasoningBody });
+      } catch {}
+    }
     const buildHeaders = (token) => {
       const h = new Headers(init2?.headers);
       h.set("Authorization", `Bearer ${token}`);
       h.set("X-Request-Id", crypto.randomUUID());
-      h.set("X-Initiator", detectInitiator(init2?.body));
+      h.set("X-Initiator", detectInitiator(patchedBody));
       return h;
     };
-    const res = await fetch(url2, { ...init2, headers: buildHeaders(bearer) });
+    const res = await fetch(url2, { ...init2, body: patchedBody, headers: buildHeaders(bearer) });
     if (res.status === 401) {
       invalidateBearer();
       const retryBearer = await exchangeToken(githubToken);
-      return fetch(url2, { ...init2, headers: buildHeaders(retryBearer) });
+      return fetch(url2, { ...init2, body: patchedBody, headers: buildHeaders(retryBearer) });
     }
     return res;
   };
@@ -62773,7 +63118,8 @@ function assertChatCompletionsSupported(modelId) {
 function createCopilotModel(modelId) {
   assertChatCompletionsSupported(modelId);
   const githubToken = getGitHubToken();
-  const copilotFetch = createCopilotFetch(githubToken);
+  const reasoningBody = getCompatReasoningBody(`copilot/${modelId}`, loadConfig());
+  const copilotFetch = createCopilotFetch(githubToken, reasoningBody);
   const client = createOpenAI({
     baseURL: COPILOT_API,
     apiKey: "copilot",
@@ -62785,8 +63131,10 @@ function createCopilotModel(modelId) {
 var ENV_VAR = "COPILOT_API_KEY", COPILOT_API = "https://api.githubcopilot.com", TOKEN_EXCHANGE = "https://api.github.com/copilot_internal/v2/token", COPILOT_CHAT_VERSION = "0.26.7", COPILOT_API_VERSION = "2025-04-01", COPILOT_HEADERS, cachedBearer = null, bearerInflight = null, supportedEndpoints, copilot;
 var init_copilot = __esm(() => {
   init_dist8();
+  init_config2();
   init_secrets();
   init_version();
+  init_compat_reasoning();
   COPILOT_HEADERS = {
     "Editor-Version": "vscode/1.95.0",
     "Editor-Plugin-Version": `copilot-chat/${COPILOT_CHAT_VERSION}`,
@@ -64417,27 +64765,21 @@ var init_dist9 = __esm(() => {
   });
 });
 
-// src/core/llm/providers/custom.ts
-function normalizeModels(models) {
-  if (!models || models.length === 0)
-    return [];
-  return models.map((m) => typeof m === "string" ? { id: m, name: m } : m);
-}
-function buildReasoningBody(reasoning) {
-  if (!reasoning)
-    return {};
+// src/core/llm/providers/reasoning-fetch.ts
+function buildOpenAICompatReasoningBody(effort, extras) {
   const body2 = {};
-  if (reasoning.effort) {
-    body2.reasoning = { effort: reasoning.effort };
+  if (effort && effort !== "off") {
+    body2.reasoning_effort = effort;
+    body2.reasoning = { effort };
   }
-  if (reasoning.enabled !== undefined) {
-    body2.enable_thinking = reasoning.enabled;
+  if (extras?.enabled !== undefined) {
+    body2.enable_thinking = extras.enabled;
   }
-  if (reasoning.budget !== undefined) {
-    body2.thinking_budget = reasoning.budget;
+  if (extras?.budget !== undefined) {
+    body2.thinking_budget = extras.budget;
   }
-  if (reasoning.extraParams) {
-    Object.assign(body2, reasoning.extraParams);
+  if (extras?.extraParams) {
+    Object.assign(body2, extras.extraParams);
   }
   return body2;
 }
@@ -64460,6 +64802,22 @@ function createReasoningFetchWrapper(reasoningBody) {
     return fetch(input, patchedInit);
   };
 }
+
+// src/core/llm/providers/custom.ts
+function normalizeModels(models) {
+  if (!models || models.length === 0)
+    return [];
+  return models.map((m) => typeof m === "string" ? { id: m, name: m } : m);
+}
+function buildReasoningBody(reasoning) {
+  if (!reasoning)
+    return {};
+  return buildOpenAICompatReasoningBody(reasoning.effort, {
+    enabled: reasoning.enabled,
+    budget: reasoning.budget,
+    extraParams: reasoning.extraParams
+  });
+}
 function buildCustomProvider(config2) {
   const envVar = config2.envVar ?? "";
   const reasoningBody = buildReasoningBody(config2.reasoning);
@@ -64523,7 +64881,9 @@ var init_custom = __esm(() => {
 var deepseek;
 var init_deepseek = __esm(() => {
   init_dist9();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   deepseek = {
     id: "deepseek",
     name: "DeepSeek",
@@ -64538,10 +64898,13 @@ var init_deepseek = __esm(() => {
       if (!apiKey) {
         throw new Error("DEEPSEEK_API_KEY is not set");
       }
+      const reasoningBody = getCompatReasoningBody(`deepseek/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
       const provider = createOpenAICompatible({
         name: "deepseek",
         baseURL: "https://api.deepseek.com/v1",
-        apiKey
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
       });
       return provider.chatModel(modelId);
     },
@@ -64892,7 +65255,9 @@ var init_dist10 = __esm(() => {
 var fireworks2;
 var init_fireworks = __esm(() => {
   init_dist10();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   fireworks2 = {
     id: "fireworks",
     name: "Fireworks",
@@ -64907,7 +65272,12 @@ var init_fireworks = __esm(() => {
       if (!apiKey) {
         throw new Error("FIREWORKS_API_KEY is not set");
       }
-      return createFireworks({ apiKey })(modelId);
+      const reasoningBody = getCompatReasoningBody(`fireworks/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
+      return createFireworks({
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
+      })(modelId);
     },
     async fetchModels() {
       const apiKey = getProviderApiKey("FIREWORKS_API_KEY");
@@ -64947,7 +65317,9 @@ var init_fireworks = __esm(() => {
 var ENV_VAR2 = "GITHUB_MODELS_API_KEY", BASE_URL = "https://models.github.ai/inference", CATALOG_URL = "https://models.github.ai/catalog/models", GH_HEADERS, githubModels;
 var init_github_models = __esm(() => {
   init_dist8();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   GH_HEADERS = {
     "X-GitHub-Api-Version": "2026-03-10",
     Accept: "application/vnd.github+json"
@@ -64966,7 +65338,14 @@ var init_github_models = __esm(() => {
       if (!apiKey) {
         throw new Error(`${ENV_VAR2} is not set. Create a fine-grained PAT with models:read at github.com/settings/tokens`);
       }
-      return createOpenAI({ baseURL: BASE_URL, apiKey, headers: GH_HEADERS }).chat(modelId);
+      const reasoningBody = getCompatReasoningBody(`github-models/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
+      return createOpenAI({
+        baseURL: BASE_URL,
+        apiKey,
+        headers: GH_HEADERS,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
+      }).chat(modelId);
     },
     async fetchModels() {
       const apiKey = getProviderApiKey(ENV_VAR2);
@@ -68637,7 +69016,9 @@ var init_dist12 = __esm(() => {
 var groq2;
 var init_groq = __esm(() => {
   init_dist12();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   groq2 = {
     id: "groq",
     name: "Groq",
@@ -68652,7 +69033,12 @@ var init_groq = __esm(() => {
       if (!apiKey) {
         throw new Error("GROQ_API_KEY is not set");
       }
-      return createGroq({ apiKey })(modelId);
+      const reasoningBody = getCompatReasoningBody(`groq/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
+      return createGroq({
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
+      })(modelId);
     },
     async fetchModels() {
       const apiKey = getProviderApiKey("GROQ_API_KEY");
@@ -72257,6 +72643,8 @@ function authHeaders() {
 var lmstudio;
 var init_lmstudio = __esm(() => {
   init_dist8();
+  init_config2();
+  init_compat_reasoning();
   lmstudio = {
     id: "lmstudio",
     name: "LM Studio",
@@ -72266,9 +72654,12 @@ var init_lmstudio = __esm(() => {
     asciiIcon: "L",
     description: "Local models via LM Studio \u2014 no key needed",
     createModel(modelId) {
+      const reasoningBody = getCompatReasoningBody(`lmstudio/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
       const client = createOpenAI({
         baseURL: openaiBase(),
-        apiKey: getApiToken()
+        apiKey: getApiToken(),
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
       });
       return client.chat(modelId);
     },
@@ -80526,7 +80917,9 @@ var init_dist19 = __esm(() => {
 var minimax2;
 var init_minimax = __esm(() => {
   init_dist19();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   minimax2 = {
     id: "minimax",
     name: "MiniMax",
@@ -80541,7 +80934,12 @@ var init_minimax = __esm(() => {
       if (!apiKey) {
         throw new Error("MINIMAX_API_KEY is not set");
       }
-      return createMinimaxAnthropic({ apiKey })(modelId);
+      const reasoningBody = getCompatReasoningBody(`minimax/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
+      return createMinimaxAnthropic({
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
+      })(modelId);
     },
     async fetchModels() {
       return null;
@@ -81415,6 +81813,8 @@ function getOllamaHost() {
 var ollama;
 var init_ollama = __esm(() => {
   init_dist8();
+  init_config2();
+  init_compat_reasoning();
   ollama = {
     id: "ollama",
     name: "Ollama",
@@ -81423,9 +81823,12 @@ var init_ollama = __esm(() => {
     asciiIcon: "O",
     description: "Local models \u2014 no key needed",
     createModel(modelId) {
+      const reasoningBody = getCompatReasoningBody(`ollama/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
       const client = createOpenAI({
         baseURL: `${getOllamaHost()}/v1`,
-        apiKey: "ollama"
+        apiKey: "ollama",
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
       });
       return client.chat(modelId);
     },
@@ -81542,7 +81945,9 @@ var init_openai = __esm(() => {
 var BASE_URL2 = "https://opencode.ai/zen/go/v1", opencodeGo;
 var init_opencode_go = __esm(() => {
   init_dist9();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   opencodeGo = {
     id: "opencode-go",
     name: "OpenCode Go",
@@ -81557,10 +81962,13 @@ var init_opencode_go = __esm(() => {
       if (!apiKey) {
         throw new Error("OPENCODE_GO_API_KEY is not set");
       }
+      const reasoningBody = getCompatReasoningBody(`opencode-go/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
       const provider = createOpenAICompatible({
         name: "opencode-go",
         baseURL: BASE_URL2,
-        apiKey
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
       });
       return provider.chatModel(modelId);
     },
@@ -81592,7 +82000,9 @@ var init_opencode_go = __esm(() => {
 var BASE_URL3 = "https://opencode.ai/zen/v1", opencodeZen;
 var init_opencode_zen = __esm(() => {
   init_dist9();
+  init_config2();
   init_secrets();
+  init_compat_reasoning();
   init_context_windows();
   opencodeZen = {
     id: "opencode-zen",
@@ -81609,10 +82019,13 @@ var init_opencode_zen = __esm(() => {
       if (!apiKey) {
         throw new Error("OPENCODE_ZEN_API_KEY is not set");
       }
+      const reasoningBody = getCompatReasoningBody(`opencode-zen/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
       const provider = createOpenAICompatible({
         name: "opencode-zen",
         baseURL: BASE_URL3,
-        apiKey
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
       });
       return provider.chatModel(modelId);
     },
@@ -87677,8 +88090,10 @@ var baseURL, proxy2;
 var init_proxy = __esm(() => {
   init_dist6();
   init_dist8();
+  init_config2();
   init_key_resolver();
   init_lifecycle();
+  init_compat_reasoning();
   init_context_windows();
   baseURL = process.env.PROXY_API_URL || "http://127.0.0.1:8317/v1";
   proxy2 = {
@@ -87693,7 +88108,13 @@ var init_proxy = __esm(() => {
       if (isAnthropicModel(modelId)) {
         return createAnthropic({ baseURL, apiKey })(modelId);
       }
-      return createOpenAI({ baseURL, apiKey }).chat(modelId);
+      const reasoningBody = getCompatReasoningBody(`proxy/${modelId}`, loadConfig());
+      const reasoningFetch = createReasoningFetchWrapper(reasoningBody);
+      return createOpenAI({
+        baseURL,
+        apiKey,
+        ...reasoningFetch ? { fetch: reasoningFetch } : {}
+      }).chat(modelId);
     },
     async fetchModels() {
       return null;
@@ -91420,13 +91841,18 @@ function extractBaseModel(modelId) {
   return (slash >= 0 ? modelId.slice(slash + 1) : modelId).toLowerCase();
 }
 function getClaudeGen(model) {
-  if (!model.startsWith("claude"))
+  let m = model;
+  if (m.startsWith("us."))
+    m = m.slice(3);
+  if (m.startsWith("anthropic."))
+    m = m.slice("anthropic.".length);
+  if (!m.startsWith("claude"))
     return "non-claude";
   for (const p of LEGACY_PREFIXES) {
-    if (model.startsWith(p))
+    if (m.startsWith(p))
       return "legacy";
   }
-  if (model.startsWith("claude-3.5") || model.startsWith("claude-3-5"))
+  if (m.startsWith("claude-3.5") || m.startsWith("claude-3-5"))
     return "3.5";
   return "4+";
 }
@@ -91434,17 +91860,25 @@ function detectModelFamily(modelId) {
   const { provider } = parseModelId(modelId);
   if (provider === "anthropic")
     return "claude";
-  if (provider === "openai" || provider === "xai")
+  if (provider === "openai")
     return "openai";
+  if (provider === "xai")
+    return "xai";
   if (provider === "google")
     return "google";
+  if (provider === "deepseek")
+    return "deepseek";
   const base = extractBaseModel(modelId);
-  if (base.startsWith("claude"))
+  if (base.startsWith("claude") || base.startsWith("anthropic.claude"))
     return "claude";
   if (base.startsWith("gpt-") || base.startsWith("o1") || base.startsWith("o3") || base.startsWith("o4"))
     return "openai";
   if (base.startsWith("gemini"))
     return "google";
+  if (base.startsWith("grok"))
+    return "xai";
+  if (base.startsWith("deepseek"))
+    return "deepseek";
   const model = parseModelId(modelId).model;
   if (model.startsWith("anthropic/"))
     return "claude";
@@ -91452,88 +91886,96 @@ function detectModelFamily(modelId) {
     return "openai";
   if (model.startsWith("google/"))
     return "google";
+  if (model.startsWith("x-ai/") || model.startsWith("xai/"))
+    return "xai";
+  if (model.startsWith("deepseek/"))
+    return "deepseek";
   return "other";
 }
 function getModelCapabilities3(modelId) {
   const base = extractBaseModel(modelId);
   const family = detectModelFamily(modelId);
+  const BASE = {
+    provider: "other",
+    thinking: false,
+    adaptiveThinking: false,
+    effort: false,
+    speed: false,
+    contextManagement: false,
+    interleavedThinking: false,
+    openaiReasoning: false,
+    openaiServiceTier: false,
+    googleThinking: false,
+    googleThinkingLevel: false,
+    xaiReasoning: false,
+    deepseekThinking: false,
+    openrouterReasoning: false,
+    compatReasoning: false
+  };
   if (family === "openai") {
     const isReasoning = base.startsWith("o1") || base.startsWith("o3") || base.startsWith("o4") || base.startsWith("gpt-5");
     return {
+      ...BASE,
       provider: "openai",
-      thinking: false,
-      adaptiveThinking: false,
-      effort: false,
-      speed: false,
-      contextManagement: false,
-      interleavedThinking: false,
       openaiReasoning: isReasoning,
       openaiServiceTier: true
     };
   }
   if (family === "google") {
+    const isGemini3 = /gemini-3(\.|-|$)/.test(base);
+    const isGemini25 = /gemini-2\.5/.test(base);
+    const supportsThinking = isGemini3 || isGemini25;
     return {
+      ...BASE,
       provider: "google",
-      thinking: false,
-      adaptiveThinking: false,
-      effort: false,
-      speed: false,
-      contextManagement: false,
-      interleavedThinking: false,
-      openaiReasoning: false,
-      openaiServiceTier: false
+      googleThinking: supportsThinking,
+      googleThinkingLevel: isGemini3
+    };
+  }
+  if (family === "xai") {
+    const isReasoning = base.startsWith("grok-3-mini") || base.startsWith("grok-4") || base.includes("reasoning");
+    return {
+      ...BASE,
+      provider: "xai",
+      xaiReasoning: isReasoning
+    };
+  }
+  if (family === "deepseek") {
+    const isChat = base === "deepseek-chat" || base.startsWith("deepseek-v3");
+    return {
+      ...BASE,
+      provider: "deepseek",
+      deepseekThinking: isChat,
+      compatReasoning: true
     };
   }
   if (family !== "claude") {
+    const isCompatReasoning = /qwen3/.test(base) || /glm-(4\.[5-9]|[5-9])/.test(base) || /kimi-(k2|thinking)/.test(base) || /gpt-oss/.test(base) || /deepseek-r1/.test(base) || /minimax-m[2-9]/.test(base);
     return {
-      provider: "other",
-      thinking: false,
-      adaptiveThinking: false,
-      effort: false,
-      speed: false,
-      contextManagement: false,
-      interleavedThinking: false,
-      openaiReasoning: false,
-      openaiServiceTier: false
+      ...BASE,
+      compatReasoning: isCompatReasoning
     };
   }
   const gen = getClaudeGen(base);
   if (gen === "legacy") {
-    return {
-      provider: "anthropic",
-      thinking: false,
-      adaptiveThinking: false,
-      effort: false,
-      speed: false,
-      contextManagement: false,
-      interleavedThinking: false,
-      openaiReasoning: false,
-      openaiServiceTier: false
-    };
+    return { ...BASE, provider: "anthropic" };
   }
   if (gen === "3.5") {
     return {
+      ...BASE,
       provider: "anthropic",
-      thinking: true,
-      adaptiveThinking: false,
-      effort: false,
-      speed: false,
-      contextManagement: false,
-      interleavedThinking: false,
-      openaiReasoning: false,
-      openaiServiceTier: false
+      thinking: true
     };
   }
   return {
+    ...BASE,
     provider: "anthropic",
     thinking: true,
     adaptiveThinking: true,
     effort: !base.includes("haiku"),
     speed: base.includes("opus"),
     contextManagement: !base.includes("haiku"),
-    interleavedThinking: true,
-    openaiReasoning: false,
-    openaiServiceTier: false
+    interleavedThinking: true
   };
 }
 function getProviderConstraints(providerId) {
@@ -91555,6 +91997,12 @@ function getEffectiveCaps(modelId) {
     ...model,
     anthropicOptions: pc.anthropicOptions && family === "claude",
     openaiOptions: pc.openaiOptions && family === "openai",
+    googleOptions: pc.googleOptions && family === "google" && model.googleThinking,
+    xaiOptions: pc.xaiOptions && family === "xai" && model.xaiReasoning,
+    deepseekOptions: pc.deepseekOptions && family === "deepseek" && model.deepseekThinking,
+    openrouterOptions: pc.openrouterOptions,
+    bedrockOptions: pc.bedrockOptions && family === "claude",
+    compatReasoningBody: pc.compatReasoningBody && (model.compatReasoning || model.deepseekThinking),
     adaptiveThinking: model.adaptiveThinking && pc.adaptiveThinking,
     effort: model.effort && pc.effort,
     speed: model.speed && pc.speed,
@@ -91657,9 +92105,6 @@ function getAnthropicToolVersions(modelId) {
   }
   return { computerUse, textEditor, programmaticToolCalling };
 }
-function supportsAnthropicOptions(modelId) {
-  return getEffectiveCaps(modelId).anthropicOptions;
-}
 function buildContextEdits(config2, contextWindow, thinkingEnabled) {
   const edits = [];
   if (config2?.clearThinking !== false && thinkingEnabled) {
@@ -91753,6 +92198,14 @@ function buildOpenAIOptions(caps, config2) {
     if (effort && effort !== "off") {
       opts.reasoningEffort = effort;
     }
+    const summary = config2.performance?.openaiReasoningSummary;
+    if (summary && summary !== "off") {
+      opts.reasoningSummary = summary;
+    }
+    const verbosity = config2.performance?.openaiVerbosity;
+    if (verbosity && verbosity !== "off") {
+      opts.verbosity = verbosity;
+    }
   }
   if (caps.openaiServiceTier) {
     const tier = config2.performance?.serviceTier;
@@ -91783,6 +92236,42 @@ async function buildProviderOptions(modelId, config2) {
       providerOptions.openai = result.opts;
     }
   }
+  if (caps.googleOptions) {
+    const result = buildGoogleOptions(modelId, caps, config2);
+    if (Object.keys(result.opts).length > 0) {
+      providerOptions.google = result.opts;
+    }
+  }
+  if (caps.xaiOptions) {
+    const result = buildXaiOptions(caps, config2);
+    if (Object.keys(result.opts).length > 0) {
+      providerOptions.xai = result.opts;
+    }
+  }
+  if (caps.deepseekOptions) {
+    const result = buildDeepseekOptions(caps, config2);
+    if (Object.keys(result.opts).length > 0) {
+      providerOptions.deepseek = result.opts;
+    }
+  }
+  if (caps.openrouterOptions) {
+    const result = buildOpenRouterOptions(caps, config2);
+    if (Object.keys(result.opts).length > 0) {
+      providerOptions.openrouter = result.opts;
+    }
+  }
+  if (caps.bedrockOptions) {
+    const result = buildBedrockOptions(modelId, caps, config2);
+    if (Object.keys(result.opts).length > 0) {
+      providerOptions.bedrock = result.opts;
+    }
+  }
+  if (parseModelId(modelId).provider === "groq") {
+    const result = buildGroqOptions(config2);
+    if (Object.keys(result.opts).length > 0) {
+      providerOptions.groq = result.opts;
+    }
+  }
   const { provider } = parseModelId(modelId);
   const customProvider2 = provider ? getProvider(provider) : null;
   if (customProvider2?.custom && customProvider2.customReasoning) {
@@ -91811,16 +92300,37 @@ async function buildProviderOptions(modelId, config2) {
   };
 }
 function degradeProviderOptions(modelId, level) {
-  if (level >= 2 || !supportsAnthropicOptions(modelId)) {
+  if (level >= 2) {
     return { providerOptions: {}, headers: undefined, contextWindow: 0 };
   }
-  const caps = getModelCapabilities3(modelId);
-  const opts = {};
-  if (caps.thinking) {
-    opts.thinking = { type: "enabled", budgetTokens: 5000 };
+  const caps = getEffectiveCaps(modelId);
+  const providerOptions = {};
+  if (caps.anthropicOptions && caps.thinking) {
+    const opts = { thinking: { type: "enabled", budgetTokens: 5000 } };
+    providerOptions.anthropic = opts;
+  }
+  if (caps.openaiOptions && caps.openaiReasoning) {
+    providerOptions.openai = { reasoningEffort: "low" };
+  }
+  if (caps.googleOptions && caps.googleThinking) {
+    providerOptions.google = caps.googleThinkingLevel ? { thinkingConfig: { thinkingLevel: "low" } } : { thinkingConfig: { thinkingBudget: 1024 } };
+  }
+  if (caps.xaiOptions && caps.xaiReasoning) {
+    providerOptions.xai = { reasoningEffort: "low" };
+  }
+  if (caps.deepseekOptions && caps.deepseekThinking) {
+    providerOptions.deepseek = { thinking: { type: "enabled" } };
+  }
+  if (caps.openrouterOptions) {
+    providerOptions.openrouter = { reasoning: { effort: "low" } };
+  }
+  if (caps.bedrockOptions && caps.thinking) {
+    providerOptions.bedrock = {
+      reasoningConfig: { type: "enabled", budgetTokens: 5000 }
+    };
   }
   return {
-    providerOptions: { anthropic: opts },
+    providerOptions,
     headers: undefined,
     contextWindow: 0
   };
@@ -91830,13 +92340,167 @@ function isProviderOptionsError(error48) {
   const lower = msg.toLowerCase();
   return lower.includes("not supported") || lower.includes("not available") || lower.includes("does not support") || lower.includes("invalid parameter") || lower.includes("inputschema") || lower.includes("thinking is not supported") || lower.includes("adaptive thinking") || lower.includes("clear_thinking") || lower.includes("context management") || lower.includes("unknown parameter") || lower.includes("temperature is deprecated");
 }
-var ANTHROPIC_FULL, OPENAI_FULL, GATEWAY_FULL, PROVIDER_CONSTRAINTS, NO_SUPPORT, LEGACY_PREFIXES, CACHE_EPHEMERAL, EPHEMERAL_CACHE;
+function buildGoogleOptions(modelId, caps, config2) {
+  const opts = {};
+  if (!caps.googleThinking)
+    return { opts };
+  const thinkingConfig = {};
+  if (caps.googleThinkingLevel) {
+    const level = config2.performance?.googleThinkingLevel;
+    if (level && level !== "off") {
+      thinkingConfig.thinkingLevel = level;
+    } else if (config2.performance?.effort && config2.performance.effort !== "off") {
+      const e = config2.performance.effort;
+      const mapped = e === "max" || e === "xhigh" ? "high" : e === "high" || e === "medium" || e === "low" ? e : null;
+      if (mapped)
+        thinkingConfig.thinkingLevel = mapped;
+    }
+  } else {
+    const budget = config2.performance?.googleThinkingBudget;
+    if (typeof budget === "number") {
+      thinkingConfig.thinkingBudget = budget;
+    } else if (budget !== "off" && config2.performance?.effort && config2.performance.effort !== "off") {
+      const map2 = {
+        low: 1024,
+        medium: 4096,
+        high: 8192,
+        xhigh: 16384,
+        max: 24576
+      };
+      const v = map2[config2.performance.effort];
+      if (v !== undefined)
+        thinkingConfig.thinkingBudget = v;
+    }
+  }
+  if (config2.performance?.googleIncludeThoughts) {
+    thinkingConfig.includeThoughts = true;
+  }
+  if (Object.keys(thinkingConfig).length > 0) {
+    opts.thinkingConfig = thinkingConfig;
+  }
+  return { opts };
+}
+function buildXaiOptions(caps, config2) {
+  const opts = {};
+  if (!caps.xaiReasoning)
+    return { opts };
+  const explicit = config2.performance?.xaiReasoningEffort;
+  if (explicit && explicit !== "off") {
+    opts.reasoningEffort = explicit === "medium" ? "high" : explicit;
+    return { opts };
+  }
+  const e = config2.performance?.effort;
+  if (e && e !== "off") {
+    opts.reasoningEffort = e === "low" ? "low" : "high";
+  }
+  return { opts };
+}
+function buildDeepseekOptions(caps, config2) {
+  const opts = {};
+  if (!caps.deepseekThinking)
+    return { opts };
+  const explicit = config2.performance?.deepseekThinking;
+  if (explicit === "enabled") {
+    opts.thinking = { type: "enabled" };
+    return { opts };
+  }
+  if (explicit === "off")
+    return { opts };
+  if (config2.performance?.effort && config2.performance.effort !== "off") {
+    opts.thinking = { type: "enabled" };
+  }
+  return { opts };
+}
+function buildOpenRouterOptions(caps, config2) {
+  const opts = {};
+  if (!caps.openrouterOptions)
+    return { opts };
+  const reasoning = {};
+  const explicitEffort = config2.performance?.openrouterReasoningEffort;
+  const explicitMax = config2.performance?.openrouterReasoningMaxTokens;
+  if (explicitMax !== undefined && explicitMax !== "off") {
+    reasoning.max_tokens = explicitMax;
+  } else if (explicitEffort && explicitEffort !== "off") {
+    reasoning.effort = explicitEffort;
+  } else if (config2.thinking?.mode === "enabled" && typeof config2.thinking?.budgetTokens === "number") {
+    reasoning.max_tokens = config2.thinking.budgetTokens;
+  } else {
+    const e = config2.performance?.effort;
+    if (e && e !== "off") {
+      const mapped = {
+        low: "low",
+        medium: "medium",
+        high: "high",
+        xhigh: "xhigh",
+        max: "xhigh"
+      };
+      const v = mapped[e];
+      if (v)
+        reasoning.effort = v;
+    }
+  }
+  if (config2.performance?.openrouterExcludeReasoning) {
+    reasoning.exclude = true;
+  }
+  if (Object.keys(reasoning).length > 0) {
+    opts.reasoning = reasoning;
+  }
+  return { opts };
+}
+function buildBedrockOptions(modelId, caps, config2) {
+  const opts = {};
+  if (!caps.bedrockOptions)
+    return { opts };
+  const reasoningConfig = {};
+  const mode = config2.thinking?.mode ?? "off";
+  if (mode === "auto" || mode === "adaptive") {
+    reasoningConfig.type = "adaptive";
+  } else if (mode === "enabled") {
+    reasoningConfig.type = "enabled";
+    if (config2.thinking?.budgetTokens) {
+      reasoningConfig.budgetTokens = config2.thinking.budgetTokens;
+    }
+  }
+  if (caps.effort && config2.performance?.effort && config2.performance.effort !== "off") {
+    const clamped = clampEffort(modelId, config2.performance.effort);
+    if (clamped)
+      reasoningConfig.maxReasoningEffort = clamped;
+  }
+  if (Object.keys(reasoningConfig).length > 0) {
+    opts.reasoningConfig = reasoningConfig;
+  }
+  return { opts };
+}
+function buildGroqOptions(config2) {
+  const opts = {};
+  const fmt = config2.performance?.groqReasoningFormat;
+  if (fmt && fmt !== "off") {
+    opts.reasoningFormat = fmt;
+  }
+  return { opts };
+}
+var NO_SUPPORT, ANTHROPIC_FULL, OPENAI_FULL, GOOGLE_FULL, XAI_FULL, DEEPSEEK_FULL, OPENROUTER_FULL, GATEWAY_FULL, COMPAT_ONLY, PROVIDER_CONSTRAINTS, LEGACY_PREFIXES, CACHE_EPHEMERAL, EPHEMERAL_CACHE;
 var init_provider_options = __esm(() => {
   init_models();
   init_providers();
+  NO_SUPPORT = {
+    anthropicOptions: false,
+    openaiOptions: false,
+    googleOptions: false,
+    xaiOptions: false,
+    deepseekOptions: false,
+    openrouterOptions: false,
+    bedrockOptions: false,
+    effort: false,
+    speed: false,
+    contextManagement: false,
+    adaptiveThinking: false,
+    interleavedThinking: false,
+    compatReasoningBody: false
+  };
   ANTHROPIC_FULL = {
+    ...NO_SUPPORT,
     anthropicOptions: true,
-    openaiOptions: false,
     effort: true,
     speed: true,
     contextManagement: true,
@@ -91844,43 +92508,82 @@ var init_provider_options = __esm(() => {
     interleavedThinking: true
   };
   OPENAI_FULL = {
-    anthropicOptions: false,
+    ...NO_SUPPORT,
+    openaiOptions: true
+  };
+  GOOGLE_FULL = {
+    ...NO_SUPPORT,
+    googleOptions: true
+  };
+  XAI_FULL = {
+    ...NO_SUPPORT,
+    xaiOptions: true
+  };
+  DEEPSEEK_FULL = {
+    ...NO_SUPPORT,
+    deepseekOptions: true,
+    compatReasoningBody: true
+  };
+  OPENROUTER_FULL = {
+    ...NO_SUPPORT,
+    openrouterOptions: true,
+    anthropicOptions: true,
     openaiOptions: true,
-    effort: false,
-    speed: false,
-    contextManagement: false,
-    adaptiveThinking: false,
-    interleavedThinking: false
+    googleOptions: true,
+    xaiOptions: true,
+    deepseekOptions: true,
+    effort: true,
+    speed: true,
+    adaptiveThinking: true,
+    interleavedThinking: true
   };
   GATEWAY_FULL = {
     anthropicOptions: true,
     openaiOptions: true,
+    googleOptions: true,
+    xaiOptions: true,
+    deepseekOptions: true,
+    openrouterOptions: false,
+    bedrockOptions: false,
     effort: true,
     speed: true,
     contextManagement: true,
     adaptiveThinking: true,
-    interleavedThinking: true
+    interleavedThinking: true,
+    compatReasoningBody: false
+  };
+  COMPAT_ONLY = {
+    ...NO_SUPPORT,
+    compatReasoningBody: true
   };
   PROVIDER_CONSTRAINTS = {
     anthropic: ANTHROPIC_FULL,
     proxy: GATEWAY_FULL,
     openai: OPENAI_FULL,
-    xai: OPENAI_FULL,
+    xai: XAI_FULL,
+    google: GOOGLE_FULL,
+    deepseek: DEEPSEEK_FULL,
+    openrouter: OPENROUTER_FULL,
+    groq: COMPAT_ONLY,
+    fireworks: COMPAT_ONLY,
+    minimax: COMPAT_ONLY,
+    copilot: COMPAT_ONLY,
+    "github-models": COMPAT_ONLY,
+    "opencode-zen": { ...GATEWAY_FULL, compatReasoningBody: true },
+    "opencode-go": COMPAT_ONLY,
+    lmstudio: COMPAT_ONLY,
+    ollama: COMPAT_ONLY,
     vercel_gateway: GATEWAY_FULL,
     llmgateway: GATEWAY_FULL,
-    opencode_zen: GATEWAY_FULL,
-    opencode_go: GATEWAY_FULL,
-    openrouter: GATEWAY_FULL,
-    bedrock: GATEWAY_FULL
-  };
-  NO_SUPPORT = {
-    anthropicOptions: false,
-    openaiOptions: false,
-    effort: false,
-    speed: false,
-    contextManagement: false,
-    adaptiveThinking: false,
-    interleavedThinking: false
+    bedrock: {
+      ...NO_SUPPORT,
+      bedrockOptions: true,
+      effort: true,
+      speed: false,
+      contextManagement: false,
+      adaptiveThinking: true,
+      interleavedThinking: false
+    }
   };
   LEGACY_PREFIXES = [
     "claude-3-haiku",
@@ -406659,7 +407362,11 @@ For non-TS/JS files (JSON, YAML, Markdown, config) or raw text outside any symbo
 
 Recall fires automatically before each user turn \u2014 prompt + edited files \u2192 top-3 relevant memories injected as <recalled_memories> stubs (summary + id + signals + "\u21B3 has details" marker), \u2264600 chars typical. Cached, deduped, never re-injected in one session. When a stub's "\u21B3 has details" marker matters to the current task, call memory(action:"get", id:<8-char prefix>) to read the full body.
 
-Auto-recall is signal-driven and misses generic or single-word prompts. Before any action where convention matters and nothing was surfaced \u2014 first commit of a session, adopting a framework/tool, changing config layout, writing tests in an unfamiliar area, picking a naming style \u2014 run memory(action:"search", query:<topic>) once. Cheap, deterministic, beats guessing. WRITE proactively, SEARCH when convention matters and nothing was recalled.
+Auto-recall is signal-driven and misses generic or single-word prompts. Before any action where convention matters and nothing was surfaced \u2014 first commit of a session, adopting a framework/tool, changing config layout, writing tests in an unfamiliar area, picking a naming style \u2014 run memory(action:"search", query:<topic>) once. Cheap, deterministic, beats guessing.
+
+SEARCH KEYWORDS \u2014 fall back to memory(search) when about to do any of these and recall was empty: commit message shape, lint/format choice, test framework conventions, package manager (bun/npm/pnpm/yarn), import style, file naming, error-handling pattern, logger choice, state-management library, dispatch/agent setup, prompt-engineering rules. One search beats one wrong guess.
+
+WRITE proactively, SEARCH when convention matters and nothing was recalled.
 
 WHY WRITES MATTER \u2014 the system multiplies them:
 - Soul Map stable file_id \u2192 memory on \`src/jwt.ts\` survives renames and refactors.
@@ -406670,6 +407377,13 @@ WHY WRITES MATTER \u2014 the system multiplies them:
 
 WHEN TO WRITE \u2014 the three triggers (fire on ANY of these, not just user-prompted ones):
 1. USER STATES A PREFERENCE OR DIRECTIVE.  "use bun not npm", "be terse", "always run tests after edits" \u2192 pref. Write immediately, scope:"global" if it's not project-specific.
+   INFER FROM CUES \u2014 don't wait for the word "remember". A preference exists whenever the user's correction or instruction implies a standing rule, not a one-shot fix. Cues that mean "this is durable":
+   \u2022 Corrective tone about HOW you did something ("be more concise", "stop narrating", "use bullets") \u2014 the correction itself IS the rule.
+   \u2022 Generalising language: "always", "never", "from now on", "by default", "prefer", "in this repo we\u2026", "we don't\u2026".
+   \u2022 Imperative meta-instructions about workflow, style, tooling, formatting, naming \u2014 anything orthogonal to the current task.
+   \u2022 User repeats or rephrases the same correction \u2192 it's a rule you missed last time. Write it now.
+   \u2022 User asks "why didn't you\u2026?" about a behavior \u2014 they had an expectation. Capture the expectation.
+   The literal word "remember" is just one cue among many. The test: "Would future-me want this surfaced next session?" If yes \u2192 write. Mid-instruction corrections ("commit it, and be concise") split into two acts: do the task, write the rule.
 2. A CHOICE GETS MADE WITH A REASON.  "switching to zustand because redux is too much boilerplate", "postgres not mysql for the JSON ops" \u2192 decision. The WHY is what future you needs (the Soul Map shows the WHAT). Capture the rationale in details.
 3. SHARP-EDGE DISCOVERED.  Bug that took >5min to diagnose, non-obvious quirk, "don't touch X because Y", a workaround for a flaky test \u2192 gotcha. Include the symptom + the fix location.
 
@@ -406731,7 +407445,7 @@ Use dedicated tools over shell for file reads, searches, definitions, and edits.
 For TS/JS (.ts/.tsx/.js/.jsx/.mts/.cts/.mjs/.cjs): \`ast_edit\` is the default \u2014 ts-morph locates symbols by {target, name}, no oldString/line drift. Use \`edit_file\`/\`multi_edit\` only for non-TS/JS or raw text outside any symbol (always pass \`lineStart\` from read output).
 Batch independent tool calls in one parallel block. Use the \`git\` tool for git, \`soul_vision\` for images.
 
-\`memory\` is your across-session brain \u2014 auto-recall fires before each user turn (top-3 stubs, \u2264600 chars typical; call memory(get, id) to read full body when "\u21B3 has details" matters). Use it like a primary tool, not a last resort: every write earns its keep when a future ambiguous prompt triggers the right recall. WRITE on (1) user preference/directive \u2192 pref, (2) choice with rationale \u2192 decision, (3) sharp edge that took effort to find \u2192 gotcha. Always set \`file_paths\` for file-scoped memories \u2014 strongest recall signal, co-change-aware. On similar_hints (\u226585% cosine), \`get\` the existing entry; refinement \u2192 merge_topics:true, contradiction \u2192 supersede. On recall conflict with the current request, raise it before acting. Soft-delete only; \u22643 surfaced per turn hard cap means a bad write won't poison context.
+\`memory\` is your across-session brain \u2014 auto-recall fires before each user turn (top-3 stubs, \u2264600 chars typical; call memory(get, id) to read full body when "\u21B3 has details" matters). Use it like a primary tool, not a last resort: every write earns its keep when a future ambiguous prompt triggers the right recall. WRITE on (1) user preference/directive \u2192 pref. Infer from cues, don't wait for "remember": corrective tone about HOW you worked ("be terse", "stop narrating"), generalising language ("always/never/by default/we don't"), repeated corrections, or "why didn't you\u2026?" questions all signal a standing rule. Mid-instruction corrections ("commit it, and be concise") split into two acts: do the task, write the rule. (2) choice with rationale \u2192 decision, (3) sharp edge that took effort to find \u2192 gotcha. SEARCH fallback: when about to commit, pick a framework/lib, name a file, or apply any convention and recall was empty, run memory(search, query) once before guessing. Always set \`file_paths\` for file-scoped memories \u2014 strongest recall signal, co-change-aware. On similar_hints (\u226585% cosine), \`get\` the existing entry; refinement \u2192 merge_topics:true, contradiction \u2192 supersede. On recall conflict with the current request, raise it before acting. Soft-delete only; \u22643 surfaced per turn hard cap means a bad write won't poison context.
 </tool_usage>`;
 
 // src/core/prompts/shared/index.ts
@@ -406780,6 +407494,8 @@ var init_builder = __esm(() => {
     claude: CLAUDE_PROMPT,
     openai: OPENAI_PROMPT,
     google: GOOGLE_PROMPT,
+    xai: OPENAI_PROMPT,
+    deepseek: OPENAI_PROMPT,
     other: DEFAULT_PROMPT
   };
 });
@@ -429107,6 +429823,11 @@ class HearthDaemon {
       return;
     const ws = this.workspaces.get(surfaceId, msg.externalId);
     const hasBridge = hearthBridge.getBinding(surfaceId, msg.externalId) !== null;
+    if (SETTINGS_COMMAND_NAMES.includes(cmd.name)) {
+      const handled = await handleSettingsCommand(cmd.name, cmd.args, (text3) => surface.notify(msg.externalId, text3));
+      if (handled)
+        return;
+    }
     if (hasBridge) {
       switch (cmd.name) {
         case "/tabs":
@@ -429499,6 +430220,9 @@ class HearthDaemon {
             "\u2501\u2501 Pairing \u2501\u2501",
             "/pair [CODE]           pair this chat",
             "/unpair                revoke",
+            "",
+            ...settingsHelpLines(),
+            "",
             "/help                  this list"
           ].join(`
 `));
@@ -429714,6 +430438,7 @@ var init_daemon = __esm(() => {
   init_pairing();
   init_peer_auth();
   init_protocol();
+  init_provider_commands();
   init_redact();
   init_surface_host();
   init_workspace();
@@ -478306,6 +479031,11 @@ class TuiHost {
     const surface = this.host.getSurface(surfaceId);
     if (!surface)
       return;
+    if (SETTINGS_COMMAND_NAMES.includes(cmd.name)) {
+      const handled = await handleSettingsCommand(cmd.name, cmd.args, (text3) => surface.notify(msg.externalId, text3));
+      if (handled)
+        return;
+    }
     switch (cmd.name) {
       case "/tabs":
       case "/list": {
@@ -478851,6 +479581,9 @@ class TuiHost {
           "\u2501\u2501 Pairing \u2501\u2501",
           "/pair [CODE]           pair this chat \xB7 redeem a code",
           "/unpair                revoke pairing",
+          "",
+          ...settingsHelpLines(),
+          "",
           "/help                  this list"
         ].join(`
 `));
@@ -478928,6 +479661,7 @@ var init_tui_host = __esm(() => {
   init_config();
   init_pairing();
   init_protocol();
+  init_provider_commands();
   init_redact();
   init_surface_host();
 });
@@ -496528,7 +497262,7 @@ var init_LockInStreamView = __esm(async () => {
     const dispatchCalls = import_react42.useMemo(() => {
       const next = liveToolCalls.filter((tc) => SUBAGENT_NAMES.has(tc.toolName));
       const prev = dispatchRef.current;
-      if (prev.length === next.length && prev.every((p2, i4) => p2 === next[i4] || p2.id === next[i4]?.id)) {
+      if (prev.length === next.length && prev.every((p2, i4) => next[i4] !== undefined && p2.id === next[i4]?.id && p2.state === next[i4]?.state && p2.args === next[i4]?.args && p2.result === next[i4]?.result && p2.error === next[i4]?.error && p2.progressText === next[i4]?.progressText)) {
         return prev;
       }
       dispatchRef.current = next;
@@ -518784,6 +519518,32 @@ function readValuesFromLayer(layer) {
     v4.openaiReasoningEffort = layer.performance.openaiReasoningEffort;
   if (layer.performance?.serviceTier !== undefined)
     v4.serviceTier = layer.performance.serviceTier;
+  if (layer.performance?.googleThinkingLevel !== undefined)
+    v4.googleThinkingLevel = layer.performance.googleThinkingLevel;
+  if (layer.performance?.googleThinkingBudget !== undefined)
+    v4.googleThinkingBudget = String(layer.performance.googleThinkingBudget);
+  if (layer.performance?.googleIncludeThoughts !== undefined)
+    v4.googleIncludeThoughts = layer.performance.googleIncludeThoughts;
+  if (layer.performance?.xaiReasoningEffort !== undefined)
+    v4.xaiReasoningEffort = layer.performance.xaiReasoningEffort;
+  if (layer.performance?.deepseekThinking !== undefined)
+    v4.deepseekThinking = layer.performance.deepseekThinking;
+  if (layer.performance?.openrouterReasoningEffort !== undefined)
+    v4.openrouterReasoningEffort = layer.performance.openrouterReasoningEffort;
+  if (layer.performance?.openrouterReasoningMaxTokens !== undefined)
+    v4.openrouterReasoningMaxTokens = String(layer.performance.openrouterReasoningMaxTokens);
+  if (layer.performance?.openrouterExcludeReasoning !== undefined)
+    v4.openrouterExcludeReasoning = layer.performance.openrouterExcludeReasoning;
+  if (layer.performance?.compatReasoningEffort !== undefined)
+    v4.compatReasoningEffort = layer.performance.compatReasoningEffort;
+  if (layer.performance?.groqReasoningEffort !== undefined)
+    v4.groqReasoningEffort = layer.performance.groqReasoningEffort;
+  if (layer.performance?.openaiReasoningSummary !== undefined)
+    v4.openaiReasoningSummary = layer.performance.openaiReasoningSummary;
+  if (layer.performance?.openaiVerbosity !== undefined)
+    v4.openaiVerbosity = layer.performance.openaiVerbosity;
+  if (layer.performance?.groqReasoningFormat !== undefined)
+    v4.groqReasoningFormat = layer.performance.groqReasoningFormat;
   if (layer.codeExecution !== undefined)
     v4.codeExecution = layer.codeExecution;
   if (layer.computerUse !== undefined)
@@ -518829,6 +519589,36 @@ function buildPatch(key3, value) {
       return { performance: { openaiReasoningEffort: value } };
     case "serviceTier":
       return { performance: { serviceTier: value } };
+    case "googleThinkingLevel":
+      return { performance: { googleThinkingLevel: value } };
+    case "googleThinkingBudget": {
+      const v4 = value === "off" ? "off" : Number(value);
+      return { performance: { googleThinkingBudget: v4 } };
+    }
+    case "googleIncludeThoughts":
+      return { performance: { googleIncludeThoughts: value } };
+    case "xaiReasoningEffort":
+      return { performance: { xaiReasoningEffort: value } };
+    case "deepseekThinking":
+      return { performance: { deepseekThinking: value } };
+    case "openrouterReasoningEffort":
+      return { performance: { openrouterReasoningEffort: value } };
+    case "openrouterReasoningMaxTokens": {
+      const v4 = value === "off" ? "off" : Number(value);
+      return { performance: { openrouterReasoningMaxTokens: v4 } };
+    }
+    case "openrouterExcludeReasoning":
+      return { performance: { openrouterExcludeReasoning: value } };
+    case "compatReasoningEffort":
+      return { performance: { compatReasoningEffort: value } };
+    case "groqReasoningEffort":
+      return { performance: { groqReasoningEffort: value } };
+    case "openaiReasoningSummary":
+      return { performance: { openaiReasoningSummary: value } };
+    case "openaiVerbosity":
+      return { performance: { openaiVerbosity: value } };
+    case "groqReasoningFormat":
+      return { performance: { groqReasoningFormat: value } };
     case "codeExecution":
       return { codeExecution: value };
     case "computerUse":
@@ -518873,7 +519663,7 @@ function ProviderSettings({
   const { width: termCols, height: termRows } = useTerminalDimensions();
   const containerRows = termRows - 2;
   const popupWidth = Math.min(MAX_POPUP_WIDTH4, Math.floor(termCols * 0.85));
-  const maxVisible = Math.max(4, Math.floor(containerRows * 0.85) - CHROME_ROWS6);
+  const maxVisible = Math.max(6, Math.floor(containerRows * 0.85) - CHROME_ROWS6);
   const t2 = useTheme();
   const [tab, setTab] = import_react136.useState("claude");
   const [cursor, setCursor] = import_react136.useState(0);
@@ -518881,12 +519671,13 @@ function ProviderSettings({
   const vals = effectiveValues(globalConfig2, projectConfig);
   const items = TAB_ITEMS[tab];
   const tabIdx = TABS5.indexOf(tab);
+  const firstRowIdx = items.findIndex((i4) => i4.type !== "section" && i4.type !== "info");
   import_react136.useEffect(() => {
     if (visible)
       setScope(detectInitialScope(projectConfig));
   }, [visible, projectConfig]);
   import_react136.useEffect(() => {
-    setCursor(0);
+    setCursor(Math.max(0, firstRowIdx));
   }, [tab]);
   const isBudgetDisabled = vals.thinkingMode !== "enabled";
   const isThinkingDisabled = vals.thinkingMode === "off" || vals.thinkingMode === "disabled";
@@ -518897,6 +519688,19 @@ function ProviderSettings({
       return isThinkingDisabled;
     return false;
   };
+  const stepCursor = (dir) => {
+    if (items.length === 0)
+      return;
+    let next = cursor;
+    for (let i4 = 0;i4 < items.length; i4++) {
+      next = (next + dir + items.length) % items.length;
+      const it = items[next];
+      if (it && it.type !== "section" && it.type !== "info") {
+        setCursor(next);
+        return;
+      }
+    }
+  };
   const cycleValue = (item) => {
     if (item.type === "toggle") {
       if (isItemDisabled(item.key))
@@ -518935,16 +519739,16 @@ function ProviderSettings({
       return;
     }
     if (evt.name === "up") {
-      setCursor((c) => c > 0 ? c - 1 : items.length - 1);
+      stepCursor(-1);
       return;
     }
     if (evt.name === "down") {
-      setCursor((c) => c < items.length - 1 ? c + 1 : 0);
+      stepCursor(1);
       return;
     }
     if (evt.name === "return" || evt.name === " ") {
       const item = items[cursor];
-      if (item)
+      if (item && item.type !== "section" && item.type !== "info")
         cycleValue(item);
       return;
     }
@@ -518973,6 +519777,9 @@ function ProviderSettings({
   const sidebarW = 22;
   const contentW = popupWidth - sidebarW - 3;
   const labelW = 22;
+  const focusedItem = items[cursor];
+  const focusedRow = focusedItem && focusedItem.type !== "section" && focusedItem.type !== "info" ? focusedItem : null;
+  const focusedDisabled = focusedRow ? isItemDisabled(focusedRow.key) : false;
   return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(PremiumPopup, {
     visible,
     width: popupWidth,
@@ -518981,14 +519788,25 @@ function ProviderSettings({
     titleIcon: "system",
     tabs: [
       { id: "claude", label: "Claude", icon: "ai", blurb: "thinking \xB7 reasoning \xB7 beta" },
-      { id: "openai", label: "OpenAI", icon: "ai", blurb: "reasoning effort \xB7 summary" },
-      { id: "general", label: "General", icon: "cloud", blurb: "shared provider options" }
+      { id: "openai", label: "OpenAI", icon: "ai", blurb: "reasoning \xB7 service tier" },
+      { id: "google", label: "Gemini", icon: "ai", blurb: "thinking level \xB7 budget" },
+      { id: "xai", label: "Grok", icon: "ai", blurb: "reasoning effort" },
+      { id: "deepseek", label: "DeepSeek", icon: "ai", blurb: "thinking toggle" },
+      { id: "openrouter", label: "OpenRouter", icon: "cloud", blurb: "unified reasoning" },
+      {
+        id: "compat",
+        label: "Other",
+        icon: "cloud",
+        blurb: "Groq \xB7 OpenCode \xB7 Fireworks \xB7 LM Studio \xB7 Ollama \u2026"
+      },
+      { id: "general", label: "General", icon: "cloud", blurb: "shared options" }
     ],
     activeTab: tab,
     footerHints: [
-      { key: "Tab", label: "switch tab" },
+      { key: "Tab", label: "tab" },
       { key: "\u2191\u2193", label: "nav" },
-      { key: "Enter/\u2190\u2192", label: "cycle" },
+      { key: "Enter", label: "cycle" },
+      { key: "\u2190\u2192", label: "scope" },
       { key: "Esc", label: "close" }
     ],
     children: [
@@ -519006,140 +519824,144 @@ function ProviderSettings({
           items,
           selectedIndex: cursor,
           width: contentW,
-          maxRows: Math.max(1, Math.floor(maxVisible / 3)),
-          rowHeight: 3,
-          keyExtractor: (item) => item.key,
+          maxRows: maxVisible,
+          rowHeight: 1,
+          keyExtractor: (item, idx) => item.type === "section" ? `sec-${idx}-${item.label}` : item.type === "info" ? `info-${idx}` : item.key,
           renderItem: (item, { selected }) => {
+            if (item.type === "section") {
+              return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+                flexDirection: "row",
+                backgroundColor: t2.bgPopup,
+                paddingX: 1,
+                children: [
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: t2.bgPopup,
+                    fg: t2.textMuted,
+                    attributes: 1,
+                    children: item.label.toUpperCase()
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: t2.bgPopup,
+                    fg: t2.textFaint,
+                    children: [
+                      "  ",
+                      "\u2500".repeat(Math.max(0, contentW - item.label.length - 6))
+                    ]
+                  }, undefined, true, undefined, this)
+                ]
+              }, undefined, true, undefined, this);
+            }
+            if (item.type === "info") {
+              return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+                flexDirection: "row",
+                backgroundColor: t2.bgPopup,
+                paddingX: 1,
+                children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                  bg: t2.bgPopup,
+                  fg: t2.textFaint,
+                  children: [
+                    "\u2139 ",
+                    item.text
+                  ]
+                }, undefined, true, undefined, this)
+              }, undefined, false, undefined, this);
+            }
             const disabled = isItemDisabled(item.key);
             const bg2 = selected ? t2.bgPopupHighlight : t2.bgPopup;
             const raw2 = vals[item.key];
             const srcScope = detectValueScope(item.key, projectConfig);
-            const srcTag = srcScope === "project" ? "proj" : "glob";
-            const srcColor = srcScope === "project" ? t2.info : t2.textMuted;
-            const caption = /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-              bg: bg2,
-              fg: t2.textFaint,
-              children: [
-                "      ",
-                item.desc
-              ]
-            }, undefined, true, undefined, this);
+            const showScope = srcScope === "project";
             let body4;
             if (item.type === "toggle") {
+              const on = !!raw2;
               body4 = /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
                 flexDirection: "row",
                 backgroundColor: bg2,
                 children: [
-                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(Toggle, {
-                    label: item.label,
-                    on: !!raw2,
-                    focused: selected && !disabled,
-                    bg: bg2
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: selected ? t2.brand : t2.textFaint,
+                    children: selected ? "\u25B8 " : "  "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: disabled ? t2.textDim : selected ? t2.brand : t2.textPrimary,
+                    attributes: selected ? 1 : undefined,
+                    children: item.label.padEnd(labelW)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: disabled ? t2.textDim : on ? t2.success : t2.textDim,
+                    children: on ? "\u25CF on " : "\u25CB off"
                   }, undefined, false, undefined, this),
                   /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
                     flexGrow: 1,
                     backgroundColor: bg2
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                  showScope ? /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
                     bg: bg2,
-                    fg: srcColor,
-                    children: [
-                      srcTag,
-                      "  "
-                    ]
-                  }, undefined, true, undefined, this)
+                    fg: t2.info,
+                    children: "proj"
+                  }, undefined, false, undefined, this) : null
                 ]
               }, undefined, true, undefined, this);
             } else {
               const opts = item.options ?? [];
               const currentValue = item.type === "budget" ? String(vals.budgetTokens) : String(raw2);
-              const optsFit = opts.length > 0 && opts.join("  ").length + labelW + 4 <= contentW - 10;
-              if (optsFit) {
-                body4 = /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
-                  flexDirection: "row",
-                  backgroundColor: bg2,
-                  children: [
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(SegmentedControl, {
-                      label: item.label,
-                      labelWidth: labelW,
-                      options: opts.map((o3) => ({ value: o3, label: o3 })),
-                      value: currentValue,
-                      focused: selected && !disabled,
-                      bg: bg2
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
-                      flexGrow: 1,
-                      backgroundColor: bg2
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-                      bg: bg2,
-                      fg: srcColor,
-                      children: [
-                        srcTag,
-                        "  "
-                      ]
-                    }, undefined, true, undefined, this)
-                  ]
-                }, undefined, true, undefined, this);
-              } else {
-                const valColor = disabled ? t2.textFaint : raw2 === "off" ? t2.textMuted : t2.brandAlt;
-                body4 = /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
-                  flexDirection: "row",
-                  backgroundColor: bg2,
-                  children: [
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-                      bg: bg2,
-                      fg: selected ? t2.brand : t2.textFaint,
-                      children: selected ? "\u25B8 " : "  "
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-                      bg: bg2,
-                      fg: disabled ? t2.textFaint : selected ? t2.brand : t2.textPrimary,
-                      attributes: selected ? 1 : undefined,
-                      children: item.label.padEnd(labelW)
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-                      bg: bg2,
-                      fg: valColor,
-                      attributes: 1,
-                      children: [
-                        "[",
-                        currentValue,
-                        "]"
-                      ]
-                    }, undefined, true, undefined, this),
-                    selected && !disabled ? /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-                      bg: bg2,
-                      fg: t2.textDim,
-                      children: "  \u2190 \u2192"
-                    }, undefined, false, undefined, this) : null,
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
-                      flexGrow: 1,
-                      backgroundColor: bg2
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
-                      bg: bg2,
-                      fg: srcColor,
-                      children: [
-                        srcTag,
-                        "  "
-                      ]
-                    }, undefined, true, undefined, this)
-                  ]
-                }, undefined, true, undefined, this);
-              }
+              const valColor = disabled ? t2.textDim : currentValue === "off" ? t2.textMuted : t2.brandAlt;
+              body4 = /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+                flexDirection: "row",
+                backgroundColor: bg2,
+                children: [
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: selected ? t2.brand : t2.textFaint,
+                    children: selected ? "\u25B8 " : "  "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: disabled ? t2.textDim : selected ? t2.brand : t2.textPrimary,
+                    attributes: selected ? 1 : undefined,
+                    children: item.label.padEnd(labelW)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: valColor,
+                    attributes: 1,
+                    children: [
+                      "[",
+                      currentValue,
+                      "]"
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: t2.textFaint,
+                    children: [
+                      "  ",
+                      opts.filter((o3) => o3 !== currentValue).slice(0, 4).join(" \xB7 ")
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+                    flexGrow: 1,
+                    backgroundColor: bg2
+                  }, undefined, false, undefined, this),
+                  showScope ? /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+                    bg: bg2,
+                    fg: t2.info,
+                    children: "proj"
+                  }, undefined, false, undefined, this) : null
+                ]
+              }, undefined, true, undefined, this);
             }
             return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
-              flexDirection: "column",
+              flexDirection: "row",
               flexShrink: 0,
               backgroundColor: bg2,
               paddingX: 1,
-              height: 3,
-              children: [
-                body4,
-                caption
-              ]
-            }, undefined, true, undefined, this);
+              height: 1,
+              children: body4
+            }, undefined, false, undefined, this);
           }
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
@@ -519147,20 +519969,44 @@ function ProviderSettings({
         width: contentW
       }, undefined, false, undefined, this),
       /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+        flexDirection: "column",
         paddingX: 2,
         paddingY: 1,
         backgroundColor: t2.bgPopup,
-        children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(SegmentedControl, {
-          label: "Save to",
-          labelWidth: 8,
-          options: CONFIG_SCOPES.map((s2) => ({ value: s2, label: s2 })),
-          value: scope
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
+        children: [
+          focusedRow ? /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+            flexDirection: "row",
+            backgroundColor: t2.bgPopup,
+            children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+              bg: t2.bgPopup,
+              fg: focusedDisabled ? t2.textDim : t2.textMuted,
+              children: focusedRow.desc
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this) : /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+            flexDirection: "row",
+            backgroundColor: t2.bgPopup,
+            children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
+              bg: t2.bgPopup,
+              fg: t2.textFaint,
+              children: " "
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("box", {
+            flexDirection: "row",
+            backgroundColor: t2.bgPopup,
+            children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(SegmentedControl, {
+              label: "Save to",
+              labelWidth: 8,
+              options: CONFIG_SCOPES.map((s2) => ({ value: s2, label: s2 })),
+              value: scope
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
-var import_react136, MAX_POPUP_WIDTH4 = 110, CHROME_ROWS6 = 10, TABS5, CLAUDE_ITEMS, OPENAI_ITEMS, GENERAL_ITEMS, TAB_ITEMS, DEFAULTS;
+var import_react136, MAX_POPUP_WIDTH4 = 110, CHROME_ROWS6 = 10, TABS5, CLAUDE_ITEMS, OPENAI_ITEMS, GENERAL_ITEMS, GOOGLE_ITEMS, XAI_ITEMS, DEEPSEEK_ITEMS, OPENROUTER_ITEMS, COMPAT_ITEMS, TAB_ITEMS, DEFAULTS;
 var init_ProviderSettings = __esm(async () => {
   init_theme();
   init_shared2();
@@ -519168,125 +520014,279 @@ var init_ProviderSettings = __esm(async () => {
   init_jsx_dev_runtime();
   await init_react2();
   import_react136 = __toESM(require_react(), 1);
-  TABS5 = ["claude", "openai", "general"];
+  TABS5 = [
+    "claude",
+    "openai",
+    "google",
+    "xai",
+    "deepseek",
+    "openrouter",
+    "compat",
+    "general"
+  ];
   CLAUDE_ITEMS = [
+    { type: "section", label: "Reasoning" },
     {
       key: "thinkingMode",
       label: "Thinking",
-      desc: "off | auto (adaptive) | enabled (fixed budget)",
+      desc: "Extended thinking mode. auto = adaptive \xB7 enabled = fixed budget",
       type: "cycle",
-      options: ["off", "disabled", "auto", "adaptive", "enabled"]
+      options: ["off", "auto", "adaptive", "enabled"]
     },
     {
       key: "budgetTokens",
-      label: "Budget Tokens",
-      desc: "Token budget for enabled thinking mode",
+      label: "Budget",
+      desc: "Token budget when thinking = enabled",
       type: "budget",
       options: ["1024", "2048", "5000", "10000", "20000"]
     },
-    {
-      key: "clearThinking",
-      label: "Preserve Thinking",
-      desc: "Keep all thinking blocks across turns for better cache hits. Off = Anthropic default (only last turn kept). Requires thinking enabled.",
-      type: "toggle"
-    },
     {
       key: "effort",
       label: "Effort",
-      desc: "Reasoning depth \u2014 affects thinking, text, and tool calls",
+      desc: "Reasoning depth across thinking, text, and tool calls",
       type: "cycle",
       options: ["off", "low", "medium", "high", "xhigh", "max"]
     },
+    {
+      key: "clearThinking",
+      label: "Preserve thinking",
+      desc: "Keep thinking blocks across turns for cache hits (requires thinking on)",
+      type: "toggle"
+    },
+    { type: "section", label: "Performance" },
     {
       key: "speed",
       label: "Speed",
-      desc: "Opus 4.6 \u2014 2.5x faster output (standard | fast)",
+      desc: "Opus 4.6 only \u2014 2.5\xD7 faster output",
       type: "cycle",
       options: ["off", "standard", "fast"]
     },
     {
-      key: "codeExecution",
-      label: "Code Execution",
-      desc: "Programmatic tool calling \u2014 batches reads in Python, saves tokens",
+      key: "toolStreaming",
+      label: "Tool streaming",
+      desc: "Stream tool call args incrementally",
       type: "toggle"
     },
     {
-      key: "computerUse",
-      label: "Computer Use",
-      desc: "Keyboard/mouse/screenshot control",
+      key: "sendReasoning",
+      label: "Send reasoning",
+      desc: "Include reasoning content in multi-turn requests",
       type: "toggle"
     },
+    { type: "section", label: "Beta tools" },
     {
-      key: "anthropicTextEditor",
-      label: "Anthropic Text Editor",
-      desc: "Anthropic's str_replace editor tool",
+      key: "codeExecution",
+      label: "Code execution",
+      desc: "Programmatic tool calling \u2014 batches reads in Python",
       type: "toggle"
     },
     {
-      key: "toolStreaming",
-      label: "Tool Streaming",
-      desc: "Stream tool call args incrementally (disable to debug)",
+      key: "computerUse",
+      label: "Computer use",
+      desc: "Keyboard / mouse / screenshot control",
       type: "toggle"
     },
     {
-      key: "sendReasoning",
-      label: "Send Reasoning",
-      desc: "Include reasoning content in multi-turn requests",
+      key: "anthropicTextEditor",
+      label: "Text editor",
+      desc: "Anthropic str_replace editor tool",
       type: "toggle"
     },
+    { type: "section", label: "Server context" },
     {
       key: "compact",
-      label: "Server Compaction",
-      desc: "Anthropic server-side context compaction (200K+ models)",
+      label: "Server compaction",
+      desc: "Anthropic server-side compaction (200K+ models)",
       type: "toggle"
     },
     {
       key: "clearToolUses",
-      label: "Clear Tool Uses",
-      desc: "Server-side \u2014 clear old tool results at 65% context. \u26A0\uFE0F Busts prompt cache when triggered",
+      label: "Clear old tool uses",
+      desc: "Drop old tool results at 65% ctx. Busts prompt cache when it fires",
       type: "toggle"
     }
   ];
   OPENAI_ITEMS = [
+    { type: "section", label: "Reasoning" },
     {
       key: "openaiReasoningEffort",
-      label: "Reasoning Effort",
-      desc: "For o3, o4, gpt-5 \u2014 controls reasoning depth",
+      label: "Effort",
+      desc: "o3 \xB7 o4 \xB7 gpt-5 \u2014 reasoning depth",
       type: "cycle",
       options: ["off", "none", "minimal", "low", "medium", "high", "xhigh"]
     },
+    {
+      key: "openaiReasoningSummary",
+      label: "Reasoning summary",
+      desc: "Include synthesized reasoning summary in the response",
+      type: "cycle",
+      options: ["off", "auto", "detailed"]
+    },
+    {
+      key: "openaiVerbosity",
+      label: "Verbosity",
+      desc: "gpt-5+ \u2014 controls answer length",
+      type: "cycle",
+      options: ["off", "low", "medium", "high"]
+    },
+    { type: "section", label: "Service" },
     {
       key: "serviceTier",
-      label: "Service Tier",
-      desc: "flex = 50% cheaper | priority = fastest (Enterprise)",
+      label: "Service tier",
+      desc: "flex = 50% cheaper \xB7 priority = fastest (Enterprise)",
       type: "cycle",
       options: ["off", "auto", "default", "flex", "priority"]
     }
   ];
   GENERAL_ITEMS = [
+    { type: "section", label: "Tools" },
     {
       key: "disableParallelToolUse",
-      label: "Sequential Tools",
-      desc: "One tool at a time instead of parallel (all providers)",
+      label: "Sequential tools",
+      desc: "Run tools one at a time instead of parallel (all providers)",
       type: "toggle"
     },
     {
       key: "webSearch",
-      label: "Web Search",
-      desc: "Allow web search tool",
+      label: "Web search",
+      desc: "Allow the web search tool",
       type: "toggle"
     },
+    { type: "section", label: "Context" },
     {
       key: "pruning",
-      label: "Tool Result Pruning",
-      desc: "Client-side \u2014 compact old tool results: main | subagents | both | none",
+      label: "Tool result pruning",
+      desc: "Client-side \u2014 compact old tool results",
       type: "cycle",
       options: ["none", "main", "subagents", "both"]
     }
   ];
+  GOOGLE_ITEMS = [
+    {
+      type: "info",
+      text: "Gemini 3 / 3.1 use thinkingLevel \xB7 Gemini 2.5 uses thinkingBudget. Only one applies per model."
+    },
+    { type: "section", label: "Gemini 3+" },
+    {
+      key: "googleThinkingLevel",
+      label: "Thinking level",
+      desc: "Gemini 3 / 3.1 \u2014 depth of internal reasoning",
+      type: "cycle",
+      options: ["off", "minimal", "low", "medium", "high"]
+    },
+    { type: "section", label: "Gemini 2.5" },
+    {
+      key: "googleThinkingBudget",
+      label: "Thinking budget",
+      desc: "Token budget for Gemini 2.5 thinking. 0 = disabled",
+      type: "cycle",
+      options: ["off", "0", "1024", "4096", "8192", "16384", "24576"]
+    },
+    { type: "section", label: "Output" },
+    {
+      key: "googleIncludeThoughts",
+      label: "Include thoughts",
+      desc: "Return thought summaries in the response",
+      type: "toggle"
+    }
+  ];
+  XAI_ITEMS = [
+    {
+      type: "info",
+      text: "Applies to: grok-3-mini \xB7 grok-4 \xB7 grok-4.1 \xB7 grok-4.20 \xB7 *-reasoning. Chat API clamps to low|high \u2014 medium auto-maps to high."
+    },
+    { type: "section", label: "Reasoning" },
+    {
+      key: "xaiReasoningEffort",
+      label: "Effort",
+      desc: "Chat: low/high \xB7 Responses API: low/medium/high",
+      type: "cycle",
+      options: ["off", "low", "medium", "high"]
+    }
+  ];
+  DEEPSEEK_ITEMS = [
+    {
+      type: "info",
+      text: "Applies to deepseek-chat only. deepseek-reasoner always thinks (no toggle)."
+    },
+    { type: "section", label: "Reasoning" },
+    {
+      key: "deepseekThinking",
+      label: "Thinking",
+      desc: "Enable chain-of-thought generation on deepseek-chat",
+      type: "cycle",
+      options: ["off", "enabled"]
+    }
+  ];
+  OPENROUTER_ITEMS = [
+    {
+      type: "info",
+      text: "Unified shape \u2014 OpenRouter maps to each upstream's native API (Anthropic budget, OpenAI effort, Gemini level). Inherits Claude budget by default."
+    },
+    { type: "section", label: "Unified reasoning" },
+    {
+      key: "openrouterReasoningEffort",
+      label: "Effort",
+      desc: "Mapped to upstream's native shape (Anthropic budget \xB7 OpenAI effort \xB7 Gemini level)",
+      type: "cycle",
+      options: ["off", "minimal", "low", "medium", "high", "xhigh", "none"]
+    },
+    {
+      key: "openrouterReasoningMaxTokens",
+      label: "Max tokens",
+      desc: "Anthropic-style budget. Takes priority over Effort when set.",
+      type: "cycle",
+      options: ["off", "1024", "2048", "4096", "8192", "16384"]
+    },
+    { type: "section", label: "Output" },
+    {
+      key: "openrouterExcludeReasoning",
+      label: "Hide reasoning",
+      desc: "Model still reasons but tokens are not returned",
+      type: "toggle"
+    }
+  ];
+  COMPAT_ITEMS = [
+    {
+      type: "info",
+      text: "Applies to: Groq \xB7 Fireworks \xB7 OpenCode Zen \xB7 OpenCode Go \xB7 LM Studio \xB7 Ollama \xB7 Copilot \xB7 GitHub Models \xB7 MiniMax \xB7 Proxy (non-Claude lane)"
+    },
+    { type: "section", label: "Shared effort" },
+    {
+      key: "compatReasoningEffort",
+      label: "Effort",
+      desc: "Single knob \u2014 propagates as reasoning_effort in the request body for every provider listed above.",
+      type: "cycle",
+      options: ["off", "low", "medium", "high", "xhigh"]
+    },
+    { type: "section", label: "Groq" },
+    {
+      type: "info",
+      text: "Groq-specific overrides. qwen3 / gpt-oss / deepseek-r1 reasoning SKUs."
+    },
+    {
+      key: "groqReasoningEffort",
+      label: "Groq override",
+      desc: "Takes priority over shared effort when set. qwen3 auto-maps to default.",
+      type: "cycle",
+      options: ["off", "low", "medium", "high"]
+    },
+    {
+      key: "groqReasoningFormat",
+      label: "Groq format",
+      desc: "How reasoning appears in the Groq response payload",
+      type: "cycle",
+      options: ["off", "parsed", "raw", "hidden"]
+    }
+  ];
   TAB_ITEMS = {
     claude: CLAUDE_ITEMS,
     openai: OPENAI_ITEMS,
+    google: GOOGLE_ITEMS,
+    xai: XAI_ITEMS,
+    deepseek: DEEPSEEK_ITEMS,
+    openrouter: OPENROUTER_ITEMS,
+    compat: COMPAT_ITEMS,
     general: GENERAL_ITEMS
   };
   DEFAULTS = {
@@ -519306,7 +520306,20 @@ var init_ProviderSettings = __esm(async () => {
     compact: false,
     clearToolUses: false,
     clearThinking: true,
-    pruning: "none"
+    pruning: "none",
+    googleThinkingLevel: "off",
+    googleThinkingBudget: "off",
+    googleIncludeThoughts: false,
+    xaiReasoningEffort: "off",
+    deepseekThinking: "off",
+    openrouterReasoningEffort: "off",
+    openrouterReasoningMaxTokens: "off",
+    openrouterExcludeReasoning: false,
+    compatReasoningEffort: "off",
+    groqReasoningEffort: "off",
+    openaiReasoningSummary: "off",
+    openaiVerbosity: "off",
+    groqReasoningFormat: "off"
   };
 });
 
@@ -519809,27 +520822,29 @@ function RouterSettings({
       for (const d3 of s2.defs) {
         if (d3.kind === "slot")
           out2.push({ kind: "slot", section: s2, def: d3 });
+        else
+          out2.push({ kind: "picker", section: s2, def: d3 });
       }
     }
     return out2;
   }, []);
-  const slotIndices = import_react140.useMemo(() => rows.map((r4, i4) => r4.kind === "slot" ? i4 : -1).filter((i4) => i4 >= 0), [rows]);
+  const selectableIndices = import_react140.useMemo(() => rows.map((r4, i4) => r4.kind === "slot" || r4.kind === "picker" ? i4 : -1).filter((i4) => i4 >= 0), [rows]);
   const moveItem = (dir) => {
-    if (slotIndices.length === 0)
+    if (selectableIndices.length === 0)
       return;
-    const cur = slotIndices.indexOf(cursor);
+    const cur = selectableIndices.indexOf(cursor);
     const base = cur < 0 ? 0 : cur;
-    const nextPos = (base + dir + slotIndices.length) % slotIndices.length;
-    setCursor(slotIndices[nextPos] ?? slotIndices[0] ?? 0);
+    const nextPos = (base + dir + selectableIndices.length) % selectableIndices.length;
+    setCursor(selectableIndices[nextPos] ?? selectableIndices[0] ?? 0);
   };
   import_react140.useMemo(() => {
-    if (cursor === 0 && slotIndices.length > 0 && slotIndices[0] !== 0) {
-      setCursor(slotIndices[0] ?? 0);
+    if (cursor === 0 && selectableIndices.length > 0 && selectableIndices[0] !== 0) {
+      setCursor(selectableIndices[0] ?? 0);
     }
-  }, [cursor, slotIndices]);
+  }, [cursor, selectableIndices]);
   const selectedRow = rows[cursor];
-  const selectedDef = selectedRow?.kind === "slot" ? selectedRow.def : null;
-  const pickerDefs = import_react140.useMemo(() => ALL_DEFS.filter((d3) => d3.kind === "picker"), []);
+  const selectedSlot = selectedRow?.kind === "slot" ? selectedRow.def : null;
+  const selectedPicker = selectedRow?.kind === "picker" ? selectedRow.def : null;
   useKeyboard((evt) => {
     if (!visible)
       return;
@@ -519846,16 +520861,28 @@ function RouterSettings({
       return;
     }
     if (evt.name === "return") {
-      if (selectedDef)
-        onPickSlot(selectedDef.key);
+      if (selectedSlot)
+        onPickSlot(selectedSlot.key);
       return;
     }
     if (evt.name === "d" || evt.name === "delete" || evt.name === "backspace") {
-      if (selectedDef)
-        onClearSlot(selectedDef.key);
+      if (selectedSlot)
+        onClearSlot(selectedSlot.key);
       return;
     }
     if (evt.name === "left" || evt.name === "right") {
+      if (selectedPicker) {
+        const cur = router2?.[selectedPicker.key];
+        const curVal = typeof cur === "number" ? cur : selectedPicker.defaultValue;
+        const opts = selectedPicker.options;
+        const i4 = opts.indexOf(curVal);
+        const base = i4 < 0 ? 0 : i4;
+        const nextIdx = evt.name === "left" ? (base - 1 + opts.length) % opts.length : (base + 1) % opts.length;
+        const next2 = opts[nextIdx];
+        if (typeof next2 === "number" && next2 !== curVal)
+          onPickerChange(selectedPicker.key, next2);
+        return;
+      }
       const sIdx = CONFIG_SCOPES.indexOf(scope);
       const next = evt.name === "left" ? CONFIG_SCOPES[(sIdx - 1 + CONFIG_SCOPES.length) % CONFIG_SCOPES.length] : CONFIG_SCOPES[(sIdx + 1) % CONFIG_SCOPES.length];
       if (next && next !== scope)
@@ -519886,7 +520913,7 @@ function RouterSettings({
       { key: "\u2191\u2193", label: "nav" },
       { key: "Enter", label: "set" },
       { key: "d", label: "reset" },
-      { key: "\u2190\u2192", label: "scope" },
+      { key: "\u2190\u2192", label: selectedPicker ? "adjust" : "scope" },
       { key: "Esc", label: "close" }
     ],
     children: /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(Section, {
@@ -519914,6 +520941,17 @@ function RouterSettings({
               }, `h-${idx}`, true, undefined, this);
             }
             const isSelected = idx === cursor;
+            if (row.kind === "picker") {
+              const cur = router2?.[row.def.key];
+              const num = typeof cur === "number" ? cur : row.def.defaultValue;
+              return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(SegmentedControl, {
+                label: row.def.label,
+                labelWidth: labelCol,
+                options: row.def.options.map((o3) => ({ value: o3, label: String(o3) })),
+                value: num,
+                focused: isSelected
+              }, `p-${idx}`, false, undefined, this);
+            }
             const rowBg = isSelected ? t2.bgPopupHighlight : t2.bgPopup;
             const raw2 = router2?.[row.def.key] ?? null;
             const modelId = typeof raw2 === "string" ? raw2 : null;
@@ -519965,17 +521003,6 @@ function RouterSettings({
           })
         }, undefined, false, undefined, this),
         /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(VSpacer, {}, undefined, false, undefined, this),
-        pickerDefs.map((def) => {
-          const cur = router2?.[def.key];
-          const num = typeof cur === "number" ? cur : def.defaultValue;
-          return /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(SegmentedControl, {
-            label: def.label,
-            labelWidth: 14,
-            options: def.options.map((o3) => ({ value: o3, label: String(o3) })),
-            value: num
-          }, def.key, false, undefined, this);
-        }),
-        /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(VSpacer, {}, undefined, false, undefined, this),
         /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(SegmentedControl, {
           label: "Scope",
           labelWidth: 14,