jeo-code 0.6.23 → 0.6.26

package/CHANGELOG.md

@@ -6,6 +6,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.6.26] - 2026-06-19
+_The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게)._
+
+### Changed
+- **Forge emblem redrawn as the mascot crayfish with raised pincer claws (집게).** The compact and grand forge marks (`FORGE_MARK_ART` / `_GRAND`) now read as the neon crayfish (가재) from `assets/character.png`, foregrounding its defining feature — two raised pincer claws on angled arms (`◣◣ ◢◢` jaws over `◆══╲ ╱══◆` arms) above the glowing eye/terminal cluster (`◉◉◉`) and a rounded carapace/tail. Purely pictographic and wordless (no embedded lettering), width-1 glyphs only so the TUI's padding/centering math stays exact; the blink frames snap the claws shut so the crayfish "clicks". Cross-checked against gajae-code's image-based crab/crayfish brand and the shared blue→violet→pink neon palette. The grand variant stays wide enough (30 cols) to keep the narrow-box compact fallback reachable.
+
+## [0.6.25] - 2026-06-19
+_Reasoning works at every thinking level (gajae parity), and the forge emblem is redrawn as the neon-lens coding wizard._
+
+### Changed
+- **Reasoning now activates at EVERY thinking level — no level restriction (gajae parity).** Previously the lowest tier disabled reasoning entirely: `thinkingToReasoningEffort` collapsed `minimal`→`low`, and the provider budgets treated `minimal`/unset effort as OFF, so picking the lowest level (or `/fast`) silently turned thinking off. `minimal` is now a genuine lightest reasoning effort threaded end to end — Anthropic (`minimal → 2000` budget_tokens), Gemini (`minimal → 2000`, clamped under the output cap), and Antigravity-Claude (`minimal → 2000`) all enable scaling-depth thinking for `minimal`/`low`/`medium`/`high`, matching gajae-code's `[Minimal, Low, Medium, High]` effort set. Only a fully UNSET effort stays non-thinking (the explicit off path). `xhigh` still maps to the deepest `high` tier the provider APIs accept.
+- **Forge emblem redrawn as the mascot neon-lens coding wizard.** The compact and grand forge marks (`FORGE_MARK_ART` / `_GRAND`) now read as the character from `assets/character.png` — a pointed wizard hat with a twinkling star tip, the glowing asymmetric ◆/◇ neon lens eyes on a nose-bridge, and the violet gown shoulders cradling the glowing terminal screen the wizard holds (`◉◉◉`). Purely pictographic and wordless (no embedded lettering), width-1 glyphs only so the TUI's padding/centering math stays exact; the blink frames twinkle the star and wink the lenses.
+
+## [0.6.24] - 2026-06-19
+_`/provider` opens an interactive onboarding selector (OAuth vs API-compatible), and OpenAI-compatible backends gain per-vendor native-reasoning formats._
+
+### Added
+- **Interactive `/provider` onboarding selector (gjc parity).** A bare `/provider` (or `/login`) in a TTY now opens a picker — OAuth login (the common path) vs API-compatible endpoint setup — instead of printing static usage. New pure builders in `provider-picker.ts` (`buildOnboardingChoices` / `onboardingPicker` / `renderOnboardingPicker`); the scriptable/non-TTY path still falls through to the readiness panel unchanged, and a "Headless OAuth: paste the redirect URL or code" hint is shown for remote sessions.
+- **Per-vendor native-reasoning formats for OpenAI-compatible providers.** A `reasoningFormat` setting (`openai` → `reasoning_effort`, `openrouter` → `reasoning:{effort}`, `qwen` → `enable_thinking`, `zai` → `thinking:{type:"enabled"}`) lets the OpenAI-compatible factory enable streamed reasoning per backend, so OpenRouter/Qwen/Z.ai models surface thinking like the first-party providers.
+
+### Changed
+- **`/provider` and `/login` descriptions** updated to mention the interactive selector and the headless paste flow.
+- **ASCII-art / welcome rendering refactor** with refreshed tests (`ascii-art`, `pickers`, `tui-welcome`); the legacy `dna-claw-anim` animation test was retired.
+
 ## [0.6.23] - 2026-06-19
 _Live reasoning/thinking streams in the TUI across every provider, three new OpenAI-compatible backends (LM Studio, xAI, Kimi) join the auth/discovery/catalog surface, and Gemini gains native function-calling._
 

package/README.ja.md

@@ -204,11 +204,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
+- **[0.6.25]** (2026-06-19) — Reasoning works at every thinking level (gajae parity), and the forge emblem is redrawn as the neon-lens coding wizard.
+- **[0.6.24]** (2026-06-19) — `/provider` opens an interactive onboarding selector (OAuth vs API-compatible), and OpenAI-compatible backends gain per-vendor native-reasoning formats.
 - **[0.6.23]** (2026-06-19) — Live reasoning/thinking streams in the TUI across every provider, three new OpenAI-compatible backends (LM Studio, xAI, Kimi) join the auth/discovery/catalog surface, and Gemini gains native function-calling.
 - **[0.6.22]** (2026-06-18) — Extended-thinking activation is now consistent across providers: a `low` session thinking level enables reasoning everywhere.
-- **[0.6.21]** (2026-06-18) — Session thinking level now reaches the provider's actual reasoning depth, not just the token ceiling.
-- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
-- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -204,11 +204,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
+- **[0.6.25]** (2026-06-19) — Reasoning works at every thinking level (gajae parity), and the forge emblem is redrawn as the neon-lens coding wizard.
+- **[0.6.24]** (2026-06-19) — `/provider` opens an interactive onboarding selector (OAuth vs API-compatible), and OpenAI-compatible backends gain per-vendor native-reasoning formats.
 - **[0.6.23]** (2026-06-19) — Live reasoning/thinking streams in the TUI across every provider, three new OpenAI-compatible backends (LM Studio, xAI, Kimi) join the auth/discovery/catalog surface, and Gemini gains native function-calling.
 - **[0.6.22]** (2026-06-18) — Extended-thinking activation is now consistent across providers: a `low` session thinking level enables reasoning everywhere.
-- **[0.6.21]** (2026-06-18) — Session thinking level now reaches the provider's actual reasoning depth, not just the token ceiling.
-- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
-- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -204,11 +204,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
+- **[0.6.25]** (2026-06-19) — Reasoning works at every thinking level (gajae parity), and the forge emblem is redrawn as the neon-lens coding wizard.
+- **[0.6.24]** (2026-06-19) — `/provider` opens an interactive onboarding selector (OAuth vs API-compatible), and OpenAI-compatible backends gain per-vendor native-reasoning formats.
 - **[0.6.23]** (2026-06-19) — Live reasoning/thinking streams in the TUI across every provider, three new OpenAI-compatible backends (LM Studio, xAI, Kimi) join the auth/discovery/catalog surface, and Gemini gains native function-calling.
 - **[0.6.22]** (2026-06-18) — Extended-thinking activation is now consistent across providers: a `low` session thinking level enables reasoning everywhere.
-- **[0.6.21]** (2026-06-18) — Session thinking level now reaches the provider's actual reasoning depth, not just the token ceiling.
-- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
-- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -204,11 +204,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
+- **[0.6.25]** (2026-06-19) — Reasoning works at every thinking level (gajae parity), and the forge emblem is redrawn as the neon-lens coding wizard.
+- **[0.6.24]** (2026-06-19) — `/provider` opens an interactive onboarding selector (OAuth vs API-compatible), and OpenAI-compatible backends gain per-vendor native-reasoning formats.
 - **[0.6.23]** (2026-06-19) — Live reasoning/thinking streams in the TUI across every provider, three new OpenAI-compatible backends (LM Studio, xAI, Kimi) join the auth/discovery/catalog surface, and Gemini gains native function-calling.
 - **[0.6.22]** (2026-06-18) — Extended-thinking activation is now consistent across providers: a `low` session thinking level enables reasoning everywhere.
-- **[0.6.21]** (2026-06-18) — Session thinking level now reaches the provider's actual reasoning depth, not just the token ceiling.
-- **[0.6.20]** (2026-06-18) — Launch REPL internals decomposed into testable modules: `@mention` path completion, slash-command view renderers, and slash-command handlers extracted from the monolithic `launch.ts` into dedicated files with full unit-test coverage.
-- **[0.6.19]** (2026-06-18) — Post-turn hooks run once per batch (not per edit), local hook reads are mtime-cached, tool-result formatting is parallelized, and wrapped colored text keeps its tint.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.6.23",
+  "version": "0.6.26",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/ai/model-manager.ts

@@ -100,13 +100,16 @@ export function thinkingMaxTokens(level?: "minimal" | "low" | "medium" | "high"
   return 16000;
 }
 
-/** Map the thinking level to an OpenAI reasoning-effort tier. `minimal` maps to `low`
- *  (the lowest tier o-series reliably accepts; gpt-5's `minimal` is opt-in via options). */
+/** Map the thinking level to an OpenAI reasoning-effort tier. `minimal` is preserved as a
+ *  genuine (lightest) reasoning effort — NOT collapsed to `low` — so reasoning works at EVERY
+ *  thinking level (gajae parity: Minimal is a real effort). Only an unset level returns undefined
+ *  (reasoning off). `xhigh` maps to `high`, the deepest tier the provider APIs accept. */
 export function thinkingToReasoningEffort(
   level?: "minimal" | "low" | "medium" | "high" | "xhigh",
-): "low" | "medium" | "high" | undefined {
+): "minimal" | "low" | "medium" | "high" | undefined {
   if (!level) return undefined;
-  if (level === "minimal" || level === "low") return "low";
+  if (level === "minimal") return "minimal";
+  if (level === "low") return "low";
   if (level === "high" || level === "xhigh") return "high";
   return "medium";
 }

package/src/ai/provider-status.ts

@@ -29,6 +29,12 @@ export interface ProviderStatus {
   envVar?: string;
   /** True when the provider can serve a request right now. */
   ready: boolean;
+  /** True when an OAuth credential is stored for this provider (logged in via OAuth). */
+  loggedIn?: boolean;
+  /** Account email from the stored OAuth credential, when known. */
+  oauthEmail?: string;
+  /** Epoch ms expiry of the stored OAuth access token, when known. */
+  oauthExpires?: number;
 }
 
 /** The env var that supplies a provider's API key. Catalog providers carry their
@@ -59,6 +65,13 @@ function oauthAccess(stored: string | StoredOAuth | undefined): string | undefin
   return typeof stored === "string" ? stored : stored.access;
 }
 
+/** Login metadata (account email / expiry) from a stored OAuth record, when present. */
+function oauthLoginInfo(stored: string | StoredOAuth | undefined): { loggedIn: boolean; oauthEmail?: string; oauthExpires?: number } {
+  if (!stored) return { loggedIn: false };
+  if (typeof stored === "string") return { loggedIn: true };
+  return { loggedIn: true, oauthEmail: stored.email, oauthExpires: stored.expires };
+}
+
 function configuredCredential(provider: AuthProvider, cfg: Config): Credential {
   const stored = cfg.oauth?.[provider];
   const oauth = oauthAccess(stored);
@@ -123,6 +136,9 @@ export async function describeProvider(name: ProviderName, config?: Config): Pro
     // gemini-cli OAuth is served end-to-end via Cloud Code Assist — no API key.
     label = "OAuth (Gemini CLI / Cloud Code Assist)";
   }
+  // Login status reflects the provider's OWN stored OAuth (e.g. "logged in to antigravity"),
+  // independent of any cross-provider credential fallback used for readiness.
+  const login = oauthLoginInfo(cfg.oauth?.[ownProvider]);
   return {
     name,
     kind,
@@ -130,6 +146,9 @@ export async function describeProvider(name: ProviderName, config?: Config): Pro
     baseUrl,
     envVar: providerEnvVar(name),
     ready,
+    loggedIn: login.loggedIn,
+    oauthEmail: login.oauthEmail,
+    oauthExpires: login.oauthExpires,
   };
 }
 

package/src/ai/providers/anthropic.ts

@@ -73,11 +73,13 @@ function anthropicSystemBlocks(
 }
 
 /** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Cross-provider
- *  parity (matches Gemini's tiers): low/medium/high all enable thinking with scaling depth; only
- *  minimal/unset stay non-thinking so /fast and minimal thinking remain cheaper/faster. */
+ *  parity (matches Gemini's tiers): minimal/low/medium/high ALL enable thinking with scaling
+ *  depth — reasoning works at every thinking level (gajae parity: Minimal is a real effort).
+ *  Only an UNSET effort stays non-thinking (the explicit /fast off path). */
 function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxTokens: number): number | undefined {
   let budget: number;
   switch (effort) {
+    case "minimal": budget = 2000; break;
     case "low": budget = 4000; break;
     case "medium": budget = 10000; break;
     case "high": budget = 24000; break;

package/src/ai/providers/antigravity.ts

@@ -9,11 +9,15 @@ import { geminiThinkingBudget } from "./gemini";
 const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
 const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
 
+
 /** Anthropic-style thinking budget for Claude served via CCA. gemini's budget fn
  *  returns undefined for claude ids, which left antigravity Claude with NO thinking
- *  requested (the opus "no reasoning" gap). Mirrors anthropic's effort→budget tiers. */
+ *  requested (the opus "no reasoning" gap). Mirrors anthropic's effort→budget tiers —
+ *  minimal/low/medium/high ALL think (gajae parity: reasoning at every level); only an
+ *  UNSET effort stays non-thinking. */
 function antigravityClaudeThinkingBudget(effort: CallOptions["reasoningEffort"]): number | undefined {
   switch (effort) {
+    case "minimal": return 2000;
     case "low": return 4000;
     case "medium": return 10000;
     case "high": return 24000;

package/src/ai/providers/gemini.ts

@@ -24,14 +24,15 @@ export function geminiThinkingBudget(model: string, effort?: CallOptions["reason
   const floor = m.includes("pro") ? 128 : 0; // pro-class cannot fully disable thinking
   let budget: number;
   switch (effort) {
+    // minimal/low/medium/high ALL enable thinking with scaling depth — reasoning works at
+    // every thinking level (gajae parity: Minimal is a real effort). Only an UNSET effort
+    // falls through to the floor (off for flash-class, the API minimum for pro-class).
+    case "minimal": budget = Math.max(floor, 2000); break;
     case "low": budget = 4000; break;
     case "medium": budget = 10000; break;
     case "high": budget = 24000; break;
-    case "minimal":
     default: budget = floor;
   }
-  // Thought tokens bill against maxOutputTokens: keep at least ~1K of the output
-  // budget for visible text, or thinking starves the reply to an empty MAX_TOKENS.
   if (typeof maxTokens === "number") budget = Math.min(budget, Math.max(floor, maxTokens - 1024));
   return budget;
 }

package/src/ai/providers/openai-compatible-catalog.ts

@@ -25,32 +25,39 @@ export interface OpenAICompatProviderDef {
   readonly defaultModel: string;
   /** Wire protocol: "openai" (/chat/completions, default) or "anthropic" (/v1/messages). */
   readonly protocol?: "openai" | "anthropic";
+  /** True for subscription/plan products (coding-plan, portal, token-plan, code) rather than
+   *  pay-per-token APIs. Surfaced under the `/provider` "OAuth / subscription" onboarding path. */
+  readonly subscription?: boolean;
+  /** gjc-parity native-reasoning enablement: how this backend turns thinking ON.
+   *  "openrouter" → `reasoning:{effort}`; "qwen" → `enable_thinking:true`; "zai" →
+   *  `thinking:{type:"enabled"}`. Omitted → OpenAI `reasoning_effort` (o/gpt-5 only). */
+  readonly thinkingFormat?: "openai" | "openrouter" | "qwen" | "zai";
 }
 
 export const OPENAI_COMPAT_PROVIDERS: readonly OpenAICompatProviderDef[] = [
   { name: "groq", label: "Groq", baseUrl: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY", defaultModel: "groq/llama-3.3-70b-versatile" },
   { name: "deepseek", label: "DeepSeek", baseUrl: "https://api.deepseek.com/v1", apiKeyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek/deepseek-chat" },
   { name: "mistral", label: "Mistral", baseUrl: "https://api.mistral.ai/v1", apiKeyEnv: "MISTRAL_API_KEY", defaultModel: "mistral/mistral-large-latest" },
-  { name: "openrouter", label: "OpenRouter", baseUrl: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY", defaultModel: "openrouter/openai/gpt-4o-mini" },
+  { name: "openrouter", label: "OpenRouter", baseUrl: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY", defaultModel: "openrouter/openai/gpt-4o-mini", thinkingFormat: "openrouter" },
   { name: "together", label: "Together", baseUrl: "https://api.together.xyz/v1", apiKeyEnv: "TOGETHER_API_KEY", defaultModel: "together/meta-llama/Llama-3.3-70B-Instruct-Turbo" },
   { name: "cerebras", label: "Cerebras", baseUrl: "https://api.cerebras.ai/v1", apiKeyEnv: "CEREBRAS_API_KEY", defaultModel: "cerebras/llama-3.3-70b" },
   { name: "fireworks", label: "Fireworks", baseUrl: "https://api.fireworks.ai/inference/v1", apiKeyEnv: "FIREWORKS_API_KEY", defaultModel: "fireworks/accounts/fireworks/models/llama-v3p3-70b-instruct" },
   { name: "nvidia", label: "NVIDIA", baseUrl: "https://integrate.api.nvidia.com/v1", apiKeyEnv: "NVIDIA_API_KEY", defaultModel: "nvidia/meta/llama-3.3-70b-instruct" },
   // Additional gjc-parity OpenAI-compatible clouds (authoritative base URLs + env vars).
-  { name: "alibaba-coding-plan", label: "Alibaba Coding Plan", baseUrl: "https://coding-intl.dashscope.aliyuncs.com/v1", apiKeyEnv: "ALIBABA_CODING_PLAN_API_KEY", defaultModel: "alibaba-coding-plan/qwen3.5-plus" },
+  { name: "alibaba-coding-plan", label: "Alibaba Coding Plan", baseUrl: "https://coding-intl.dashscope.aliyuncs.com/v1", apiKeyEnv: "ALIBABA_CODING_PLAN_API_KEY", defaultModel: "alibaba-coding-plan/qwen3.5-plus", subscription: true, thinkingFormat: "qwen" },
   { name: "huggingface", label: "Hugging Face", baseUrl: "https://router.huggingface.co/v1", apiKeyEnv: "HF_TOKEN", defaultModel: "huggingface/deepseek-ai/DeepSeek-R1" },
   { name: "nanogpt", label: "NanoGPT", baseUrl: "https://nano-gpt.com/api/v1", apiKeyEnv: "NANO_GPT_API_KEY", defaultModel: "nanogpt/openai/gpt-5.4" },
-  { name: "qwen-portal", label: "Qwen Portal", baseUrl: "https://portal.qwen.ai/v1", apiKeyEnv: "QWEN_PORTAL_API_KEY", defaultModel: "qwen-portal/coder-model" },
+  { name: "qwen-portal", label: "Qwen Portal", baseUrl: "https://portal.qwen.ai/v1", apiKeyEnv: "QWEN_PORTAL_API_KEY", defaultModel: "qwen-portal/coder-model", subscription: true, thinkingFormat: "qwen" },
   { name: "synthetic", label: "Synthetic", baseUrl: "https://api.synthetic.new/openai/v1", apiKeyEnv: "SYNTHETIC_API_KEY", defaultModel: "synthetic/hf:moonshotai/Kimi-K2.5" },
   { name: "venice", label: "Venice", baseUrl: "https://api.venice.ai/api/v1", apiKeyEnv: "VENICE_API_KEY", defaultModel: "venice/llama-3.3-70b" },
   { name: "zenmux", label: "ZenMux", baseUrl: "https://zenmux.ai/api/v1", apiKeyEnv: "ZENMUX_API_KEY", defaultModel: "zenmux/anthropic/claude-opus-4.6" },
   { name: "qianfan", label: "Qianfan", baseUrl: "https://qianfan.baidubce.com/v2", apiKeyEnv: "QIANFAN_API_KEY", defaultModel: "qianfan/deepseek-v3.2" },
   { name: "xiaomi", label: "Xiaomi", baseUrl: "https://api.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_API_KEY", defaultModel: "xiaomi/mimo-v2-flash" },
-  { name: "xiaomi-token-plan-ams", label: "Xiaomi Token Plan (Europe)", baseUrl: "https://token-plan-ams.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_AMS_API_KEY", defaultModel: "xiaomi-token-plan-ams/mimo-v2.5" },
-  { name: "xiaomi-token-plan-cn", label: "Xiaomi Token Plan (China)", baseUrl: "https://token-plan-cn.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_CN_API_KEY", defaultModel: "xiaomi-token-plan-cn/mimo-v2.5" },
-  { name: "xiaomi-token-plan-sgp", label: "Xiaomi Token Plan (Singapore)", baseUrl: "https://token-plan-sgp.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_SGP_API_KEY", defaultModel: "xiaomi-token-plan-sgp/mimo-v2.5" },
-  { name: "minimax-code", label: "MiniMax Code", baseUrl: "https://api.minimax.io/v1", apiKeyEnv: "MINIMAX_CODE_API_KEY", defaultModel: "minimax-code/minimax-m3" },
-  { name: "minimax-code-cn", label: "MiniMax Code (China)", baseUrl: "https://api.minimaxi.com/v1", apiKeyEnv: "MINIMAX_CODE_CN_API_KEY", defaultModel: "minimax-code-cn/minimax-m3" },
+  { name: "xiaomi-token-plan-ams", label: "Xiaomi Token Plan (Europe)", baseUrl: "https://token-plan-ams.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_AMS_API_KEY", defaultModel: "xiaomi-token-plan-ams/mimo-v2.5", subscription: true },
+  { name: "xiaomi-token-plan-cn", label: "Xiaomi Token Plan (China)", baseUrl: "https://token-plan-cn.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_CN_API_KEY", defaultModel: "xiaomi-token-plan-cn/mimo-v2.5", subscription: true },
+  { name: "xiaomi-token-plan-sgp", label: "Xiaomi Token Plan (Singapore)", baseUrl: "https://token-plan-sgp.xiaomimimo.com/v1", apiKeyEnv: "XIAOMI_TOKEN_PLAN_SGP_API_KEY", defaultModel: "xiaomi-token-plan-sgp/mimo-v2.5", subscription: true },
+  { name: "minimax-code", label: "MiniMax Code", baseUrl: "https://api.minimax.io/v1", apiKeyEnv: "MINIMAX_CODE_API_KEY", defaultModel: "minimax-code/minimax-m3", subscription: true },
+  { name: "minimax-code-cn", label: "MiniMax Code (China)", baseUrl: "https://api.minimaxi.com/v1", apiKeyEnv: "MINIMAX_CODE_CN_API_KEY", defaultModel: "minimax-code-cn/minimax-m3", subscription: true },
   // Anthropic-Messages-protocol providers (served via makeAnthropicCompatibleAdapter).
   { name: "zai", label: "z.ai", baseUrl: "https://api.z.ai/api/anthropic", apiKeyEnv: "ZAI_API_KEY", defaultModel: "zai/glm-5.2", protocol: "anthropic" },
   { name: "minimax", label: "MiniMax", baseUrl: "https://api.minimax.io/anthropic", apiKeyEnv: "MINIMAX_API_KEY", defaultModel: "minimax/minimax-m3", protocol: "anthropic" },
@@ -61,6 +68,10 @@ const BY_NAME = new Map<string, OpenAICompatProviderDef>(OPENAI_COMPAT_PROVIDERS
 /** All catalog provider names (for PROVIDER_NAMES / AuthProvider unions). */
 export const OPENAI_COMPAT_NAMES: readonly ProviderName[] = OPENAI_COMPAT_PROVIDERS.map(p => p.name);
 
+/** Subscription/plan-tier provider names (coding-plan, portal, token-plan, code) — surfaced
+ *  under the `/provider` "OAuth / subscription" onboarding path rather than the generic API-key list. */
+export const SUBSCRIPTION_PROVIDER_NAMES: readonly ProviderName[] = OPENAI_COMPAT_PROVIDERS.filter(p => p.subscription).map(p => p.name);
+
 /** Catalog entry for a provider name, or undefined when it is not catalog-driven. */
 export function openaiCompatDef(name: string): OpenAICompatProviderDef | undefined {
   return BY_NAME.get(name);

package/src/ai/providers/openai-compatible.ts

@@ -12,12 +12,15 @@ import { openaiAdapter } from "./openai";
  */
 const KEYLESS: Credential = { kind: "none", provider: "openai" };
 
-export function makeOpenAICompatibleAdapter(opts: { name: ProviderName; baseUrl: string; keyless?: boolean }): ProviderAdapter {
+export function makeOpenAICompatibleAdapter(opts: { name: ProviderName; baseUrl: string; keyless?: boolean; thinkingFormat?: CallOptions["reasoningFormat"] }): ProviderAdapter {
   const prefix = `${opts.name}/`;
   const prep = (o: CallOptions): CallOptions => ({
     ...o,
     model: o.model.startsWith(prefix) ? o.model.slice(prefix.length) : o.model,
     baseUrl: o.baseUrl ?? opts.baseUrl,
+    // Carry the backend's native-reasoning enablement so openaiRequest can turn thinking
+    // on with the right param (gjc parity) — without it OpenRouter/Qwen models stay silent.
+    reasoningFormat: o.reasoningFormat ?? opts.thinkingFormat,
   });
   const credFor = (c: Credential): Credential => (opts.keyless ? KEYLESS : c);
   return {

package/src/ai/providers/openai-responses.ts

@@ -76,6 +76,17 @@ export function codexResponsesRequest(
     // frame can show the model's thinking instead of a frozen "calling model (Ns)…".
     payload.reasoning = { effort: options.reasoningEffort, summary: "auto" };
   }
+  // OAuth → the undocumented ChatGPT/Codex backend (codex headers + account-id).
+  // API key → the public OpenAI Responses API (`/v1/responses`) with a plain Bearer.
+  // Both speak the same Responses schema (the body above), so only url+headers differ.
+  if (credential.kind === "api_key") {
+    const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+    return {
+      url: `${base}/responses`,
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}`, accept: "text/event-stream" },
+      body: JSON.stringify(payload),
+    };
+  }
   const accountId = extractChatgptAccountId(token);
   const headers: Record<string, string> = {
     "content-type": "application/json",

package/src/ai/providers/openai.ts

@@ -6,6 +6,36 @@ import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 import { createThinkSplitter } from "../think-tags";
 
+/** True for OpenAI reasoning models (o-series + gpt-5+ family). Digit-count agnostic
+ *  (gpt-6/o10 stay reasoning). Strips the `openai/` routing prefix first. */
+export function isOpenAIReasoningModel(model: string): boolean {
+  const m = model.startsWith("openai/") ? model.slice(7) : model;
+  const gptMajor = m.match(/^gpt-(\d+)/);
+  return /^o\d/.test(m) || (gptMajor ? Number(gptMajor[1]) >= 5 : false);
+}
+
+/** gjc-parity: write the backend-specific param that turns NATIVE reasoning ON, so the
+ *  model streams thinking we can surface. Mutates `payload`. "openai" needs no param here
+ *  (handled by `reasoning_effort` for true o-series/gpt-5 models). */
+export function applyCompatThinking(
+  payload: Record<string, unknown>,
+  format: CallOptions["reasoningFormat"],
+  effort: NonNullable<CallOptions["reasoningEffort"]>,
+): void {
+  switch (format) {
+    case "openrouter":
+      payload.reasoning = { effort };
+      break;
+    case "qwen":
+      payload.enable_thinking = true;
+      break;
+    case "zai":
+      payload.thinking = { type: "enabled" };
+      break;
+    // "openai" / undefined: no extra param (reasoning_effort path covers real OpenAI models).
+  }
+}
+
 export function openaiRequest(messages: Message[], options: CallOptions, credential: Credential, stream: boolean): { url: string; headers: Record<string, string>; body: string } {
   const model = options.model.startsWith("openai/") ? options.model.slice(7) : options.model;
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
@@ -26,8 +56,7 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
   // Reasoning models (o-series, gpt-5+ family) take max_completion_tokens + reasoning_effort
   // and reject temperature; classic chat models (gpt-4o, …) take max_tokens + temperature.
   // Digit-count agnostic (gpt-6/o10 stay reasoning) — mirrors inferCatalogMetadata.
-  const gptMajorMatch = model.match(/^gpt-(\d+)/);
-  const isReasoning = /^o\d/.test(model) || (gptMajorMatch ? Number(gptMajorMatch[1]) >= 5 : false);
+  const isReasoning = isOpenAIReasoningModel(model);
   const payload: Record<string, unknown> = {
     model,
     messages: openaiMessages,
@@ -39,6 +68,13 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
     payload.temperature = options.temperature ?? 0.2;
     payload.max_tokens = options.maxTokens ?? 4000;
   }
+  // gjc parity — enable NATIVE reasoning per the backend's thinking format so the model
+  // actually emits reasoning (otherwise OpenRouter/Qwen/z.ai stay silent and the TUI has
+  // nothing to show). `reasoning_effort` (OpenAI-style) only suits o-series/gpt-5; other
+  // backends need their own param. Gated on a requested effort (off → no thinking).
+  if (options.reasoningEffort && !isReasoning) {
+    applyCompatThinking(payload, options.reasoningFormat, options.reasoningEffort);
+  }
   if (stream) {
     payload.stream = true;
     payload.stream_options = { include_usage: true };
@@ -65,12 +101,56 @@ function emptyCompletionError(finishReason: string | undefined): Error {
   return new Error(`OpenAI returned no content${finishReason ? ` (finish_reason=${finishReason})` : ""}${hint}.`);
 }
 
+/** A streamed `choices[].delta`. `reasoning` is `unknown` because OpenAI-compatible
+ *  servers disagree on its shape: a plain string (OpenRouter/xAI), an object
+ *  `{ text|content }`, or absent (the `reasoning_details[]` array carries it instead). */
+export interface OpenAIDelta {
+  content?: string;
+  reasoning_content?: string;
+  reasoning_text?: string;
+  reasoning?: unknown;
+  reasoning_details?: { text?: string; content?: string }[];
+  tool_calls?: { index?: number; function?: { name?: string; arguments?: string } }[];
+}
+
+/** Pull a reasoning-text delta out of the many OpenAI-compatible shapes. Returns the
+ *  first non-empty of: `reasoning_content`, `reasoning_text`, a string/`{text|content}`
+ *  `reasoning`, or the concatenated `reasoning_details[].text|content`. */
+export function reasoningDeltaOf(delta: OpenAIDelta | undefined): string | undefined {
+  if (!delta) return undefined;
+  if (typeof delta.reasoning_content === "string" && delta.reasoning_content) return delta.reasoning_content;
+  if (typeof delta.reasoning_text === "string" && delta.reasoning_text) return delta.reasoning_text;
+  const r = delta.reasoning;
+  if (typeof r === "string" && r) return r;
+  if (r && typeof r === "object") {
+    const o = r as { text?: unknown; content?: unknown };
+    if (typeof o.text === "string" && o.text) return o.text;
+    if (typeof o.content === "string" && o.content) return o.content;
+  }
+  if (Array.isArray(delta.reasoning_details)) {
+    const t = delta.reasoning_details
+      .map(x => (typeof x?.text === "string" ? x.text : typeof x?.content === "string" ? x.content : ""))
+      .join("");
+    if (t) return t;
+  }
+  return undefined;
+}
+
 export const openaiAdapter: ProviderAdapter = {
   name: "openai",
   supportsNativeTools: true,
   async call(messages, options, credential) {
     // ChatGPT/Codex OAuth can't use /chat/completions — route to the Codex Responses backend.
     if (credential.kind === "oauth") return codexResponsesCall(messages, options, credential);
+    // OpenAI reasoning models (o-series/gpt-5) expose reasoning ONLY via the Responses
+    // API — /chat/completions hides it. Use Responses for a real-OpenAI API key (no
+    // custom baseUrl); OpenAI-compatible servers (groq/xai/lmstudio/… set baseUrl) keep
+    // the chat path + reasoning_content. Fall back to chat if /responses is unavailable.
+    if (credential.kind === "api_key" && !options.baseUrl && isOpenAIReasoningModel(options.model)) {
+      try {
+        return await codexResponsesCall(messages, options, credential);
+      } catch { /* /responses unsupported for this model/account — fall through to chat */ }
+    }
     const { url, headers, body } = openaiRequest(messages, options, credential, false);
     const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("OpenAI", response);
@@ -88,6 +168,18 @@ export const openaiAdapter: ProviderAdapter = {
       yield* codexResponsesStream(messages, options, credential);
       return;
     }
+    // OpenAI reasoning models surface reasoning only via Responses (see call()). Pre-stream
+    // fallback: if it fails before any chunk, retry on chat completions (no regression).
+    if (credential.kind === "api_key" && !options.baseUrl && isOpenAIReasoningModel(options.model)) {
+      let started = false;
+      try {
+        for await (const chunk of codexResponsesStream(messages, options, credential)) { started = true; yield chunk; }
+        return;
+      } catch (e) {
+        if (started) throw e; // mid-stream failure — cannot safely restart on another endpoint
+        // else fall through to chat completions below
+      }
+    }
     const { url, headers, body } = openaiRequest(messages, options, credential, true);
     let response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (response.status === 400) {
@@ -110,7 +202,7 @@ export const openaiAdapter: ProviderAdapter = {
     const think = createThinkSplitter(options.onReasoning);
     const toolAcc = new Map<number, { name: string; args: string }>();
     for await (const data of readSse(response.body)) {
-      let chunk: { choices?: { delta?: { content?: string; reasoning_content?: string; reasoning?: string; reasoning_text?: string; tool_calls?: { index?: number; function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
+      let chunk: { choices?: { delta?: OpenAIDelta; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
       try {
         chunk = JSON.parse(data);
       } catch {
@@ -124,10 +216,10 @@ export const openaiAdapter: ProviderAdapter = {
           yield visible;
         }
       }
-      // Structured reasoning channel (DeepSeek `reasoning_content`, OpenRouter/xAI
-      // `reasoning`): a SEPARATE field from content, so it bypasses the <think> splitter.
-      const d = chunk.choices?.[0]?.delta;
-      const reason = d?.reasoning_content ?? d?.reasoning ?? d?.reasoning_text;
+      // Structured reasoning channel (separate from `content`, so it bypasses the
+      // <think> splitter): handles string fields, an object `reasoning`, and the
+      // `reasoning_details[]` array form (OpenRouter/xAI/DeepSeek variants).
+      const reason = reasoningDeltaOf(chunk.choices?.[0]?.delta);
       if (reason) options.onReasoning?.(reason);
       const tcs = chunk.choices?.[0]?.delta?.tool_calls;
       if (tcs) {

package/src/ai/register-providers.ts

@@ -34,6 +34,6 @@ providerRegistry.register("kimi", kimiAdapter);
 for (const def of OPENAI_COMPAT_PROVIDERS) {
   const adapter = def.protocol === "anthropic"
     ? makeAnthropicCompatibleAdapter({ name: def.name, baseUrl: def.baseUrl })
-    : makeOpenAICompatibleAdapter({ name: def.name, baseUrl: def.baseUrl });
+    : makeOpenAICompatibleAdapter({ name: def.name, baseUrl: def.baseUrl, thinkingFormat: def.thinkingFormat });
   providerRegistry.register(def.name, adapter);
 }

package/src/ai/types.ts

@@ -55,6 +55,11 @@ export interface CallOptions {
   signal?: AbortSignal;
   /** Reasoning effort for reasoning models (o-series / gpt-5), mapped from thinkingLevel. */
   reasoningEffort?: "minimal" | "low" | "medium" | "high";
+  /** How an OpenAI-compatible backend enables/streams native reasoning (gjc parity):
+   *  "openai" → `reasoning_effort`; "openrouter" → `reasoning: {effort}`; "qwen" →
+   *  `enable_thinking: true`; "zai" → `thinking: {type:"enabled"}`. Set per provider by
+   *  the openai-compatible factory; without it a model never emits reasoning to surface. */
+  reasoningFormat?: "openai" | "openrouter" | "qwen" | "zai";
   /** Notified before each auto-retry backoff wait (rate limits / transient errors).
    *  NOT forwarded to provider adapters — consumed by the manager's retry layer. */
   onRetry?: (attempt: number, err: unknown, delayMs: number) => void;

package/src/commands/auth.ts

@@ -16,6 +16,7 @@ import {
   snapshotProvider,
   setApiKey,
   isOAuthProvider,
+  OAUTH_PROVIDERS,
   API_KEY_ONLY_PROVIDERS,
   type AuthProvider,
   type OAuthController,
@@ -32,7 +33,8 @@ export async function runAuthCommand(args: string[]): Promise<void> {
   process.exitCode = 1;
 }
 
-const CLOUD_PROVIDERS: readonly AuthProvider[] = ["anthropic", "openai", "gemini", "antigravity", "xai", "kimi"];
+// Every loginable provider: OAuth-capable ∪ API-key-only (keyless ollama/lmstudio excluded).
+const CLOUD_PROVIDERS: readonly AuthProvider[] = [...OAUTH_PROVIDERS, ...API_KEY_ONLY_PROVIDERS];
 /** True (and prints an error + sets exit code) when `p` is given but not a known provider. */
 function rejectInvalidProvider(p: string | undefined): boolean {
   if (p !== undefined && !(CLOUD_PROVIDERS as readonly string[]).includes(p)) {
@@ -56,7 +58,7 @@ async function runAuthStatus(): Promise<void> {
   const cfg = await readGlobalConfig();
   console.log("\n=== jeo auth status ===");
   console.log("Provider     API key   OAuth");
-  for (const p of ["anthropic", "openai", "gemini", "antigravity", "xai", "kimi"] as AuthProvider[]) {
+  for (const p of CLOUD_PROVIDERS) {
     const snap = await snapshotProvider(p);
     const key = p === "antigravity" ? "—" : (snap.apiKey ? "set" : "—");
     let oauth = "—";