pleumrouter 0.5.36 → 0.5.37

package/README.md

@@ -17,7 +17,7 @@ bun install -g pleumrouter                          # bun
 ## 빠른 시작
 
 ```bash
-pleum                     # Claude Code · Codex · Antigravity · opencode 바로 선택
+pleum                     # 에이전트 실행 → Claude Code · Codex · Antigravity · OpenCode
 pleum claude              # Claude Code 바로 실행
 pleum codex               # Codex 바로 실행
 pleum agy                 # Antigravity CLI 바로 실행
@@ -33,8 +33,8 @@ SSH/CI에서는 `pleum login --device`를 쓰세요.
 
 | 명령 | 설명 |
 |------|------|
-| `pleum` | (인자 없음, TTY) 첫 화면에서 Claude Code·Codex·Antigravity·opencode를 바로 실행. ↑/↓ 이동 · enter 실행 · → 모델 설정 · esc 종료. 나머지 에이전트는 "에이전트 실행" 메뉴. 파이프에선 도움말 출력 |
-| `pleum claude\|codex\|agy\|opencode [--model id]` | 네 우선 지원 도구를 한 명령으로 실행. 최초 실행은 브라우저 로그인 후 에이전트 키 발급 |
+| `pleum` | (인자 없음, TTY) 에이전트 실행 → Claude Code·Codex·Antigravity·OpenCode. 앞의 세 도구는 공식/기본 모델 또는 custom(beta)을 선택. 파이프에선 도움말 출력 |
+| `pleum claude\|codex\|agy\|opencode [--model id]` | 네 우선 지원 도구를 한 명령으로 실행. Claude·Codex·agy는 모델 미지정 시 공식/기본 모드, `--model` 지정 시 custom 모드. 최초 실행은 브라우저 로그인 후 에이전트 키 발급 |
 | `pleum login [--device]` | 브라우저 OAuth 로그인 → access/refresh 토큰을 `~/.pleum/config.json`에 저장(API 키 미발급). `--device`는 SSH·CI |
 | `pleum logout` | 서버 세션 revoke + 로컬 토큰 삭제(언어·기본 모델 등 나머지 설정은 유지) |
 | `pleum launch [tool] [--model id] [-- args]` | 에이전트 실행. `--` 뒤 인자는 도구로 그대로 전달. 도구 생략 시 지원 목록·설치 여부 표시 |
@@ -81,7 +81,9 @@ SSH/CI에서는 `pleum login --device`를 쓰세요.
 env·실행 인자 또는 일부 도구의 격리 홈(`PI_CODING_AGENT_DIR` / `CRUSH_GLOBAL_CONFIG`)으로 연결한다. Codex는 `-c` 임시 설정을 써서 기존 `~/.codex`의 세션과 설정을 유지한다.
 별칭: `antigravity`→`agy`, `picode`→`pi`, `ohmypi`/`oh-my-pi`→`omp`, `qwencode`/`qwen-code`→`qwen`, `minimax-code`/`mcode`→`minimax`, `mimocode`/`mimo-code`→`mimo`, `open-interpreter`→`interpreter`.
 
-`agy`만 사용자 `~/.gemini/antigravity-cli/settings.json`에 `modelProvider=gemini`를 병합한다(제품이 이 파일 없이 키를 무시함). Kiro는 공식 BYOK가 없어 지원하지 않는다.
+공식/기본 모드에서도 요청은 PleumRouter를 거쳐 Pleum API 크레딧으로 정산된다. Claude custom은 주 대화 모델만 바꾸며 일반 서브에이전트는 Pleum의 Sonnet으로 실행한다(Claude의 fork·`model: inherit` skill은 주 대화 모델을 상속할 수 있다). OpenCode 실행 세션의 `/models`에는 활성 Pleum 텍스트 대화 모델만 표시하며 추천 10개를 즐겨찾기 상단에 둔다. 기존 즐겨찾기와 최근 기록은 보존한다.
+
+`agy`만 사용자 `~/.gemini/antigravity-cli/settings.json`에 `modelProvider=gemini`를 임시 병합하고 종료 시 복구한다(제품이 이 파일 없이 키를 무시함). agy custom은 설치 버전의 모델 목록과 실제 요청 ID가 확인된 Gemini 모델만 실행한다. Kiro는 공식 BYOK가 없어 지원하지 않는다.
 
 ## 환경변수
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pleumrouter",
-  "version": "0.5.36",
+  "version": "0.5.37",
   "description": "Official PleumRouter terminal CLI — launch any coding agent against PleumRouter.",
   "type": "module",
   "bin": {

package/src/launch.mjs

@@ -1,12 +1,13 @@
-import { spawn } from "node:child_process";
-import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
-import { homedir } from "node:os";
+import { spawn, execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync, mkdtempSync, renameSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import { join, delimiter, dirname, resolve } from "node:path";
-import { readConfig, isLoggedIn, getActiveContext } from "./config.mjs";
+import { readConfig, isLoggedIn, getActiveContext, ROOT } from "./config.mjs";
 import { login } from "./login.mjs";
 import { ensureWireKey } from "./wire.mjs";
 import {
   RECIPES,
+  CORE_MODELS,
   MANUAL,
   LAUNCH_ALIASES,
   resolveLaunchTool,
@@ -17,6 +18,7 @@ import {
 } from "./recipes.mjs";
 import { t } from "./i18n.mjs";
 import { sanitizeTerminalText } from "./ansi.mjs";
+import { fetchModels, codingModels } from "./models.mjs";
 
 // PATH에서 실행 파일을 찾는다(설치 여부 표시용). menu.mjs도 사용.
 export function onPath(bin) {
@@ -102,6 +104,79 @@ export function resolveLaunchModel(tool, explicit, cfg = readConfig()) {
   return explicit || cfg?.launch_models?.[tool] || recipe?.defaultModel;
 }
 
+// agy의 Google API-key 모드는 계정 모드보다 모델이 적다. 임시 HOME으로 실제
+// 설치 버전의 목록을 읽어, 선택 모델이 다른 Gemini 모델로 조용히 바뀌는 일을 막는다.
+export function listAgyModelIds({ run = execFileSync } = {}) {
+  const home = mkdtempSync(join(tmpdir(), "pleum-agy-models-"));
+  try {
+    const settingsDir = join(home, ".gemini", "antigravity-cli");
+    mkdirSync(settingsDir, { recursive: true, mode: 0o700 });
+    writeFileSync(join(settingsDir, "settings.json"), '{"modelProvider":"gemini"}', { mode: 0o600 });
+    const output = run("agy", ["models"], {
+      encoding: "utf8",
+      timeout: 15000,
+      env: {
+        ...process.env,
+        HOME: home,
+        USERPROFILE: home,
+        GEMINI_API_KEY: "pleum-model-list-probe",
+        GOOGLE_GEMINI_BASE_URL: ROOT,
+      },
+    });
+    return new Set(String(output).split(/\r?\n/).map((line) => line.split(/\s/)[0]).filter((id) => /^gemini-/.test(id)));
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+// 설치된 agy 1.2.12를 모의 Gemini 엔드포인트에 연결해 실제 요청 ID가
+// 선택 ID와 일치함을 확인한 모델만 열어 둔다. 새 모델은 같은 검증 후 추가한다.
+const AGY_VERIFIED_MODELS = new Map([
+  ["gemini-3.8-flash", "gemini-3.8-flash"],
+  ["gemini-3.7-flash", "gemini-3.7-flash"],
+  ["gemini-3.6-flash", "gemini-3.6-flash"],
+  ["gemini-3.1-pro-preview", "gemini-3.1-pro"],
+]);
+
+export function agyCliModel(model, ids) {
+  const cliBase = AGY_VERIFIED_MODELS.get(model);
+  if (!cliBase) return null;
+  return [cliBase, `${cliBase}-medium`, `${cliBase}-high`, `${cliBase}-low`, `${cliBase}-max`].find((id) => ids.has(id)) || null;
+}
+
+export function supportsAgyModel(model, ids) {
+  return Boolean(agyCliModel(model, ids));
+}
+
+function opencodeStateDir({ run = execFileSync } = {}) {
+  try {
+    const paths = run("opencode", ["debug", "paths"], { encoding: "utf8", timeout: 5000 });
+    const state = /^state\s+(.+)$/m.exec(String(paths))?.[1]?.trim();
+    if (state) return state;
+  } catch {}
+  return join(process.env.XDG_STATE_HOME || join(homedir(), ".local", "state"), "opencode");
+}
+
+export function seedOpenCodeFavorites(models, { stateDir = opencodeStateDir() } = {}) {
+  const path = join(stateDir, "model.json");
+  const state = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+  if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error("Invalid OpenCode model state");
+  const current = Array.isArray(state.favorite) ? state.favorite : [];
+  const active = new Set(codingModels(models).map((m) => m.id));
+  const pins = CORE_MODELS.filter((id) => active.has(id)).map((modelID) => ({ providerID: "openai", modelID }));
+  const pinKeys = new Set(pins.map((m) => `${m.providerID}/${m.modelID}`));
+  const favorite = [...pins, ...current.filter((m) => !pinKeys.has(`${m.providerID}/${m.modelID}`))];
+  if (JSON.stringify(favorite) === JSON.stringify(current)) return;
+  mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+  const temp = join(stateDir, `model.json.pleum-${process.pid}`);
+  try {
+    writeFileSync(temp, JSON.stringify({ ...state, favorite }), { mode: 0o600 });
+    renameSync(temp, path);
+  } finally {
+    rmSync(temp, { force: true });
+  }
+}
+
 // 공통 실행 파이프라인의 설정 어댑터. 신규 에이전트는 env/args만 쓰거나
 // 별도 홈이 필요할 때 타입 핸들러 하나를 등록하면 된다.
 const SETUP = {
@@ -130,6 +205,9 @@ export async function launch(tool, model, passthrough, {
   getKey = agentKey,
   pathCheck = onPath,
   spawnChild = spawn,
+  getModels = fetchModels,
+  getAgyModels = listAgyModelIds,
+  seedFavorites = seedOpenCodeFavorites,
 } = {}) {
   recoverAgySettings();
   const resolved = resolveLaunchTool(tool);
@@ -156,15 +234,41 @@ export async function launch(tool, model, passthrough, {
     return 127;
   }
 
-  const key = await getKey();
   model = resolveLaunchModel(resolved, model);
+  let catalog;
+  if (model?.mode === "custom" || resolved === "opencode") {
+    catalog = codingModels(await getModels());
+    const chosen = model?.mode === "custom" ? model.model : model;
+    const [id, provider] = String(chosen || "").split("@");
+    const entry = catalog.find((m) => m.id === id);
+    if (!entry || (provider && !entry.providers?.some((p) => p.provider === provider))) {
+      throw new Error(t("Model is not an active coding model: {model}", { model: sanitizeTerminalText(chosen) }));
+    }
+    if (resolved === "agy") {
+      const cliModel = agyCliModel(chosen, getAgyModels());
+      if (!cliModel) {
+        throw new Error(t("Antigravity does not support this model through its Gemini API mode: {model}", { model: sanitizeTerminalText(chosen) }));
+      }
+      model = { ...model, cliModel };
+    }
+  }
+  const key = await getKey();
 
-  const env = { ...process.env, ...r.env(key, model) };
+  const env = { ...process.env };
   for (const name of r.unsetEnv || []) delete env[name];
+  Object.assign(env, r.env(key, model, catalog));
   const setup = SETUP[r.type || "env"];
   if (!setup) throw new Error(`Unknown agent setup type: ${r.type}`);
   let restore = setup(env, model);
 
+  if (resolved === "opencode") {
+    try {
+      seedFavorites(catalog);
+    } catch (e) {
+      console.log(`ℹ ${t("Could not add Pleum models to OpenCode favorites: {error}", { error: sanitizeTerminalText(e.message) })}`);
+    }
+  }
+
   const cleanup = () => {
     if (restore) {
       restore();

package/src/locales/es.mjs

@@ -71,8 +71,6 @@ export const ES = {
     "Necesita GitHub Copilot CLI 2026-04 o posterior para el enrutamiento de proveedores BYOK.",
   "Gemini CLI speaks Google's native generateContent format — set the model after launch with `/model google/<id>`.":
     "Gemini CLI usa el formato nativo generateContent de Google — establece el modelo tras el inicio con `/model google/<id>`.",
-  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Routes any coding model via PleumRouter.":
-    "Escribe modelProvider=gemini en ~/.gemini/antigravity-cli/settings.json. Enruta cualquier modelo de codificación a través de PleumRouter.",
   "↑ {n} more above": "↑ {n} más arriba",
   "↓ {n} more below": "↓ {n} más abajo",
   "Auto (best route)": "Auto (mejor ruta)",
@@ -331,5 +329,19 @@ export const ES = {
   "Medium (Standard)": "Medio (Estándar)",
   "Balanced reasoning effort": "Esfuerzo de razonamiento equilibrado",
   "Low reasoning effort for rapid iteration": "Bajo esfuerzo de razonamiento para iteraciones rápidas",
+  // Agent launch modes
+  "Antigravity custom supports only verified Gemini models in API-key mode.": "Antigravity custom solo admite modelos Gemini verificados en modo de clave API.",
+  "Anthropic official models": "Continuar con modelos oficiales de Anthropic",
+  "OpenAI official models": "Continuar con modelos oficiales de OpenAI",
+  "Antigravity default models": "Continuar con modelos predeterminados de Antigravity",
+  "Choose models inside the agent": "Elegir modelo dentro del agente",
+  "Choose my model (beta)": "Elegir mi modelo (beta)",
+  "Select a PleumRouter coding model": "Elegir un modelo de código de PleumRouter",
+  "No compatible coding models available": "No hay modelos de código compatibles",
+  "Antigravity model discovery failed: {error}": "No se pudo consultar los modelos de Antigravity: {error}",
+  "Model is not an active coding model: {model}": "No es un modelo de código activo: {model}",
+  "Antigravity does not support this model through its Gemini API mode: {model}": "Antigravity no admite este modelo en modo Gemini API: {model}",
+  "Could not add Pleum models to OpenCode favorites: {error}": "No se pudieron añadir modelos Pleum a favoritos de OpenCode: {error}",
+  "↑/↓ move • enter select • esc quit": "↑/↓ mover • enter seleccionar • esc salir",
+  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Supported Gemini models route via PleumRouter.": "Escribe modelProvider=gemini en ~/.gemini/antigravity-cli/settings.json. Los modelos Gemini compatibles usan PleumRouter.",
 };
-

package/src/locales/ja.mjs

@@ -72,8 +72,6 @@ export const JA = {
     "BYOK プロバイダールーティングに対応した 2026-04 以降の GitHub Copilot CLI が必要です。",
   "Gemini CLI speaks Google's native generateContent format — set the model after launch with `/model google/<id>`.":
     "Gemini CLI は Google のネイティブ generateContent 形式を使用します — 起動後に `/model google/<id>` でモデルを設定してください。",
-  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Routes any coding model via PleumRouter.":
-    "~/.gemini/antigravity-cli/settings.json に modelProvider=gemini を書き込みます。あらゆるコーディングモデルを PleumRouter でルーティングします。",
   "↑ {n} more above": "↑ 上にあと {n} 件",
   "↓ {n} more below": "↓ 下にあと {n} 件",
   "Auto (best route)": "Auto (最適な自動ルーティング)",
@@ -331,5 +329,19 @@ export const JA = {
   "Medium (Standard)": "中 (標準)",
   "Balanced reasoning effort": "バランスの取れた標準的な推論強度",
   "Low reasoning effort for rapid iteration": "迅速なイテレーション向けの低い推論強度",
+  // Agent launch modes
+  "Antigravity custom supports only verified Gemini models in API-key mode.": "Antigravity custom は API キーモードで検証済みの Gemini モデルのみ対応します。",
+  "Anthropic official models": "Anthropic 公式モデルで続行",
+  "OpenAI official models": "OpenAI 公式モデルで続行",
+  "Antigravity default models": "Antigravity 標準モデルで続行",
+  "Choose models inside the agent": "エージェント内でモデルを選択",
+  "Choose my model (beta)": "モデルを自分で選ぶ (beta)",
+  "Select a PleumRouter coding model": "PleumRouter のコーディングモデルを選択",
+  "No compatible coding models available": "対応するコーディングモデルがありません",
+  "Antigravity model discovery failed: {error}": "Antigravity のモデル一覧を取得できません: {error}",
+  "Model is not an active coding model: {model}": "有効なコーディングモデルではありません: {model}",
+  "Antigravity does not support this model through its Gemini API mode: {model}": "Antigravity の Gemini API モードでは使用できません: {model}",
+  "Could not add Pleum models to OpenCode favorites: {error}": "OpenCode のお気に入りに Pleum モデルを追加できません: {error}",
+  "↑/↓ move • enter select • esc quit": "↑/↓ 移動 • enter 選択 • esc 終了",
+  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Supported Gemini models route via PleumRouter.": "~/.gemini/antigravity-cli/settings.json に modelProvider=gemini を書き込みます。対応する Gemini モデルを PleumRouter 経由で使用します。",
 };
-

package/src/locales/ko.mjs

@@ -52,8 +52,6 @@ export const KO = {
     "BYOK provider 라우팅을 지원하는 2026-04 이후 버전의 GitHub Copilot CLI가 필요합니다.",
   "Gemini CLI speaks Google's native generateContent format — set the model after launch with `/model google/<id>`.":
     "Gemini CLI는 Google의 네이티브 generateContent 포맷을 사용합니다 — 실행 후 `/model google/<id>`로 모델을 설정하세요.",
-  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Routes any coding model via PleumRouter.":
-    "~/.gemini/antigravity-cli/settings.json 에 modelProvider=gemini 를 씁니다. 모든 코딩 모델을 PleumRouter로 라우팅합니다.",
   "↑ {n} more above": "↑ 위에 {n}개 더",
   "↓ {n} more below": "↓ 아래에 {n}개 더",
   "Auto (best route)": "Auto (최적 자동 라우팅)",
@@ -394,5 +392,19 @@ export const KO = {
   "Medium (Standard)": "보통 (표준)",
   "Balanced reasoning effort": "균형 잡힌 표준 추론 강도",
   "Low reasoning effort for rapid iteration": "빠른 반복 작업을 위한 낮은 추론 강도",
+  // Agent launch modes
+  "Antigravity custom supports only verified Gemini models in API-key mode.": "Antigravity custom은 API 키 모드에서 검증된 Gemini 모델만 지원합니다.",
+  "Anthropic official models": "Anthropic 공식 모델로 진행",
+  "OpenAI official models": "OpenAI 공식 모델로 진행",
+  "Antigravity default models": "Antigravity 기본 모델로 진행",
+  "Choose models inside the agent": "에이전트 안에서 모델 선택",
+  "Choose my model (beta)": "모델 내가 custom하기(beta)",
+  "Select a PleumRouter coding model": "PleumRouter 코딩 모델 선택",
+  "No compatible coding models available": "호환되는 코딩 모델이 없습니다",
+  "Antigravity model discovery failed: {error}": "Antigravity 모델 목록 조회 실패: {error}",
+  "Model is not an active coding model: {model}": "활성 코딩 모델이 아닙니다: {model}",
+  "Antigravity does not support this model through its Gemini API mode: {model}": "Antigravity Gemini API 모드에서 지원하지 않는 모델입니다: {model}",
+  "Could not add Pleum models to OpenCode favorites: {error}": "OpenCode 즐겨찾기에 Pleum 모델을 추가하지 못했습니다: {error}",
+  "↑/↓ move • enter select • esc quit": "↑/↓ 이동 • enter 선택 • esc 종료",
+  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Supported Gemini models route via PleumRouter.": "~/.gemini/antigravity-cli/settings.json에 modelProvider=gemini를 씁니다. 지원되는 Gemini 모델을 PleumRouter로 라우팅합니다.",
 };
-

package/src/locales/zh.mjs

@@ -71,8 +71,6 @@ export const ZH = {
     "需要 2026-04 或更新版本的 GitHub Copilot CLI 才支持 BYOK provider 路由。",
   "Gemini CLI speaks Google's native generateContent format — set the model after launch with `/model google/<id>`.":
     "Gemini CLI 使用 Google 原生 generateContent 格式 — 启动后用 `/model google/<id>` 设置模型。",
-  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Routes any coding model via PleumRouter.":
-    "将 modelProvider=gemini 写入 ~/.gemini/antigravity-cli/settings.json。通过 PleumRouter 路由所有编码模型。",
   "↑ {n} more above": "↑ 上方还有 {n} 项",
   "↓ {n} more below": "↓ 下方还有 {n} 项",
   "Auto (best route)": "Auto (最佳自动路由)",
@@ -331,5 +329,19 @@ export const ZH = {
   "Medium (Standard)": "中 (标准)",
   "Balanced reasoning effort": "平衡的标准推理强度",
   "Low reasoning effort for rapid iteration": "快速迭代的低推理强度",
+  // Agent launch modes
+  "Antigravity custom supports only verified Gemini models in API-key mode.": "Antigravity 自选模型在 API 密钥模式下仅支持已验证的 Gemini 模型。",
+  "Anthropic official models": "使用 Anthropic 官方模型",
+  "OpenAI official models": "使用 OpenAI 官方模型",
+  "Antigravity default models": "使用 Antigravity 默认模型",
+  "Choose models inside the agent": "在代理中选择模型",
+  "Choose my model (beta)": "自选模型 (beta)",
+  "Select a PleumRouter coding model": "选择 PleumRouter 编程模型",
+  "No compatible coding models available": "没有兼容的编程模型",
+  "Antigravity model discovery failed: {error}": "获取 Antigravity 模型列表失败：{error}",
+  "Model is not an active coding model: {model}": "不是可用的编程模型：{model}",
+  "Antigravity does not support this model through its Gemini API mode: {model}": "Antigravity 的 Gemini API 模式不支持此模型：{model}",
+  "Could not add Pleum models to OpenCode favorites: {error}": "无法将 Pleum 模型加入 OpenCode 收藏：{error}",
+  "↑/↓ move • enter select • esc quit": "↑/↓ 移动 • enter 选择 • esc 退出",
+  "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Supported Gemini models route via PleumRouter.": "将 modelProvider=gemini 写入 ~/.gemini/antigravity-cli/settings.json。支持的 Gemini 模型经由 PleumRouter 路由。",
 };
-

package/src/menu.mjs

@@ -1,11 +1,4 @@
-// Ollama 0.31 런처풍 시작 메뉴 — bare `pleum`(TTY)에서 뜬다. 비TTY면 false 반환(호출자가 HELP 폴백).
-// 동작 패리티(ollama cmd/tui/tui.go·cmd/launch 소스 분석 기반):
-//   · 인라인 렌더(대체 화면 아님), ▸ 커서 + dim 설명 2줄 항목, 하단 키 안내
-//   · →(configure) = 모델 피커를 강제로 띄우고 선택 즉시 실행(+ launch_models에 저장)
-//   · Enter = 저장된 모델(launch_models)로 바로 실행, 미설치면 Y/n 확인 후 자동 설치
-//   · 실행 종료 후 메뉴로 복귀(ollama runInteractiveTUI 루프), last_selection 커서 복원
-//   · 키보드 전용: ↑/k ↓/j 이동 · enter/space 실행 · →/l 모델 설정 · esc/q 뒤로(최상위에선 종료) · ctrl+c 즉시 종료
-// 4대 에이전트는 최상위에서 바로 실행하고, 나머지는 "에이전트 실행" 서브메뉴에서 고른다.
+// bare `pleum` 인라인 런처. 첫 화면의 에이전트 실행 → 도구 → 실행 모드를 공유한다.
 
 import { readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
@@ -14,8 +7,8 @@ import { style, displayWidth, terminalWidth, terminalHeight, hyperlink, sanitize
 import { keyFeeder, select } from "./interactive.mjs";
 import { readConfig, writeConfig, isLoggedIn, getActiveContext } from "./config.mjs";
 import { RECIPES, MANUAL, DEFAULT_MODEL } from "./recipes.mjs";
-import { onPath, launch } from "./launch.mjs";
-import { fetchModels, matchModels, listModels, formatModelLabel, fetchCoreCodingModels, CORE_MODEL_PROVIDERS } from "./models.mjs";
+import { onPath, launch, listAgyModelIds, supportsAgyModel } from "./launch.mjs";
+import { fetchModels, matchModels, listModels, formatModelLabel, codingModels, coreCodingModels } from "./models.mjs";
 import { run } from "./run.mjs";
 import { login } from "./login.mjs";
 import { balance } from "./balance.mjs";
@@ -50,24 +43,14 @@ const AGENT_DESC = {
 const autoInstallable = (r) => !/^https?:/.test(r.install); // URL이면 수동 설치 안내만
 
 // 최상위 메뉴 항목(순수 함수 — 테스트 대상). 로그인은 첫 에이전트 실행 시 시작한다.
-export function buildItems({ savedModels = {}, activeContext = { type: "personal" }, installed = {} }) {
-  const items = [];
-  for (const tool of ["claude", "codex", "agy", "opencode"]) {
-    const r = RECIPES[tool];
-    items.push({
-      id: `launch:${tool}`,
-      tool,
-      title: `${r.label}${installed[tool] === false ? `  (${t("install")})` : ""}`,
-      desc: `${t(AGENT_DESC[tool])}${savedModels[tool] ? ` · ${t("model")}: ${savedModels[tool]}` : ""}`,
-    });
-  }
+export function buildItems({ savedModels = {}, activeContext = { type: "personal" } }) {
+  const items = [{ id: "agents", title: t("Run an agent"), desc: t("Pick a coding agent to run through PleumRouter") }];
   items.push({
     id: "chat",
     tool: "chat",
     title: t("Chat with a model"),
     desc: `${t("Start an interactive chat")}${savedModels.chat ? ` · ${t("model")}: ${savedModels.chat}` : ""}`,
   });
-  items.push({ id: "agents", title: t("Run an agent"), desc: t("Pick a coding agent to run through PleumRouter") });
   const contextDesc = activeContext?.type === "team" && activeContext.org_name
     ? `${t("Team")}: ${activeContext.org_name}`
     : t("Personal");
@@ -88,7 +71,7 @@ export function buildAgentItems({ installed, savedModels = {} }) {
       tool,
       title: `${r.label}${installed[tool] ? "" : autoInstallable(r) ? `  (${t("install")})` : `  (${t("not installed")})`}`,
       desc: installed[tool]
-        ? `${t(AGENT_DESC[tool] ?? "")}${savedModels[tool] ? ` · ${t("model")}: ${savedModels[tool]}` : ""}`
+        ? `${t(AGENT_DESC[tool] ?? "")}${savedModels[tool] && !["claude", "codex", "agy"].includes(tool) ? ` · ${t("model")}: ${savedModels[tool]}` : ""}`
         : autoInstallable(r)
           ? `${t("Press Enter to install now")} — ${r.install}`
           : `${t("Manual install:")} ${hyperlink(r.install)}`,
@@ -123,9 +106,10 @@ function saveLastSelection(id) {
   writeConfig(cfg);
 }
 
-export async function pickProviderForModel(modelId, { input = process.stdin, output = process.stdout } = {}) {
+export async function pickProviderForModel(model, { input = process.stdin, output = process.stdout } = {}) {
+  const modelId = typeof model === "string" ? model : model?.id;
   if (!modelId || modelId === "__view_all__") return modelId;
-  const providers = CORE_MODEL_PROVIDERS[modelId] || [];
+  const providers = [...new Set((typeof model === "string" ? [] : model.providers || []).map((p) => p.provider).filter(Boolean))];
   if (!providers.length) return modelId;
 
   const options = [
@@ -134,10 +118,10 @@ export async function pickProviderForModel(modelId, { input = process.stdin, out
       title: `⚡ ${t("Auto (best route)")}`,
       desc: t("PleumRouter auto-routing — lowest price, lowest latency, automatic failover"),
     },
-    ...providers.map((p) => ({
-      id: p.id,
-      title: p.name,
-      desc: t("Pin to {provider} (@{provider})", { provider: p.id }),
+    ...providers.map((provider) => ({
+      id: provider,
+      title: provider,
+      desc: t("Pin to {provider} (@{provider})", { provider }),
     })),
   ];
 
@@ -154,9 +138,20 @@ export async function pickProviderForModel(modelId, { input = process.stdin, out
   return `${modelId}@${chosen.id}`;
 }
 
-export async function pickModelFor(item, defaultModel) {
+export async function pickModelFor(item, defaultModel, { supported = () => true, allowProvider = true } = {}) {
+  let allModels;
+  try {
+    allModels = codingModels(await fetchModels()).filter((m) => supported(m.id));
+  } catch (e) {
+    console.log(`${style.red("✗")} ${t("Failed to fetch model list: {error}", { error: sanitizeTerminalText(e.message) })}`);
+    return undefined;
+  }
+  if (!allModels.length) {
+    console.log(`${style.red("✗")} ${t("No compatible coding models available")}`);
+    return undefined;
+  }
   for (;;) {
-    const core = fetchCoreCodingModels();
+    const core = coreCodingModels(allModels);
     const items = [
       ...core,
       {
@@ -177,13 +172,6 @@ export async function pickModelFor(item, defaultModel) {
 
     let pickedModelId = m.id;
     if (pickedModelId === "__view_all__") {
-      let allModels;
-      try {
-        allModels = await fetchModels();
-      } catch (e) {
-        console.log(`${style.red("✗")} ${t("Failed to fetch model list: {error}", { error: sanitizeTerminalText(e.message) })}`);
-        return undefined;
-      }
       const allPicked = await select(allModels, {
         message: `${item.title} — ${t("select a model")}`,
         formatItem: (x) => formatModelLabel(x),
@@ -194,113 +182,20 @@ export async function pickModelFor(item, defaultModel) {
       pickedModelId = allPicked.id;
     }
 
-    const withProvider = await pickProviderForModel(pickedModelId);
+    const selected = allModels.find((x) => x.id === pickedModelId);
+    const withProvider = allowProvider ? await pickProviderForModel(selected) : pickedModelId;
     if (!withProvider) continue;
     return withProvider;
   }
 }
 
-export async function pickClaudeCodeTiers(agentItem, { input = process.stdin, output = process.stdout } = {}) {
-  const cfg = readConfig() ?? {};
-  const savedTiers = cfg.claude_tiers;
-  const defaultTiers = {
-    sonnet: "claude-sonnet-5",
-    opus: "claude-opus-5-5",
-    haiku: "claude-haiku-4-5",
-  };
-  const baseTiers = {
-    sonnet: savedTiers?.sonnet || defaultTiers.sonnet,
-    opus: savedTiers?.opus || defaultTiers.opus,
-    haiku: savedTiers?.haiku || defaultTiers.haiku,
-  };
-
-  // 기존 설정이 존재하면 1-클릭 확인 메뉴: Enter 1회로 기존 설정대로 즉시 실행
-  if (savedTiers && savedTiers.sonnet && savedTiers.opus && savedTiers.haiku) {
-    const keepChoice = await select(
-      [
-        {
-          id: "keep",
-          title: t("Keep existing configuration"),
-          desc: `Sonnet: ${savedTiers.sonnet} · Opus: ${savedTiers.opus} · Haiku: ${savedTiers.haiku}`,
-        },
-        {
-          id: "change",
-          title: t("Reconfigure tiers"),
-          desc: t("Choose Sonnet, Opus, and Haiku models again"),
-        },
-      ],
-      {
-        message: `${agentItem.title} — ${t("Use existing model configuration?")}`,
-        formatItem: (x) => `${x.title}  ${style.dim(x.desc)}`,
-        limit: 5,
-        input,
-        output,
-      },
-    );
-    if (!keepChoice) return null;
-    if (keepChoice.id === "keep") {
-      return savedTiers;
-    }
-  }
-
-  // 1/3단계: Sonnet 모델 지정 (10개 핵심 추천 + 200+ 전체 검색 + 프로바이더 라우팅)
-  const sonnet = await pickModelFor(
-    { title: `${agentItem.title} (1/3) — ${t("Sonnet model")}` },
-    baseTiers.sonnet,
-  );
-  if (!sonnet) return null;
-
-  // 2/3단계: Opus 모델 지정 (10개 핵심 추천 + 200+ 전체 검색 + 프로바이더 라우팅)
-  const opus = await pickModelFor(
-    { title: `${agentItem.title} (2/3) — ${t("Opus model")}` },
-    baseTiers.opus,
-  );
-  if (!opus) return null;
-
-  // 3/3단계: Haiku 모델 지정 (10개 핵심 추천 + 200+ 전체 검색 + 프로바이더 라우팅)
-  const haiku = await pickModelFor(
-    { title: `${agentItem.title} (3/3) — ${t("Haiku model")}` },
-    baseTiers.haiku,
-  );
-  if (!haiku) return null;
-
-  const resultTiers = { sonnet, opus, haiku };
-  cfg.claude_tiers = resultTiers;
-  writeConfig(cfg);
-  return resultTiers;
-}
-
-export async function pickCodexEffort(defaultEffort = "medium") {
-  const options = [
-    { id: "medium", title: `⚡ ${t("Medium (Recommended)")}`, desc: t("Balanced reasoning speed and depth") },
-    { id: "high", title: `🔥 ${t("High (Deep reasoning)")}`, desc: t("Maximum reasoning depth for complex tasks") },
-    { id: "low", title: `⚡ ${t("Low (Fast response)")}`, desc: t("Lightweight reasoning for quick answers") },
-  ];
-  const initialIndex = options.findIndex((x) => x.id === defaultEffort);
-  const picked = await select(options, {
-    message: `Codex — ${t("Select reasoning effort")}`,
-    formatItem: (x) => `${x.title}  ${style.dim(x.desc)}`,
-    limit: 5,
-    initialCursor: initialIndex >= 0 ? initialIndex : 0,
-  });
-  return picked ? picked.id : null;
-}
-
-export async function pickAgyEffort(defaultEffort = "high") {
-  const options = [
-    { id: "high", title: `⚡ ${t("High (Recommended)")}`, desc: t("High reasoning effort for standard tasks") },
-    { id: "max", title: `🚀 ${t("Max (Maximum reasoning)")}`, desc: t("Full reasoning effort for difficult problems") },
-    { id: "medium", title: `⚖️ ${t("Medium (Standard)")}`, desc: t("Balanced reasoning effort") },
-    { id: "low", title: `⚡ ${t("Low (Fast response)")}`, desc: t("Low reasoning effort for rapid iteration") },
+export function agentModeItems(tool) {
+  const native = tool === "claude" ? "Anthropic official models"
+    : tool === "codex" ? "OpenAI official models" : "Antigravity default models";
+  return [
+    { id: "native", title: t(native), desc: t("Choose models inside the agent") },
+    { id: "custom", title: t("Choose my model (beta)"), desc: t("Select a PleumRouter coding model") },
   ];
-  const initialIndex = options.findIndex((x) => x.id === defaultEffort);
-  const picked = await select(options, {
-    message: `Antigravity CLI (agy) — ${t("Select reasoning effort")}`,
-    formatItem: (x) => `${x.title}  ${style.dim(x.desc)}`,
-    limit: 6,
-    initialCursor: initialIndex >= 0 ? initialIndex : 0,
-  });
-  return picked ? picked.id : null;
 }
 
 // 미설치 도구: ollama처럼 확인 후 그 자리에서 설치(stdio 상속). 성공 시 true.
@@ -465,7 +360,7 @@ export async function runList(items, { header, footer, initialCursor = 0 } = {})
         else if (key.type === "down" || (key.type === "char" && key.value === "j")) move(1);
         else if (key.type === "right" || (key.type === "char" && key.value === "l")) {
           const it = items[cursor];
-          if (!it.tool || it.manual) continue; // 도구 없는 항목·수동 설정 항목은 모델 설정 불가
+          if (!it.tool || it.manual || ["claude", "codex", "agy", "opencode"].includes(it.tool)) continue;
           return void (await configure(it));
         } else continue;
         dirty = true;
@@ -488,14 +383,13 @@ async function menuSelect() {
   const items = buildItems({
     savedModels: cfg?.launch_models ?? {},
     activeContext: getActiveContext(cfg),
-    installed: Object.fromEntries(["claude", "codex", "agy", "opencode"].map((tool) => [tool, onPath(RECIPES[tool].bin)])),
   });
   const last = cfg?.last_selection;
   const initialCursor = last ? Math.max(0, items.findIndex((it) => it.id === last)) : 0;
   const headerLines = [`${style.bold(style.plum("PleumRouter"))} ${style.dim(`pleum ${version}`)}`];
   return runList(items, {
     header: headerLines.join("\n"),
-    footer: t("↑/↓ move • enter run • → set model • esc quit"),
+    footer: t("↑/↓ move • enter select • esc quit"),
     initialCursor,
   });
 }
@@ -507,12 +401,11 @@ async function agentSelect() {
   const items = buildAgentItems({ installed, savedModels: readConfig()?.launch_models ?? {} });
   return runList(items, {
     header: style.bold(style.plum(t("Run an agent via PleumRouter"))),
-    footer: t("↑/↓ move • enter run • → set model • esc back"),
+    footer: t("↑/↓ move • enter select • esc back"),
   });
 }
 
-// 에이전트 실행 메뉴 — bare pleum의 "에이전트 실행"과 pleum launch (인자 없음)가 공유.
-// Enter는 저장 모델로 즉시 실행하고, →는 모델 선택 후 실행한다.
+// bare pleum의 "에이전트 실행"과 pleum launch (인자 없음)가 공유한다.
 export async function runAgentMenu({ loop = false } = {}) {
   const io = process.stdin;
   if (!io.isTTY || !process.stdout.isTTY || typeof io.setRawMode !== "function") return false;
@@ -535,8 +428,34 @@ export async function runAgentMenu({ loop = false } = {}) {
       continue;
     }
 
-    if (agentPicked.model) saveModel(agentItem.tool, agentPicked.model);
-    await launch(agentItem.tool, agentPicked.model, [], { exit: false });
+    let model = agentPicked.model;
+    if (["claude", "codex", "agy"].includes(agentItem.tool)) {
+      const mode = await select(agentModeItems(agentItem.tool), {
+        message: agentItem.title,
+        formatItem: (x) => `${x.title}  ${style.dim(x.desc)}`,
+        limit: 4,
+      });
+      if (!mode) continue;
+      if (mode.id === "custom") {
+        let supported = () => true;
+        if (agentItem.tool === "agy") {
+          try {
+            const ids = listAgyModelIds();
+            supported = (id) => supportsAgyModel(id, ids);
+            console.log(style.dim(t("Antigravity custom supports only verified Gemini models in API-key mode.")));
+          } catch (e) {
+            console.log(`${style.red("✗")} ${t("Antigravity model discovery failed: {error}", { error: sanitizeTerminalText(e.message) })}`);
+            continue;
+          }
+        }
+        const saved = readConfig()?.launch_models?.[agentItem.tool];
+        const selected = await pickModelFor(agentItem, saved, { supported, allowProvider: agentItem.tool !== "agy" });
+        if (!selected) continue;
+        saveModel(agentItem.tool, selected);
+        model = { mode: "custom", model: selected };
+      } else model = { mode: "native" };
+    } else if (agentPicked.model) saveModel(agentItem.tool, agentPicked.model);
+    await launch(agentItem.tool, model, [], { exit: false });
     console.log();
     if (!loop) return true;
   }
@@ -590,15 +509,6 @@ export async function mainMenu() {
         if (r === "quit") return true;
         continue;
       }
-      case "launch:claude":
-      case "launch:codex":
-      case "launch:agy":
-      case "launch:opencode": {
-        const tool = item.tool;
-        if (!onPath(RECIPES[tool].bin) && !(await ensureInstalled(RECIPES[tool]))) continue;
-        await launch(tool, model, [], { exit: false });
-        continue;
-      }
     }
   }
 }

package/src/models.mjs

@@ -2,129 +2,10 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFileSync, writeFileSync, mkdirSync, statSync } from "node:fs";
 import { V1 } from "./config.mjs";
+import { CORE_MODELS } from "./recipes.mjs";
 import { style, padDisplay, divider, sanitizeTerminalText } from "./ansi.mjs";
 import { t } from "./i18n.mjs";
 
-export const CORE_MODEL_PROVIDERS = {
-  "deepseek-ai/DeepSeek-V4.1-Flash": [
-    { id: "deepseek", name: "DeepSeek (Official)" },
-    { id: "together", name: "Together AI" },
-    { id: "fireworks", name: "Fireworks AI" },
-    { id: "siliconflow", name: "SiliconFlow" },
-  ],
-  "claude-sonnet-5": [
-    { id: "anthropic", name: "Anthropic (Official)" },
-    { id: "aws_bedrock", name: "AWS Bedrock" },
-    { id: "gcp_vertex", name: "Google Cloud Vertex AI" },
-  ],
-  "claude-opus-5-5": [
-    { id: "anthropic", name: "Anthropic (Official)" },
-    { id: "aws_bedrock", name: "AWS Bedrock" },
-    { id: "gcp_vertex", name: "Google Cloud Vertex AI" },
-  ],
-  "gpt-6-astra": [
-    { id: "openai", name: "OpenAI (Official)" },
-    { id: "azure", name: "Microsoft Azure OpenAI" },
-  ],
-  "gpt-6-sol": [
-    { id: "openai", name: "OpenAI (Official)" },
-    { id: "azure", name: "Microsoft Azure OpenAI" },
-  ],
-  "gpt-6-luna": [
-    { id: "openai", name: "OpenAI (Official)" },
-    { id: "azure", name: "Microsoft Azure OpenAI" },
-  ],
-  "gemini-3.8-flash": [
-    { id: "google", name: "Google AI Studio (Official)" },
-    { id: "vertex", name: "Google Cloud Vertex AI" },
-  ],
-  "qwen3.8-max": [
-    { id: "alibaba", name: "Alibaba DashScope (Official)" },
-    { id: "together", name: "Together AI" },
-    { id: "siliconflow", name: "SiliconFlow" },
-  ],
-  "glm-5.3-flash": [
-    { id: "zhipu", name: "Zhipu AI BigModel (Official)" },
-    { id: "modelark", name: "ByteDance ModelArk" },
-  ],
-  "kimi-k3": [
-    { id: "moonshot", name: "Moonshot AI (Official)" },
-  ],
-};
-
-export const CORE_MODEL_DEFAULTS = [
-  {
-    id: "deepseek-ai/DeepSeek-V4.1-Flash",
-    display_name: "DeepSeek V4.1 Flash (Ultra-fast coding)",
-    maker: "DeepSeek",
-    context_length: 131072,
-    pricing: { prompt: "0.00000014", completion: "0.00000028" },
-  },
-  {
-    id: "claude-sonnet-5",
-    display_name: "Claude Sonnet 5 (Anthropic flagship coding)",
-    maker: "Anthropic",
-    context_length: 200000,
-    pricing: { prompt: "0.000003", completion: "0.000015" },
-  },
-  {
-    id: "claude-opus-5-5",
-    display_name: "Claude Opus 5.5 (Deep reasoning & architecture)",
-    maker: "Anthropic",
-    context_length: 200000,
-    pricing: { prompt: "0.000005", completion: "0.000025" },
-  },
-  {
-    id: "gpt-6-astra",
-    display_name: "GPT-6 Astra (OpenAI flagship reasoning)",
-    maker: "OpenAI",
-    context_length: 128000,
-    pricing: { prompt: "0.0000025", completion: "0.00001" },
-  },
-  {
-    id: "gpt-6-sol",
-    display_name: "GPT-6 Sol (Fast coding & logic)",
-    maker: "OpenAI",
-    context_length: 128000,
-    pricing: { prompt: "0.000001", completion: "0.000004" },
-  },
-  {
-    id: "gpt-6-luna",
-    display_name: "GPT-6 Luna (Lightweight coding)",
-    maker: "OpenAI",
-    context_length: 128000,
-    pricing: { prompt: "0.0000005", completion: "0.000002" },
-  },
-  {
-    id: "gemini-3.8-flash",
-    display_name: "Gemini 3.8 Flash (1M context fast multimodal)",
-    maker: "Google",
-    context_length: 1048576,
-    pricing: { prompt: "0.00000035", completion: "0.0000014" },
-  },
-  {
-    id: "qwen3.8-max",
-    display_name: "Qwen 3.8 Max (Alibaba flagship coding)",
-    maker: "Alibaba",
-    context_length: 131072,
-    pricing: { prompt: "0.0000016", completion: "0.0000064" },
-  },
-  {
-    id: "glm-5.3-flash",
-    display_name: "GLM 5.3 Flash (Zhipu AI high-speed coding)",
-    maker: "Zhipu AI",
-    context_length: 128000,
-    pricing: { prompt: "0.0000001", completion: "0.0000002" },
-  },
-  {
-    id: "kimi-k3",
-    display_name: "Kimi K3 (Moonshot 256K long-context coding)",
-    maker: "Moonshot",
-    context_length: 262144,
-    pricing: { prompt: "0.0000006", completion: "0.0000024" },
-  },
-];
-
 let memoryModelsCache = null;
 let memoryCacheExpiry = 0;
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
@@ -133,19 +14,14 @@ function getCacheFilePath() {
   return join(homedir(), ".pleum", "models-cache.json");
 }
 
-export function fetchCoreCodingModels() {
-  const cacheFile = getCacheFilePath();
-  let liveList = memoryModelsCache;
-  if (!liveList) {
-    try {
-      liveList = JSON.parse(readFileSync(cacheFile, "utf8"));
-    } catch {}
-  }
-  const byId = new Map((liveList || []).map((m) => [m.id, m]));
-  return CORE_MODEL_DEFAULTS.map((def) => {
-    const live = byId.get(def.id);
-    return live ? { ...def, ...live } : { ...def };
-  });
+// 코딩 에이전트는 텍스트 대화 API를 호출한다. 공개 카탈로그의 다른 생성 방식은 피커에서 제외한다.
+export function codingModels(models) {
+  return models.filter((m) => m.is_active !== false && m.modality === "text" && m.operations?.includes("chat.generate"));
+}
+
+export function coreCodingModels(models) {
+  const byId = new Map(codingModels(models).map((m) => [m.id, m]));
+  return CORE_MODELS.map((id) => byId.get(id)).filter(Boolean);
 }
 
 // GET /v1/models 는 공개(인증 불필요). 슬러그는 provider/model 형식.

package/src/recipes.mjs

@@ -34,15 +34,10 @@ export const RECIPES = {
     label: "Claude Code",
     bin: "claude",
     type: "env",
-    unsetEnv: ["ANTHROPIC_API_KEY"],
-    resolveModel: (explicit, cfg) => {
-      if (explicit && typeof explicit === "object") return explicit;
-      return {
-        sonnet: explicit || cfg?.launch_models?.claude || cfg?.claude_tiers?.sonnet || "claude-sonnet-5",
-        opus: cfg?.claude_tiers?.opus || "claude-opus-5-5",
-        haiku: cfg?.claude_tiers?.haiku || "claude-haiku-4-5",
-      };
-    },
+    unsetEnv: ["ANTHROPIC_API_KEY", "ANTHROPIC_CUSTOM_MODEL_OPTION", "ANTHROPIC_CUSTOM_MODEL_OPTION_NAME", "ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION"],
+    resolveModel: (explicit) => explicit && typeof explicit === "object"
+      ? explicit
+      : explicit ? { mode: "custom", model: explicit } : { mode: "native" },
     install: "npm i -g @anthropic-ai/claude-code",
     // 앱 랭킹 귀속 메타 — 백엔드 featured_agents / UA fallback과 동기화.
     attribution: {
@@ -51,11 +46,7 @@ export const RECIPES = {
     },
     // 함정: ANTHROPIC_BASE_URL은 반드시 루트(/v1 없이) — CLI가 /v1/messages를 스스로 덧붙인다.
     // /v1을 넣으면 /v1/v1/messages가 되어 실패.
-    env: (key, m) => {
-      const isObj = m && typeof m === "object";
-      const sonnet = (isObj ? m.sonnet : m) || "claude-sonnet-5";
-      const opus = (isObj ? m.opus : null) || "claude-opus-5-5";
-      const haiku = (isObj ? m.haiku : null) || "claude-haiku-4-5";
+    env: (key, selection) => {
       // Claude 모델의 provider-qualified ID만 보정한다. 다른 회사 모델에
       // anthropic/을 붙이면 카탈로그에 없는 ID가 되어 요청이 실패한다.
       const toAnthropic = (x) => /^claude-/.test(x) ? `anthropic/${x}` : x;
@@ -65,30 +56,40 @@ export const RECIPES = {
         // CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY는 의도적으로 설정하지 않는다:
         // 활성화 시 Claude Code가 GET /v1/models를 호출해 카탈로그 200+개 모델을
         // /model 메뉴에 쏟아부어 화면이 난잡해지는 원인이 된다.
-        ANTHROPIC_DEFAULT_SONNET_MODEL: toAnthropic(sonnet),
+        ANTHROPIC_DEFAULT_SONNET_MODEL: toAnthropic("claude-sonnet-5"),
         ANTHROPIC_DEFAULT_SONNET_MODEL_NAME: "Sonnet",
         ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION: "Sonnet 5 · Efficient for routine tasks",
-        ANTHROPIC_DEFAULT_OPUS_MODEL: toAnthropic(opus),
+        ANTHROPIC_DEFAULT_OPUS_MODEL: toAnthropic("claude-opus-5-5"),
         ANTHROPIC_DEFAULT_OPUS_MODEL_NAME: "Opus",
         ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION: "Opus 5.5 · Best for everyday, complex tasks",
-        ANTHROPIC_DEFAULT_HAIKU_MODEL: toAnthropic(haiku),
+        ANTHROPIC_DEFAULT_FABLE_MODEL: toAnthropic("claude-fable-5-1"),
+        ANTHROPIC_DEFAULT_FABLE_MODEL_NAME: "Fable",
+        ANTHROPIC_DEFAULT_FABLE_MODEL_DESCRIPTION: "Fable 5.1 · Long-running tasks",
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: toAnthropic("claude-haiku-4-5"),
         ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME: "Haiku",
         ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION: "Haiku 4.5 · Fastest for quick answers",
-        ANTHROPIC_SMALL_MODEL: toAnthropic(haiku),
+        ANTHROPIC_SMALL_MODEL: toAnthropic("claude-haiku-4-5"),
+        ...(selection?.mode === "custom" ? {
+          ANTHROPIC_CUSTOM_MODEL_OPTION: toAnthropic(selection.model),
+          ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: `Pleum · ${selection.model}`,
+          ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: "Selected in Pleum for this session",
+          CLAUDE_CODE_SUBAGENT_MODEL: "sonnet",
+          CLAUDE_CODE_SUBAGENT_MODEL_FORCE: "1",
+        } : {}),
       };
     },
-    // CLI 인자에 임의의 --model을 넘기지 않고 Claude Code의 내장 티어(Default/Opus)로 기동하게 하여
-    // /model 화면에 깨끗한 5개 표준 항목(Default, Opus, Fable, Sonnet, Haiku)만 표시되도록 한다.
-    args: () => [],
+    args: (selection) => ["--model", selection?.mode === "custom"
+      ? (/^claude-/.test(selection.model) ? `anthropic/${selection.model}` : selection.model)
+      : "sonnet"],
   },
   codex: {
     label: "Codex CLI",
     bin: "codex",
     type: "env",
     defaultModel: "gpt-6-sol",
-    resolveModel: (explicit, cfg) => explicit && typeof explicit === "object"
+    resolveModel: (explicit) => explicit && typeof explicit === "object"
       ? explicit
-      : { model: explicit || cfg?.launch_models?.codex || "gpt-6-sol", effort: cfg?.codex_effort || "medium" },
+      : { mode: explicit ? "custom" : "native", model: explicit || "gpt-6-sol" },
     install: "npm i -g @openai/codex",
     attribution: {
       title: "Codex",
@@ -97,7 +98,6 @@ export const RECIPES = {
     env: (key) => ({ PLEUM_API_KEY: key }),
     args: (model) => {
       const m = model && typeof model === "object" ? model.model : model;
-      const effort = model && typeof model === "object" ? model.effort : null;
       const provider = {
         name: "PleumRouter",
         base_url: V1,
@@ -110,7 +110,6 @@ export const RECIPES = {
         "-c", 'model_provider="pleum"',
         "-c", `model_providers.pleum=${providerToml}`,
         "--model", m || "gpt-6-sol",
-        ...(effort ? ["-c", `model_reasoning_effort=${tomlBasicString(effort)}`] : []),
       ];
     },
   },
@@ -118,12 +117,11 @@ export const RECIPES = {
     label: "Antigravity CLI",
     bin: "agy",
     type: "agy-settings",
-    defaultModel: "gemini-3.8-flash",
-    resolveModel: (explicit, cfg) => explicit && typeof explicit === "object"
+    resolveModel: (explicit) => explicit && typeof explicit === "object"
       ? explicit
-      : { model: explicit || cfg?.launch_models?.agy || "gemini-3.8-flash", effort: cfg?.agy_effort || "high" },
+      : explicit ? { mode: "custom", model: explicit } : { mode: "native" },
     install: "https://antigravity.google/cli/install.sh",
-    note: "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Routes any coding model via PleumRouter.",
+    note: "Writes modelProvider=gemini into ~/.gemini/antigravity-cli/settings.json. Supported Gemini models route via PleumRouter.",
     attribution: {
       title: "Antigravity CLI",
       referer: "https://www.antigravity.google/docs/cli/install",
@@ -134,14 +132,9 @@ export const RECIPES = {
       GOOGLE_API_KEY: key,
     }),
     args: (m) => {
-      const isObj = m && typeof m === "object";
-      const model = (isObj ? m.model : m) || "gemini-3.8-flash";
-      const effort = isObj ? m.effort : null;
-      // agy의 --model은 내장 Gemini 모델만 받는다. 다른 카탈로그 ID는
-      // settings.json model로 전달하고 CLI 인자에는 싣지 않는다.
-      return /^(?:google\/)?gemini-/.test(model)
-        ? ["--model", model.replace(/^google\//, ""), "--effort", effort || "high"]
-        : [];
+      if (!m || m.mode === "native") return [];
+      const model = typeof m === "object" ? (m.cliModel || m.model) : m;
+      return ["--model", model.replace(/^google\//, "")];
     },
   },
   opencode: {
@@ -159,19 +152,22 @@ export const RECIPES = {
       title: "opencode",
       referer: "https://opencode.ai",
     },
-    env: (key, model) => {
+    env: (key, model, catalog = []) => {
       const active = model || "gpt-6-sol";
-      const models = Object.fromEntries(CORE_MODELS.map((id) => [id, {}]));
+      const models = Object.fromEntries(catalog.map(({ id }) => [id, {}]));
       models[active] = {};
       return {
         PLEUM_API_KEY: key,
         OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          enabled_providers: ["openai"],
+          disabled_providers: [],
           provider: {
             openai: {
               npm: "@ai-sdk/openai",
               name: "PleumRouter",
               options: { baseURL: V1, apiKey: "{env:PLEUM_API_KEY}" },
               models,
+              whitelist: Object.keys(models),
             },
           },
         }),
@@ -469,9 +465,11 @@ export function mergeAgySettings(existingJson, model) {
       throw new Error("agy settings.json must be a JSON object");
     }
   }
-  const isObj = model && typeof model === "object";
-  const m = (isObj ? model.model : model) || "gemini-3.8-flash";
-  return { ...obj, modelProvider: "gemini", model: m };
+  const m = typeof model === "object" ? model?.cliModel || model?.model : model;
+  const settings = { ...obj, modelProvider: "gemini" };
+  if (m) settings.model = m;
+  else delete settings.model;
+  return settings;
 }
 
 export function piModelsJson(model) {