jeo-code 0.6.22 → 0.6.24

package/src/commands/launch.ts

@@ -17,10 +17,10 @@ import { runUltragoalEngine, type UltragoalEngineOptions } from "./ultragoal";
 import { skillsPromptSection, loadSkills, buildSkillTask, workflowSkillsForPrompt, parseSkillInvocation, parseSkillChain, looksLikeSkillEcho, skillInvocationCard, type SkillDoc, type SkillInvocation } from "../skills/catalog";
 import { formatForgeBox } from "../tui/components/forge";
 import { interactiveOAuthLogin } from "./auth";
-import { logoutOAuth } from "../auth";
+import { logoutOAuth, OAUTH_PROVIDERS, API_KEY_ONLY_PROVIDERS, setApiKey } from "../auth";
 import type { AuthProvider } from "../auth";
 import { matchSlash, isSlashAttempt, suggestSlashCommands, formatSlashCommandList, formatSlashPreview, slashPreviewMatches, activeTriggerToken, tabCompleteSelection, type SlashCommandInfo } from "../tui/components/slash";
-import { staticCompletionContext, readlineCompleter, formatCompletionPreview, tokenize, type CompletionContext } from "../tui/components/autocomplete";
+import { staticCompletionContext, readlineCompleter, formatCompletionPreview, formatMidTurnHint, tokenize, type CompletionContext } from "../tui/components/autocomplete";
 import { normalizeBaseUrl } from "./setup-helpers";
 import { EVOLUTION_STAGES, animateAsciiArt } from "../tui/components/ascii-art";
 import { getEvolutionTip } from "../tui/components/evolution";
@@ -41,6 +41,7 @@ import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLev
 import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../agent/goal-verifier";
 
 import { listAliases } from "../ai/model-registry";
+import { openaiCompatDef, SUBSCRIPTION_PROVIDER_NAMES } from "../ai/providers/openai-compatible-catalog";
 
 import { allSubagentRoles, getSubagentRole, resolveSubagentModel, resolveSubagentMaxSteps, resolveSubagentThinking, parseMaxSteps, withSubagentSetting, clearSubagentSetting } from "../agent/subagents";
 import { SelectList, renderSelectList, type SelectItem } from "../tui/components/select-list";
@@ -57,7 +58,7 @@ import {
 } from "../tui/components/config-panel";
 import { liveModelPicker, renderLiveModelPicker, type ModelAssignmentBadge } from "../tui/components/live-model-picker";
 
-import { providerPicker, renderProviderPicker } from "../tui/components/provider-picker";
+import { loginPicker, renderLoginPicker, onboardingPicker, renderOnboardingPicker, apiKeyPicker, renderApiKeyPicker, subscriptionLoginPicker, type OnboardingAction } from "../tui/components/provider-picker";
 import { detectLanguage, languageLabel, parseLineRange, sliceLines, formatCodeBlock, formatDiff, sanitizeForTerminal } from "../tui/components/code-view";
 import { categoryBadge } from "../tui/components/category-index";
 import { renderInputFrame, verticalCursorOffset } from "../tui/components/input-box";
@@ -134,6 +135,7 @@ import {
   captureLivePromptInputChunk,
   restoreQueuedLinesToPrefill,
   createInFlightAbortHarness,
+  classifyMidTurnLine,
 } from "./launch/input";
 import {
   gatedStdout,
@@ -198,6 +200,7 @@ export {
   captureLivePromptInputChunk,
   restoreQueuedLinesToPrefill,
   createInFlightAbortHarness,
+  classifyMidTurnLine,
 
   gatedStdout,
   formatTaskSubEvent,
@@ -211,7 +214,10 @@ export {
   currentAtLabelFn as currentAtLabel,
 };
 export function normalizeSlashAlias(input: string): string {
-  if (input === "/login" || input.startsWith("/login ")) return `/provider login${input.slice("/login".length)}`;
+  // gjc-parity: bare `/login` opens the provider onboarding selector (same as bare
+  // `/provider`); `/login <provider|args>` is the direct OAuth-login alias.
+  if (input === "/login") return "/provider";
+  if (input.startsWith("/login ")) return `/provider login${input.slice("/login".length)}`;
   if (input === "/settings") return "/config";
   if (input === "/subagent" || input.startsWith("/subagent ")) return `/agents${input.slice("/subagent".length)}`;
   if (input === "/subagents" || input.startsWith("/subagents ")) return `/agents${input.slice("/subagents".length)}`;
@@ -219,7 +225,12 @@ export function normalizeSlashAlias(input: string): string {
   return input;
 }
 
-const PROVIDER_DEFAULT: Record<ProviderName, string> = { anthropic: "sonnet", openai: "gpt-5.5", gemini: "flash", antigravity: "antigravity/gemini-3-pro-high", ollama: "fast" };
+// Per-provider starting model for `--provider <name>` / role pinning. Catalog
+// OpenAI-compatible providers supply their own default; built-ins use this map.
+const STATIC_PROVIDER_DEFAULT: Partial<Record<ProviderName, string>> = { anthropic: "sonnet", openai: "gpt-5.5", gemini: "flash", antigravity: "antigravity/gemini-3-pro-high", ollama: "fast", lmstudio: "lmstudio/local-model", xai: "grok-4.3", kimi: "kimi-k2-0711-preview" };
+function providerDefaultModel(p: ProviderName): string {
+  return openaiCompatDef(p)?.defaultModel ?? STATIC_PROVIDER_DEFAULT[p] ?? "";
+}
 
 
 export function formatResumeHint(sessionId: string): string {
@@ -263,7 +274,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const defaultModel = cfg.defaultModel;
   const initialSessionModel =
     flags.model ??
-    (flags.modelRole ? resolveRoleModel(flags.modelRole, cfg) : flags.provider ? PROVIDER_DEFAULT[flags.provider] : undefined);
+    (flags.modelRole ? resolveRoleModel(flags.modelRole, cfg) : flags.provider ? providerDefaultModel(flags.provider) : undefined);
   if (flags.provider && initialSessionModel) {
     const { provider } = await describeModel(initialSessionModel);
     if (provider !== flags.provider) {
@@ -472,6 +483,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // Full untruncated output of the most recent tool call — the clipped forge
   // card's `⟦Ctrl+O for more⟧` hint resolves here.
   let lastToolDetail: { tool: string; output: string } | null = null;
+  // Accumulated reasoning/thinking for the in-flight turn (the model's thought before its
+  // answer). Captured from the reasoning stream and persisted on the assistant message so
+  // it survives /resume + export (gjc "think → answer" record). Reset at each turn start.
+  let lastTurnReasoning = "";
   /** Wrap turn events so EVERY sink (TUI or plain stream) records the last full
    *  tool output for the Ctrl+O detail view. */
   const withToolDetailCapture = (base: ReturnType<LaunchTui["events"]>): ReturnType<LaunchTui["events"]> => ({
@@ -480,6 +495,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       lastToolDetail = { tool, output };
       base.onToolResult?.(tool, success, output);
     },
+    onReasoningStream: (textSoFar: string) => {
+      // textSoFar is the cumulative thought for the current step; keep the latest
+      // non-empty value (the thought immediately preceding the turn's answer).
+      if (textSoFar.trim()) lastTurnReasoning = textSoFar;
+      base.onReasoningStream?.(textSoFar);
+    },
   });
   /** Compose a session-persistence flush into onStep so each completed step is
    *  written as it lands (durability across mid-turn interruption) without
@@ -547,6 +568,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // Clears the live next-prompt draft — used after a mid-turn Enter is lifted into
   // the steering inbox so the consumed line does not also become the next prompt.
   let queueBusyClear: (() => void) | undefined;
+  // Routes a command-shaped (/… or $…) mid-turn draft into the idle loop's
+  // pending-line queue so it runs as a real COMMAND at the turn boundary,
+  // instead of being steered into the model as literal text.
+  let queueBusyCommand: ((line: string) => void) | undefined;
   let interactiveTurnActive = false;
 
 
@@ -577,6 +602,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // AFTER compaction (which mutates history) and consumed by the post-turn
     // persistence block below.
     let beforeLen = history.length;
+    lastTurnReasoning = ""; // fresh turn: capture this turn's thinking from scratch
     // Incremental session persistence (durability across mid-turn interruption):
     // persistTurnTail() flushes history messages added since the last flush — called
     // right after the user prompt, on every onStep boundary, and once post-turn — so
@@ -675,12 +701,34 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           if (typedEnter) {
             const line = (queueBusySnapshot?.().text ?? "").trim();
             if (line) {
-              steerInbox.push(line);
+              // A mid-turn /command or $skill is NOT a query for the model — steering it
+              // would send the literal "/model" / "$skill" text to the LLM. Recognize it
+              // and run it as a real COMMAND: queue it for the idle dispatcher and stop the
+              // turn so it runs at once (below). Plain queries still steer into the running
+              // turn. JEO_NO_STEER=1 disables both (legacy draft-only).
               queueBusyClear?.();
               tui.setLivePromptInput("");
-              // Surface the steered query as a `user` card in scrollback so it reads
-              // as an accepted input that started work — not just a transient notice.
-              tui.flushSteerCard(line);
+              tui.setLivePromptHint([]);
+              if (classifyMidTurnLine(line) === "command") {
+                // Run it as a real COMMAND: queue it for immediate dispatch by the prompt
+                // loop and abort the turn (the same controller Esc uses). The abort ends a
+                // streaming turn at once and cancels any further steps; a running tool still
+                // finishes first (jeo's abort is step-level, like Esc). The queued command is
+                // then auto-dispatched — no second Enter. JEO_NO_MIDTURN_DISPATCH=1 keeps the
+                // legacy behavior (queue to prefill, no interrupt, press Enter to run).
+                queueBusyCommand?.(line);
+                if (jeoEnv("NO_MIDTURN_DISPATCH") === "1") {
+                  tui.events().onNotice?.(`⌘ queued ${line} — press Enter after this turn to run`);
+                } else {
+                  tui.events().onNotice?.(`⌘ ${line} — interrupting the turn to run it`);
+                  harness.controller.abort();
+                }
+              } else {
+                steerInbox.push(line);
+                // Surface the steered query as a `user` card in scrollback so it reads
+                // as an accepted input that started work — not just a transient notice.
+                tui.flushSteerCard(line);
+              }
               return;
             }
           }
@@ -691,7 +739,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           // suppressed for the whole turn). On Enter the draft is lifted into the steering
           // inbox and surfaces as a `user` card (above). JEO_NO_LIVE_DRAFT=1 opts out.
           if (captured && jeoEnv("NO_LIVE_DRAFT") !== "1") {
-            tui.setLivePromptInput(queueBusySnapshot?.().text ?? "");
+            const draft = queueBusySnapshot?.().text ?? "";
+            tui.setLivePromptInput(draft);
+            // Mid-turn command preview: as you type a /command or $skill DURING a turn,
+            // show its matches above the input box so command input visibly reacts
+            // (idle-prompt parity). Cleared the moment the draft stops being command-shaped.
+            tui.setLivePromptHint(
+              /^\s*[/$]/.test(draft) ? formatMidTurnHint(draft.trimStart(), completionContext(), 5) : [],
+            );
           }
         },
         onAbortNotice: msg => {
@@ -851,8 +906,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // this only covers the tail — net content is the full turn either way.
     try {
       await persistTurnTail();
-      history.push({ role: "assistant", content: reply });
-      if (sessionId) await appendMessage(sessionId, { role: "assistant", content: reply }, cwd);
+      const assistantMsg: Message = lastTurnReasoning.trim()
+        ? { role: "assistant", content: reply, reasoning: lastTurnReasoning }
+        : { role: "assistant", content: reply };
+      history.push(assistantMsg);
+      if (sessionId) await appendMessage(sessionId, assistantMsg, cwd);
       if (tui) tui.finish(reply);
     } finally {
       if (tui) interactiveTurnActive = false;
@@ -1038,7 +1096,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // gjc-style fresh-start clear so the banner opens atop a clean screen. TTY only,
   // never mid-turn (scrollback flood). ponytail: add an opt-out env if anyone misses their scrollback.
   if (process.stdout.isTTY) process.stdout.write(clearScreen());
-  // Launch sweep: the DNA Claw's gradient loops seamlessly (default 2 full
+  // Launch sweep: the forge mark's gradient loops seamlessly (default 2 full
   // cycles, JEO_WELCOME_ANIM_CYCLES overrides), ending on the static banner.
   // Truecolor TTYs only; JEO_NO_WELCOME_ANIM=1 opts out.
   const sweepable =
@@ -1356,6 +1414,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // only captures the line submitted while it is registered; orphan lines emit
   // 'line' instead), so queue those and serve them before prompting again.
   const pendingStdinLines: string[] = [];
+  // Commands submitted mid-turn (/… or $…) land here; the prompt loop dispatches them
+  // IMMEDIATELY on its next iteration, bypassing the "new input first" prefill contract
+  // (the user explicitly invoked them — no second Enter).
+  const pendingMidTurnCommands: string[] = [];
   const queuedPromptInput: PromptInputQueue = { pendingLines: pendingStdinLines, partial: "", pastedLines: [], inPaste: false };
   queueBusyInput = (chunk: string) => captureLivePromptInputChunk(queuedPromptInput, chunk);
   queueBusyPasteActive = () => queuedPromptInput.inPaste;
@@ -1363,6 +1425,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     text: queuedPromptInput.partial,
   });
   queueBusyClear = () => { queuedPromptInput.partial = ""; };
+  queueBusyCommand = (line: string) => {
+    // NO_MIDTURN_DISPATCH=1 keeps the legacy prefill path (tee up, press Enter); the
+    // default routes to the immediate-dispatch queue served at the top of the loop.
+    (jeoEnv("NO_MIDTURN_DISPATCH") === "1" ? pendingStdinLines : pendingMidTurnCommands).push(line);
+  };
   // Bracketed-paste line routing at the PROMPT: readline strips the 2004 markers
   // and replays pasted lines as synthetic keypresses, emitting paste-start /
   // paste-end around them. Lines submitted INSIDE that window are intentional
@@ -2142,13 +2209,112 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
 
   const pickCloudProvider = async (statuses: Awaited<ReturnType<typeof describeAllProviders>>): Promise<AuthProvider | undefined> => {
-    const cloud = new Set(["anthropic", "openai", "gemini", "antigravity"]);
-    const list = providerPicker(statuses.filter(s => cloud.has(s.name)), true);
+    const cloud = new Set<string>(OAUTH_PROVIDERS); // OAuth-login providers (anthropic/openai/gemini/antigravity)
+    const subs = new Set<string>(SUBSCRIPTION_PROVIDER_NAMES); // subscription/plan products (token-keyed)
+    const list = subscriptionLoginPicker(
+      statuses.filter(s => cloud.has(s.name)),
+      statuses.filter(s => subs.has(s.name)),
+      true,
+    );
+    let chosen: ProviderName | undefined;
+    await runSelectPicker(
+      (cols, rows) =>
+        renderLoginPicker(list, {
+          title: "Login with OAuth / subscription  ↑↓ move · Enter select · Esc cancel",
+          cols,
+          rows: Math.max(4, Math.min(rows, 8)),
+          unicode: true,
+          color: true,
+        }),
+      (ch, key) => {
+        if (key?.name === "up") {
+          list.up();
+          return false;
+        }
+        if (key?.name === "down") {
+          list.down();
+          return false;
+        }
+        if (key?.name === "pageup") {
+          list.page(-1, 4);
+          return false;
+        }
+        if (key?.name === "pagedown") {
+          list.page(1, 4);
+          return false;
+        }
+        if (key?.name === "backspace") {
+          list.backspace();
+          return false;
+        }
+        if (key?.name === "escape" || (key?.ctrl && key.name === "c")) {
+          return true;
+        }
+        if (key?.name === "return" || key?.name === "enter") {
+          chosen = list.selected()?.value;
+          return true;
+        }
+        if (ch && ch >= " " && !key?.ctrl && !key?.meta) {
+          list.typeChar(ch);
+        }
+        return false;
+      },
+    );
+    return chosen && (cloud.has(chosen) || subs.has(chosen)) ? chosen as AuthProvider : undefined;
+  };
+
+  // Bare `/provider` opens gjc's interactive onboarding selector: choose between
+  // OAuth/subscription login and registering an API-compatible endpoint. Returns the
+  // picked action, or undefined when cancelled (Esc/Ctrl+C). TTY only — callers fall
+  // back to the printed usage in non-interactive mode.
+  const pickOnboardingAction = async (): Promise<OnboardingAction | undefined> => {
+    const list = onboardingPicker(true);
+    let chosen: OnboardingAction | undefined;
+    await runSelectPicker(
+      (cols, rows) =>
+        renderOnboardingPicker(list, {
+          cols,
+          rows: Math.max(4, Math.min(rows, 6)),
+          unicode: true,
+          color: true,
+        }),
+      (ch, key) => {
+        if (key?.name === "up") {
+          list.up();
+          return false;
+        }
+        if (key?.name === "down") {
+          list.down();
+          return false;
+        }
+        if (key?.name === "escape" || (key?.ctrl && key.name === "c")) {
+          return true;
+        }
+        if (key?.name === "return" || key?.name === "enter") {
+          chosen = list.selected()?.value;
+          return true;
+        }
+        if (ch && ch >= " " && !key?.ctrl && !key?.meta) {
+          list.typeChar(ch);
+        }
+        return false;
+      },
+    );
+    return chosen;
+  };
+
+  // API-key onboarding: pick one of the bundled API-key-only providers (groq, deepseek,
+  // mistral, …) to store a key for. Returns the picked provider, or undefined on cancel.
+  // TTY only — the caller prints scriptable guidance otherwise.
+  const pickApiKeyProvider = async (statuses: Awaited<ReturnType<typeof describeAllProviders>>): Promise<AuthProvider | undefined> => {
+    const subs = new Set<string>(SUBSCRIPTION_PROVIDER_NAMES); // surfaced under OAuth/subscription login instead
+    const keyed = new Set<string>(API_KEY_ONLY_PROVIDERS);
+    const list = apiKeyPicker(statuses.filter(s => keyed.has(s.name) && !subs.has(s.name)), true);
     let chosen: ProviderName | undefined;
     await runSelectPicker(
       (cols, rows) =>
-        renderProviderPicker(list, {
-          title: "Select OAuth provider",
+        renderApiKeyPicker(list, {
+          title: "Select a provider to key  \u2191\u2193 move \u00b7 Enter select \u00b7 Esc cancel",
           cols,
           rows: Math.max(4, Math.min(rows, 8)),
           unicode: true,
@@ -2188,9 +2354,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         return false;
       },
     );
-    return chosen && cloud.has(chosen) ? chosen as AuthProvider : undefined;
+    return chosen && keyed.has(chosen) ? chosen as AuthProvider : undefined;
   };
 
+
   if (previewEnabled) {
     process.once("exit", () => out.write("\x1b[?25h")); // safety net: never leave the cursor hidden
     const footerKeypressHandler = (_ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean } | undefined) => {
@@ -2482,7 +2649,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // Box mode: NO raw `jeo>` prompt at all — the boxed footer IS the input UI
       // (gating already suppresses readline echo, the empty prompt guarantees no
       // raw CLI input line can ever flash). Legacy prompt only without the box.
-      const rawText = await promptInput(previewEnabled ? "" : "\njeo> ");
+      const rawText = pendingMidTurnCommands.length
+        ? (disarmPreview(), pendingMidTurnCommands.shift()!)
+        : await promptInput(previewEnabled ? "" : "\njeo> ");
       if (rawText.includes("\u0003")) forceExitFromCtrlC();
       const raw = rawText.trim();
       disarmPreview();
@@ -2936,40 +3105,152 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
       if (input.startsWith("/provider") && (input === "/provider" || input[9] === " ")) {
         const tokens = input.substring(9).trim().split(/\s+/).filter(Boolean);
-        const name = (tokens[0] ?? "").toLowerCase();
+        let name = (tokens[0] ?? "").toLowerCase();
         // gjc-parity (semantic): /provider is ONBOARDING ONLY — set up OAuth credentials
         // or an API-compatible endpoint. Switching the active provider/model lives in /model.
         const providerOnboardingUsage = (): string[] => [
           "Provider onboarding — set up credentials or an API-compatible endpoint:",
-          "  OAuth / subscription : /provider login [anthropic|openai|gemini|antigravity]   (alias: /login)",
+          "  OAuth / subscription : /provider login [anthropic|openai|gemini|antigravity|<subscription>]   (alias: /login)",
+          "                         subscriptions (token): alibaba-coding-plan, qwen-portal, xiaomi-token-plan-*, minimax-code*",
+          "  API key (cloud)      : /provider key [provider] [key]   (groq, deepseek, mistral, openrouter, …)",
           "  API-compatible       : /provider add --base-url <url> [--model <model>] [--compat openai]   (reads OPENAI_API_KEY)",
           "                         show current / clear: /provider add   ·   /provider add clear",
           "  Logout               : /logout <provider>",
+          "  Headless OAuth        : paste the redirect URL or code when the login prompt asks.",
           "Switch the active model or provider with /model.",
         ];
+        // Bare `/provider` in an interactive TTY → gjc's interactive onboarding selector
+        // (OAuth login vs API-compatible endpoint). The choice routes into the same
+        // `login`/`add` branches below; cancel falls through to the printed readiness +
+        // usage. Non-TTY / `help` keep the static panel (scriptable, unchanged).
+        if (!name && process.stdin.isTTY && process.stdout.isTTY) {
+          const action = await pickOnboardingAction();
+          if (action === "oauth-login") name = "login";
+          else if (action === "api-key") name = "key";
+          else if (action === "api-add") {
+            console.log("Add an API-compatible endpoint:");
+            console.log("  /provider add --base-url <url> [--model <model>] [--compat openai]");
+            console.log("  reads OPENAI_API_KEY · show current / clear: /provider add   ·   /provider add clear");
+            continue;
+          }
+          // action === undefined (cancelled) → fall through to the readiness panel.
+        }
+        // `/provider key [name] [key]` → store an API key for an API-key-only provider
+        // (groq/deepseek/mistral/…). Interactive: pick the provider, then paste the key.
+        if (name === "key") {
+          const keyed = new Set<string>(API_KEY_ONLY_PROVIDERS);
+          let target = tokens.slice(1).map(t => t.toLowerCase()).find(t => keyed.has(t)) as AuthProvider | undefined;
+          // A trailing token after the provider name is treated as the key itself.
+          const inlineKey = target ? tokens.slice(1).filter(t => t.toLowerCase() !== target).pop() : undefined;
+          if (!target) {
+            const statuses = await describeAllProviders();
+            if (process.stdin.isTTY && process.stdout.isTTY) {
+              target = await pickApiKeyProvider(statuses);
+            } else {
+              console.log("Set an API key for which provider?");
+              console.log(`  ${API_KEY_ONLY_PROVIDERS.filter(p => !(SUBSCRIPTION_PROVIDER_NAMES as readonly string[]).includes(p)).join(", ")}`);
+              console.log("  Subscription / plan products use /provider login (token).");
+              console.log("  Usage: /provider key <provider> <api-key>   (or set <PROVIDER>_API_KEY)");
+            }
+            if (!target) {
+              console.log("(cancelled)");
+              continue;
+            }
+          }
+          const envVar = `${target.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+          let apiKey = inlineKey;
+          if (!apiKey) {
+            apiKey = (await promptInput(`Paste ${target} API key (blank to cancel): `)).trim();
+          }
+          if (!apiKey) {
+            console.log("(cancelled — no key entered)");
+            continue;
+          }
+          await setApiKey(target, apiKey);
+          console.log(`[SUCCESS] Stored ${target} API key in ~/.jeo/config.json (also reads ${envVar}).`);
+          const live = await refreshLiveModelsCache();
+          const after = (await describeAllProviders()).find(s => s.name === target);
+          if (after) console.log(`  status → ${after.name}: ${after.ready ? `✓ ${after.label}` : after.label}`);
+          const forProvider = live.filter(r => r.provider === target);
+          if (forProvider.some(r => r.ok && r.models.length > 0)) {
+            lastPickIndex = flattenModels(forProvider);
+            const viaCatalog = forProvider.some(r => r.fallback);
+            console.log(`  ${viaCatalog ? "catalog" : "live"} ${target} models → /model #N${viaCatalog ? "  (live list endpoint unavailable; showing known models)" : ""}`);
+            logLines(formatPickListWithCapabilities(lastPickIndex, { cap: 12 }));
+          } else {
+            const failed = forProvider.find(r => !r.ok);
+            if (failed?.error) console.log(`  live ${target} models unavailable: ${failed.error}`);
+          }
+          continue;
+        }
         // `/provider login|auth [name]` → run OAuth login from the REPL.
         if (name === "login" || name === "auth") {
           const cloud = ["anthropic", "openai", "gemini", "antigravity"] as const;
-          let target = tokens.slice(1).map(t => t.toLowerCase()).find(t => (cloud as readonly string[]).includes(t));
+          const subs = new Set<string>(SUBSCRIPTION_PROVIDER_NAMES); // token-keyed subscription/plan products
+          let target = tokens.slice(1).map(t => t.toLowerCase()).find(t => (cloud as readonly string[]).includes(t) || subs.has(t));
           if (!target) {
             const statuses = await describeAllProviders();
             if (process.stdin.isTTY && process.stdout.isTTY) {
               target = await pickCloudProvider(statuses);
             } else {
               console.log("Log in to which provider?");
+              console.log("  OAuth:");
               cloud.forEach((p, i) => {
                 const st = statuses.find(s => s.name === p);
-                console.log(`  ${i + 1}) ${p.padEnd(10)} ${st?.ready ? `✓ ${st.label}` : "· not ready"}`);
+                const badge = st?.loggedIn
+                  ? `\u2713 logged in${st.oauthEmail ? ` (${st.oauthEmail})` : ""}`
+                  : "\u00b7 not logged in";
+                console.log(`  ${i + 1}) ${p.padEnd(10)} ${badge}`);
               });
+              console.log("  Subscription / plan (token):");
+              for (const p of SUBSCRIPTION_PROVIDER_NAMES) {
+                const st = statuses.find(s => s.name === p);
+                const badge = st?.kind === "api_key" ? "\u2713 active" : "\u00b7 no token";
+                console.log(`     ${p.padEnd(22)} ${badge} (set ${st?.envVar ?? `${p.toUpperCase().replace(/-/g, "_")}_API_KEY`})`);
+              }
               const ans = (await promptInput(`Choose [1-${cloud.length}] or name (blank to cancel): `)).trim().toLowerCase();
               const byNum: Record<string, string> = Object.fromEntries(cloud.map((p, i) => [String(i + 1), p]));
-              target = byNum[ans] ?? ((cloud as readonly string[]).includes(ans) ? ans : undefined);
+              target = byNum[ans] ?? ((cloud as readonly string[]).includes(ans) || subs.has(ans) ? ans : undefined);
             }
             if (!target) {
               console.log("(cancelled)");
               continue;
             }
           }
+          // Subscription/plan providers authenticate by token (not OAuth): prompt for the key
+          // and store it like `/provider key`, then refresh + list models.
+          if (subs.has(target)) {
+            const sub = target as AuthProvider;
+            const envVar = `${sub.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+            let token = tokens.slice(1).filter(t => t.toLowerCase() !== sub).pop();
+            if (!token) {
+              if (process.stdin.isTTY && process.stdout.isTTY) {
+                token = (await promptInput(`Paste ${sub} subscription token (blank to cancel): `)).trim();
+              } else {
+                console.log(`Set the ${sub} subscription token with: /provider login ${sub} <token>   (or set ${envVar}).`);
+              }
+            }
+            if (!token) {
+              console.log("(cancelled — no token entered)");
+              continue;
+            }
+            await setApiKey(sub, token);
+            console.log(`[SUCCESS] Stored ${sub} subscription token in ~/.jeo/config.json (also reads ${envVar}).`);
+            const live = await refreshLiveModelsCache();
+            const after = (await describeAllProviders()).find(s => s.name === sub);
+            if (after) console.log(`  status → ${after.name}: ${after.ready ? `✓ ${after.label}` : after.label}`);
+            const forProvider = live.filter(r => r.provider === sub);
+            if (forProvider.some(r => r.ok && r.models.length > 0)) {
+              lastPickIndex = flattenModels(forProvider);
+              const viaCatalog = forProvider.some(r => r.fallback);
+              console.log(`  ${viaCatalog ? "catalog" : "live"} ${sub} models → /model #N${viaCatalog ? "  (live list endpoint unavailable; showing known models)" : ""}`);
+              logLines(formatPickListWithCapabilities(lastPickIndex, { cap: 12 }));
+            } else {
+              const failed = forProvider.find(r => !r.ok);
+              if (failed?.error) console.log(`  live ${sub} models unavailable: ${failed.error}`);
+            }
+            continue;
+          }
           console.log(`Starting OAuth login for ${target}…`);
           try {
             const { email } = await interactiveOAuthLogin(target as AuthProvider, rl);
@@ -3216,7 +3497,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             // No model given → the provider's first live model, provider-qualified.
             chosenModel = qualifyModelId(forProvider[0]!.model, want);
           } else {
-            chosenModel = PROVIDER_DEFAULT[want];
+            chosenModel = providerDefaultModel(want);
           }
           await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, role.id, { model: chosenModel }) }));
           console.log(`${role.title} pinned to ${want} via model ${chosenModel} — saved to ~/.jeo/config.json`);

package/src/commands/setup.ts

@@ -8,6 +8,7 @@ import {
   OAUTH_FLOW_REGISTRY,
   openInBrowser,
   type AuthProvider,
+  type OAuthProvider,
   type OAuthController,
 } from "../auth";
 import {
@@ -118,7 +119,7 @@ export async function runSetupCommand(): Promise<void> {
       const key = await rl.question(`${choice} API key [${current.providers[choice] ? "********" : "None"}]: `);
       if (key.trim()) next.providers[choice] = key.trim();
     } else {
-      const flow = OAUTH_FLOW_REGISTRY[choice as AuthProvider];
+      const flow = OAUTH_FLOW_REGISTRY[choice as OAuthProvider];
       if (!flow.verifiedEndToEnd && flow.note) console.log(`Note: ${flow.note}`);
       // Abort the pending "Paste redirect URL…" question once the flow settles —
       // otherwise it survives the SUCCESS/FAILED result, reprints its prompt, and
@@ -138,7 +139,7 @@ export async function runSetupCommand(): Promise<void> {
       try {
         let email: string | undefined;
         try {
-          ({ email } = await interactiveLogin(choice as AuthProvider, ctrl));
+          ({ email } = await interactiveLogin(choice as OAuthProvider, ctrl));
         } finally {
           // Must fire BEFORE the catch's API-key question below, or that
           // question queues behind the stale paste prompt.