9router 0.5.95 → 0.5.99

package/src/cli/commands/connectTools.js

@@ -4,6 +4,8 @@
  * tool configured here looks identical to one applied from the dashboard.
  *
  * Each tool: { id, name, paths(), apply(ctx) → string[] written, reset() → string[] touched }
+ * Optional: route + serverModel(data) to inherit the server's model; needsModel: false
+ * for tools that discover models themselves (omp).
  * ctx: { baseUrl (origin, no /v1), apiKey, model, claudeModels: { envKey: model } }
  */
 
@@ -13,6 +15,7 @@ const os = require("os");
 
 const home = () => os.homedir();
 const v1 = (baseUrl) => (baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`);
+const isStr = (v) => typeof v === "string" && v.length > 0;
 
 // Drop trailing commas (JSONC) outside string literals, so values like "a,}" survive.
 function stripTrailingCommas(text) {
@@ -50,17 +53,17 @@ function writeFile(file, content) {
 
 const writeJson = (file, data) => writeFile(file, JSON.stringify(data, null, 2));
 
-// confbox is ESM-only; loaded lazily so non-codex runs don't need it.
+// confbox (TOML/YAML) is ESM-only; loaded lazily so other tools don't need it.
 async function toml() {
   return import("confbox");
 }
 
 // ── Claude Code ─────────────────────────────────────────────────────────────
 const CLAUDE_MODELS = [
-  { flag: "fable", envKey: "ANTHROPIC_DEFAULT_FABLE_MODEL", defaultValue: "cc/claude-fable-5" },
-  { flag: "opus", envKey: "ANTHROPIC_DEFAULT_OPUS_MODEL", defaultValue: "cc/claude-opus-5" },
-  { flag: "sonnet", envKey: "ANTHROPIC_DEFAULT_SONNET_MODEL", defaultValue: "cc/claude-sonnet-5" },
-  { flag: "haiku", envKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL", defaultValue: "cc/claude-haiku-4-5-20251001" },
+  { flag: "fable", envKey: "ANTHROPIC_DEFAULT_FABLE_MODEL" },
+  { flag: "opus", envKey: "ANTHROPIC_DEFAULT_OPUS_MODEL" },
+  { flag: "sonnet", envKey: "ANTHROPIC_DEFAULT_SONNET_MODEL" },
+  { flag: "haiku", envKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL" },
 ];
 const CLAUDE_RESET_KEYS = ["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN", ...CLAUDE_MODELS.map((m) => m.envKey)];
 const claudePath = () => path.join(home(), ".claude", "settings.json");
@@ -73,10 +76,23 @@ const claude = {
     const file = claudePath();
     const cur = readJson(file) || {};
     cur.hasCompletedOnboarding = true;
-    cur.env = { ...(cur.env || {}), ANTHROPIC_BASE_URL: v1(baseUrl), ANTHROPIC_AUTH_TOKEN: apiKey, ...claudeModels };
+    cur.env = { ...(cur.env || {}), ANTHROPIC_BASE_URL: v1(baseUrl), ANTHROPIC_AUTH_TOKEN: apiKey };
+    // A tier with no model (null) is removed so Claude Code uses its own default
+    // instead of a stale value from an earlier run.
+    for (const m of CLAUDE_MODELS) {
+      if (claudeModels[m.envKey]) cur.env[m.envKey] = claudeModels[m.envKey];
+      else delete cur.env[m.envKey];
+    }
     writeJson(file, cur);
     return [file];
   },
+  async show() {
+    const env = readJson(claudePath())?.env || {};
+    const models = {};
+    if (isStr(env.ANTHROPIC_MODEL)) models.main = env.ANTHROPIC_MODEL;
+    for (const m of CLAUDE_MODELS) if (isStr(env[m.envKey])) models[m.flag] = env[m.envKey];
+    return { baseUrl: env.ANTHROPIC_BASE_URL, apiKey: env.ANTHROPIC_AUTH_TOKEN, models };
+  },
   async reset() {
     const file = claudePath();
     const cur = readJson(file);
@@ -97,6 +113,14 @@ const codex = {
   id: "codex",
   name: "OpenAI Codex CLI",
   paths: () => [codexPath()],
+  route: "codex-settings",
+  // GET returns raw TOML text; only trust `model` when the provider is 9router.
+  async serverModel(data) {
+    if (!isStr(data?.config)) return null;
+    const { parseTOML } = await toml();
+    const cfg = parseTOML(data.config) || {};
+    return cfg.model_provider === "9router" && isStr(cfg.model) ? cfg.model : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const { parseTOML, stringifyTOML } = await toml();
     const file = codexPath();
@@ -118,6 +142,28 @@ const codex = {
     writeFile(file, stringifyTOML(cfg));
     return [file];
   },
+  async show() {
+    let cfg;
+    try {
+      const { parseTOML } = await toml();
+      cfg = parseTOML(fs.readFileSync(codexPath(), "utf8")) || {};
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw new Error(`Cannot parse ${codexPath()}: ${err.message}`);
+    }
+    const p = cfg.model_providers?.["9router"];
+    const auth = p?.http_headers?.Authorization;
+    return {
+      baseUrl: p?.base_url,
+      apiKey: isStr(auth) ? auth.replace(/^Bearer\s+/i, "") : undefined,
+      models: {
+        ...(isStr(cfg.model) ? { main: cfg.model } : {}),
+        ...(isStr(cfg.agents?.default_subagent_model) ? { subagent: cfg.agents.default_subagent_model } : {}),
+      },
+      // Codex only routes through 9router when this provider is the active one.
+      active: cfg.model_provider === "9router",
+    };
+  },
   async reset() {
     const { parseTOML, stringifyTOML } = await toml();
     const file = codexPath();
@@ -141,6 +187,11 @@ const opencode = {
   id: "opencode",
   name: "OpenCode",
   paths: () => [opencodePath()],
+  route: "opencode-settings",
+  serverModel(data) {
+    const m = data?.config?.model;
+    return isStr(m) && m.startsWith("9router/") ? m.slice("9router/".length) : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const file = opencodePath();
     const cfg = readJson(file) || {};
@@ -160,6 +211,16 @@ const opencode = {
     writeJson(file, cfg);
     return [file];
   },
+  async show() {
+    const cfg = readJson(opencodePath()) || {};
+    const p = cfg.provider?.["9router"];
+    const models = {};
+    if (isStr(cfg.model)) models.main = cfg.model;
+    if (isStr(cfg.agent?.explorer?.model)) models.explorer = cfg.agent.explorer.model;
+    const listed = Object.keys(p?.models || {});
+    if (listed.length) models.available = listed.join(", ");
+    return { baseUrl: p?.options?.baseURL, apiKey: p?.options?.apiKey, models, active: !!cfg.model?.startsWith("9router/") };
+  },
   async reset() {
     const file = opencodePath();
     const cfg = readJson(file);
@@ -183,6 +244,11 @@ const droid = {
   id: "droid",
   name: "Factory Droid",
   paths: () => [droidPath()],
+  route: "droid-settings",
+  serverModel(data) {
+    const m = (data?.settings?.customModels || []).find(isDroid9r)?.model;
+    return isStr(m) ? m : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const file = droidPath();
     const cfg = readJson(file) || {};
@@ -205,6 +271,14 @@ const droid = {
     writeJson(file, cfg);
     return [file];
   },
+  async show() {
+    const ours = (readJson(droidPath())?.customModels || []).filter(isDroid9r);
+    return {
+      baseUrl: ours[0]?.baseUrl,
+      apiKey: ours[0]?.apiKey,
+      models: ours.length ? { main: ours[0].model, ...(ours.length > 1 ? { available: ours.map((m) => m.model).join(", ") } : {}) } : {},
+    };
+  },
   async reset() {
     const file = droidPath();
     const cfg = readJson(file);
@@ -225,6 +299,11 @@ const crush = {
   id: "crush",
   name: "Crush",
   paths: () => [crushPath()],
+  route: "crush-settings",
+  serverModel(data) {
+    const m = data?.config?.providers?.["9router"]?.models?.[0]?.id;
+    return isStr(m) ? m : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const file = crushPath();
     const cfg = readJson(file) || {};
@@ -238,6 +317,11 @@ const crush = {
     writeJson(file, cfg);
     return [file];
   },
+  async show() {
+    const p = readJson(crushPath())?.providers?.["9router"];
+    const ids = (p?.models || []).map((m) => m.id).filter(isStr);
+    return { baseUrl: p?.base_url, apiKey: p?.api_key, models: ids.length ? { main: ids[0] } : {} };
+  },
   async reset() {
     const file = crushPath();
     const cfg = readJson(file);
@@ -256,6 +340,8 @@ const kilo = {
   id: "kilo",
   name: "Kilo Code CLI",
   paths: () => [kiloPath()],
+  // No route: the dashboard GET exposes only auth key names, not the model,
+  // so kilo falls back to the shared model.
   async apply({ baseUrl, apiKey, model }) {
     const file = kiloPath();
     const auth = readJson(file) || {};
@@ -263,6 +349,10 @@ const kilo = {
     writeJson(file, auth);
     return [file];
   },
+  async show() {
+    const a = readJson(kiloPath())?.["openai-compatible"];
+    return { baseUrl: a?.baseUrl, apiKey: a?.apiKey, models: isStr(a?.model) ? { main: a.model } : {} };
+  },
   async reset() {
     const file = kiloPath();
     const auth = readJson(file);
@@ -283,6 +373,11 @@ const cline = {
   id: "cline",
   name: "Cline CLI",
   paths: () => [clineState(), clineSecrets()],
+  route: "cline-settings",
+  serverModel(data) {
+    const st = data?.settings;
+    return st?.actModeApiProvider === "openai" && isStr(st.openAiModelId) ? st.openAiModelId : null;
+  },
   async apply({ baseUrl, apiKey, model }) {
     const state = readJson(clineState()) || {};
     state.actModeApiProvider = "openai";
@@ -296,6 +391,18 @@ const cline = {
     writeJson(clineSecrets(), secrets);
     return [clineState(), clineSecrets()];
   },
+  async show() {
+    const st = readJson(clineState()) || {};
+    const models = {};
+    if (isStr(st.openAiModelId)) models.act = st.openAiModelId;
+    if (isStr(st.planModeOpenAiModelId)) models.plan = st.planModeOpenAiModelId;
+    return {
+      baseUrl: st.openAiBaseUrl,
+      apiKey: readJson(clineSecrets())?.openAiApiKey,
+      models,
+      active: st.actModeApiProvider === "openai",
+    };
+  },
   async reset() {
     const state = readJson(clineState());
     if (!state) return [];
@@ -318,9 +425,122 @@ const cline = {
   },
 };
 
-const TOOLS = [claude, codex, opencode, droid, crush, kilo, cline];
+// ── Pi (pi-coding-agent) ────────────────────────────────────────────────────
+// Prefers ~/.pi/agent/models.json; an existing legacy ~/.pi/models.json is used instead.
+const piPath = () => {
+  const agent = path.join(home(), ".pi", "agent", "models.json");
+  const root = path.join(home(), ".pi", "models.json");
+  return !fs.existsSync(agent) && fs.existsSync(root) ? root : agent;
+};
+
+const pi = {
+  id: "pi",
+  name: "Pi",
+  paths: () => [piPath()],
+  route: "pi-settings",
+  serverModel(data) {
+    const m = data?.config?.providers?.["9router"]?.models?.[0];
+    const id = typeof m === "string" ? m : m?.id;
+    return isStr(id) ? id : null;
+  },
+  async apply({ baseUrl, apiKey, model }) {
+    const file = piPath();
+    const cfg = readJson(file) || {};
+    cfg.providers = cfg.providers || {};
+    cfg.providers["9router"] = {
+      ...(cfg.providers["9router"] || {}),
+      baseUrl: v1(baseUrl),
+      apiKey,
+      api: "openai-completions",
+      models: [{ id: model, name: model, contextWindow: 128000, maxTokens: 16384 }],
+    };
+    writeJson(file, cfg);
+    return [file];
+  },
+  async show() {
+    const p = readJson(piPath())?.providers?.["9router"];
+    const ids = (p?.models || []).map((m) => (typeof m === "string" ? m : m?.id)).filter(isStr);
+    return {
+      baseUrl: p?.baseUrl,
+      apiKey: p?.apiKey,
+      models: ids.length ? { main: ids[0], ...(ids.length > 1 ? { available: ids.join(", ") } : {}) } : {},
+    };
+  },
+  async reset() {
+    const file = piPath();
+    const cfg = readJson(file);
+    if (!cfg?.providers?.["9router"]) return [];
+    delete cfg.providers["9router"];
+    if (Object.keys(cfg.providers).length === 0) delete cfg.providers;
+    rewriteFile(file, JSON.stringify(cfg, null, 2));
+    return [file];
+  },
+};
+
+// ── Oh My Pi ────────────────────────────────────────────────────────────────
+// Proxy discovery lists every server model under /model, so no model is written.
+// The dashboard also mirrors the key into agent.db; models.yml is the primary
+// source, so that best-effort sqlite write is skipped here.
+const ompPath = () => path.join(home(), ".omp", "agent", "models.yml");
+
+async function readYaml(file) {
+  let text;
+  try { text = fs.readFileSync(file, "utf8"); } catch (err) { if (err.code === "ENOENT") return null; throw err; }
+  try {
+    const { parseYAML } = await toml();
+    return parseYAML(text) || {};
+  } catch (err) {
+    throw new Error(`Cannot parse ${file}: ${err.message}`);
+  }
+}
+
+const omp = {
+  id: "omp",
+  name: "Oh My Pi",
+  paths: () => [ompPath()],
+  needsModel: false,
+  async apply({ baseUrl, apiKey }) {
+    const { stringifyYAML } = await toml();
+    const file = ompPath();
+    const cfg = (await readYaml(file)) || {};
+    cfg.providers = cfg.providers || {};
+    cfg.providers["9router"] = {
+      baseUrl: v1(baseUrl),
+      apiKey,
+      api: "openai-completions",
+      authHeader: true,
+      disableStrictTools: true,
+      discovery: { type: "proxy" },
+    };
+    writeFile(file, stringifyYAML(cfg));
+    return [file];
+  },
+  async show() {
+    const p = (await readYaml(ompPath()))?.providers?.["9router"];
+    return {
+      baseUrl: p?.baseUrl,
+      apiKey: p?.apiKey,
+      models: p?.discovery?.type === "proxy" ? { main: "(all server models, via discovery)" } : {},
+    };
+  },
+  async reset() {
+    const { stringifyYAML } = await toml();
+    const file = ompPath();
+    const cfg = await readYaml(file);
+    if (!cfg?.providers?.["9router"]) return [];
+    delete cfg.providers["9router"];
+    if (Object.keys(cfg.providers).length === 0) delete cfg.providers;
+    rewriteFile(file, Object.keys(cfg).length ? stringifyYAML(cfg) : "");
+    return [file];
+  },
+};
+
+const TOOLS = [claude, codex, opencode, droid, crush, kilo, cline, pi, omp];
 const TOOL_IDS = TOOLS.map((t) => t.id);
-const TOOL_ALIASES = { "claude-code": "claude", "claudecode": "claude", "factory": "droid", "kilocode": "kilo" };
+const TOOL_ALIASES = {
+  "claude-code": "claude", "claudecode": "claude", "factory": "droid", "kilocode": "kilo",
+  "pi-coding-agent": "pi", "oh-my-pi": "omp",
+};
 
 function resolveTools(list) {
   const ids = new Set();

package/src/cli/commands/show.js

@@ -0,0 +1,101 @@
+/**
+ * `9router show [tools…]` — print the 9router settings currently written in
+ * each CLI tool's LOCAL config: base URL, (masked) API key and models.
+ *
+ * Read-only and offline: never contacts a server and never prints a full key.
+ */
+
+const { TOOLS, TOOL_IDS, resolveTools } = require("./connectTools");
+const { __test__: { maskKey } } = require("./connect");
+
+const HELP = `
+Usage: 9router show [tool…] [options]
+
+Show the 9router settings each CLI tool on THIS machine is currently using.
+Read-only: reads local config files, contacts no server.
+
+  9router show                 # every supported tool
+  9router show claude          # one tool
+  9router show claude codex    # several (or: --tools claude,codex)
+
+Tools: ${TOOL_IDS.join(", ")}, all
+
+Options:
+  --tools <list>   Comma-separated tools (same as positional names)
+  --json           Machine-readable output (API key still masked)
+  -h, --help       Show this help
+`;
+
+function parseArgs(argv) {
+  const opts = { tools: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--tools") {
+      const v = argv[++i];
+      if (v === undefined) throw new Error("Missing value for --tools");
+      opts.tools.push(...v.split(","));
+    } else if (a === "--json") opts.json = true;
+    else if (a === "-h" || a === "--help") opts.help = true;
+    else if (!a.startsWith("-")) opts.tools.push(a);
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  return opts;
+}
+
+// Normalise one tool's show() output into a printable, key-safe record.
+async function inspect(tool) {
+  const record = { id: tool.id, name: tool.name, files: tool.paths() };
+  try {
+    const s = await tool.show();
+    record.configured = !!(s.baseUrl || s.apiKey || Object.keys(s.models || {}).length);
+    record.baseUrl = s.baseUrl || null;
+    record.apiKey = s.apiKey ? maskKey(s.apiKey) : null;
+    record.models = s.models || {};
+    // `active` is only reported by tools where 9router can be present but not selected.
+    if (typeof s.active === "boolean") record.active = s.active;
+  } catch (err) {
+    record.error = err.message;
+  }
+  return record;
+}
+
+function printRecord(r) {
+  if (r.error) {
+    console.log(`❌ ${r.name}: ${r.error}`);
+    return;
+  }
+  if (!r.configured) {
+    console.log(`• ${r.name}: not configured for 9router (${r.files[0]})`);
+    return;
+  }
+  const inactive = r.active === false ? "  \x1b[33m(9router present but not the active provider)\x1b[0m" : "";
+  console.log(`✅ ${r.name}${inactive}`);
+  console.log(`   File:     ${r.files.join(", ")}`);
+  console.log(`   Base URL: ${r.baseUrl || "(none)"}`);
+  console.log(`   API key:  ${r.apiKey || "(none)"}`);
+  const entries = Object.entries(r.models);
+  if (!entries.length) console.log("   Models:   (none set — the tool's own default applies)");
+  else {
+    const width = Math.max(...entries.map(([k]) => k.length));
+    console.log("   Models:");
+    for (const [k, v] of entries) console.log(`     ${k.padEnd(width)}  ${v}`);
+  }
+}
+
+async function run(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help) {
+    console.log(HELP);
+    return 0;
+  }
+  const tools = opts.tools.length ? resolveTools(opts.tools) : TOOLS;
+  const records = [];
+  for (const t of tools) records.push(await inspect(t));
+
+  if (opts.json) console.log(JSON.stringify(records, null, 2));
+  else records.forEach((r, i) => { if (i) console.log(""); printRecord(r); });
+
+  return records.some((r) => r.error) ? 1 : 0;
+}
+
+module.exports = { run, __test__: { parseArgs, inspect } };

package/src/cli/menus/cliTools.js

@@ -1,5 +1,5 @@
 const api = require("../api/client");
-const { pause, confirm } = require("../utils/input");
+const { pause, confirm, select } = require("../utils/input");
 const { showStatus } = require("../utils/display");
 const { selectModelFromList } = require("../utils/modelSelector");
 const { showMenuWithBack } = require("../utils/menuHelper");
@@ -515,27 +515,71 @@ async function showOpenCodeMenu(port, breadcrumb = []) {
 
 // ─── Hermes Agent ─────────────────────────────────────────────────────────────
 
-async function buildHermesHeader() {
-  const result = await api.getCliToolSettings("hermes");
+// Profile targeted by Quick Setup / Reset. The menu rebuilds through `refresh()` on every
+// loop, so the pick has to live outside the render — module state, like the menu itself.
+let hermesActiveProfile = "default";
+
+async function fetchHermesProfiles() {
+  const result = await api.listHermesProfiles();
+  if (!result.success) return [];
+  return result.data.profiles || [];
+}
+
+const hermesProfileLine = (p) => {
+  const name = p.displayName && !p.isDefault ? `${p.name} (${p.displayName})` : p.name;
+  const state = p.has9Router
+    ? `${COLORS.green}✓ 9router${COLORS.reset}`
+    : p.baseUrl
+      ? `${COLORS.red}other: ${p.baseUrl}${COLORS.reset}`
+      : `${COLORS.red}✗ not configured${COLORS.reset}`;
+  const model = p.model ? ` ${COLORS.dim}· ${p.model}${COLORS.reset}` : "";
+  return `${name} — ${state}${model}`;
+};
+
+async function buildHermesHeader(profiles) {
+  const list = profiles || (await fetchHermesProfiles());
+  const result = await api.getCliToolSettings("hermes", hermesActiveProfile);
   if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
 
-  const { installed, has9Router, settings } = result.data;
+  const { installed, has9Router, settings, profile } = result.data;
   if (!installed) return `Status:   ${COLORS.red}✗ Hermes Agent not installed${COLORS.reset}`;
 
-  if (!has9Router) {
-    return [
-      `Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`,
-      `${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`
-    ].join("\n");
+  const name = profile?.name || hermesActiveProfile;
+  const lines = [];
+  if (has9Router) {
+    lines.push(`Status:   ${COLORS.green}✓ Configured${COLORS.reset} (${name})`);
+  } else {
+    lines.push(`Status:   ${COLORS.red}✗ Not configured${COLORS.reset} (${name})`);
+    lines.push(`${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`);
   }
 
   const model = settings?.model || {};
-  const lines = [`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`];
   if (model.base_url) lines.push(`Endpoint: ${COLORS.cyan}${model.base_url}${COLORS.reset}`);
   if (model.default)  lines.push(`Model:    ${COLORS.dim}${model.default}${COLORS.reset}`);
+
+  if (list.length > 1) {
+    const summary = list
+      .map((p) => `${p.name}${p.has9Router ? `${COLORS.green}✓` : `${COLORS.red}✗`}`)
+      .join(`${COLORS.reset} `);
+    lines.push(`Profiles:  ${summary}${COLORS.reset}`);
+  }
   return lines.join("\n");
 }
 
+async function selectHermesProfile() {
+  const profiles = await fetchHermesProfiles();
+  if (profiles.length === 0) {
+    showStatus("No Hermes profiles found.", "error");
+    await pause();
+    return;
+  }
+
+  const index = await select("Select Hermes profile:", profiles.map(hermesProfileLine));
+  hermesActiveProfile = profiles[index].name;
+  showStatus(`Active profile: "${hermesActiveProfile}"`, "success");
+  await pause();
+}
+
 async function hermesQuickSetup(port) {
   const { endpoint } = await getEndpoint(port);
   const apiKey = await getFirstApiKey();
@@ -546,17 +590,63 @@ async function hermesQuickSetup(port) {
     return;
   }
 
-  const model = await selectModelFromList("Select Hermes Model", "", { excludeCombos: true });
+  const model = await selectModelFromList(`Select Hermes Model (${hermesActiveProfile})`, "", { excludeCombos: true });
   if (!model) return;
 
-  const result = await api.applyCliToolSettings("hermes", { baseUrl: endpoint, apiKey, model });
-  showStatus(result.success ? "Hermes setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  const result = await api.applyCliToolSettings("hermes", {
+    profile: hermesActiveProfile,
+    baseUrl: endpoint,
+    apiKey,
+    model,
+  });
+  showStatus(
+    result.success ? `Hermes setup completed for profile "${hermesActiveProfile}"!` : `Failed: ${result.error}`,
+    result.success ? "success" : "error"
+  );
+  await pause();
+}
+
+// Endpoint + API key across every profile. Each profile keeps its own model — profiles
+// already routed through 9router are refreshed, anything else is reported as skipped.
+async function hermesApplyAll(port) {
+  const { endpoint } = await getEndpoint(port);
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
+    await pause();
+    return;
+  }
+
+  const model = await selectModelFromList("Select Model (used only for profiles with no model yet)", "", { excludeCombos: true });
+  if (!model) return;
+
+  const result = await api.applyCliToolSettings("hermes", { applyToAll: true, baseUrl: endpoint, apiKey, model });
+  if (!result.success) {
+    showStatus(`Failed: ${result.error}`, "error");
+    await pause();
+    return;
+  }
+
+  const skipped = (result.data.results || []).filter((r) => r.status !== "updated");
+  if (skipped.length === 0) {
+    showStatus(`Endpoint applied to ${result.data.updated} profile(s).`, "success");
+  } else {
+    const detail = skipped.map((r) => `  ${r.profile}: ${r.reason || r.status}`).join("\n");
+    showStatus(
+      `Updated ${result.data.updated} profile(s), skipped ${skipped.length}:\n${detail}`,
+      result.data.updated > 0 ? "success" : "error"
+    );
+  }
   await pause();
 }
 
 async function hermesReset() {
-  const result = await api.resetCliToolSettings("hermes");
-  showStatus(result.success ? "Hermes settings reset!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  const result = await api.resetCliToolSettings("hermes", hermesActiveProfile);
+  showStatus(
+    result.success ? `Hermes settings reset for profile "${hermesActiveProfile}"!` : `Failed: ${result.error}`,
+    result.success ? "success" : "error"
+  );
   await pause();
 }
 
@@ -564,11 +654,20 @@ async function showHermesMenu(port, breadcrumb = []) {
   await showMenuWithBack({
     title: "⚡ Hermes Agent Settings",
     breadcrumb,
+    refresh: async () => {
+      const profiles = await fetchHermesProfiles();
+      // Drop a stale selection (profile deleted in another tab) back to default.
+      if (profiles.length > 0 && !profiles.some((p) => p.name === hermesActiveProfile)) {
+        hermesActiveProfile = "default";
+      }
+      return profiles;
+    },
     headerContent: buildHermesHeader,
-    refresh: async () => ({}),
     items: [
+      { label: () => `🎯 Profile: ${hermesActiveProfile}`, action: async () => { await selectHermesProfile(); return true; } },
       { label: "⚡ Quick Setup", action: async () => { await hermesQuickSetup(port); return true; } },
-      { label: "Reset to Default", action: async () => { await hermesReset(); return true; } }
+      { label: "🔁 Apply to All Profiles", action: async () => { await hermesApplyAll(port); return true; } },
+      { label: () => `↺ Reset Profile: ${hermesActiveProfile}`, action: async () => { await hermesReset(); return true; } }
     ]
   });
 }

package/src/cli/menus/combos.js

@@ -4,6 +4,7 @@ const { clearScreen, showStatus, showHeader } = require("../utils/display");
 const { formatDate } = require("../utils/format");
 const { selectModelFromList } = require("../utils/modelSelector");
 const { showMenuWithBack } = require("../utils/menuHelper");
+const { comboModelId } = require("../utils/comboModelId");
 
 /**
  * Format model to string (handle both string and object)
@@ -253,7 +254,7 @@ async function handleCreateCombo() {
     
     if (selectedModels.length > 0) {
       selectedModels.forEach((m, i) => {
-        console.log(`  ${i + 1}. ${m.provider}/${m.model}`);
+        console.log(`  ${i + 1}. ${m}`);
       });
     } else {
       console.log("  (none)");
@@ -295,7 +296,13 @@ async function handleCreateCombo() {
       continue;
     }
     
-    selectedModels.push(availableModels[num - 1]);
+    const modelId = comboModelId(availableModels[num - 1]);
+    if (!modelId) {
+      showStatus("Selected model has no valid identifier", "error");
+      await pause();
+      continue;
+    }
+    selectedModels.push(modelId);
   }
   
   // Create combo

package/src/cli/menus/providers.js

@@ -67,6 +67,14 @@ const PROVIDER_MODELS = {
     { id: "gemini-3.5-flash-extra-low" },
     { id: "gemini-pro-agent" },
     { id: "gemini-3.1-pro-low" },
+    { id: "claude-sonnet-5-5" },
+    { id: "claude-sonnet-5-5-low" },
+    { id: "claude-sonnet-5-5-medium" },
+    { id: "claude-sonnet-5-5-high" },
+    { id: "claude-opus-5-5" },
+    { id: "claude-opus-5-5-low" },
+    { id: "claude-opus-5-5-medium" },
+    { id: "claude-opus-5-5-high" },
     { id: "claude-sonnet-4-6" },
     { id: "claude-opus-4-6-thinking" },
     { id: "gpt-oss-120b-medium" },