jeo-code 0.6.21 → 0.6.23

package/src/ai/providers/openai.ts

@@ -4,6 +4,7 @@ import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
+import { createThinkSplitter } from "../think-tags";
 
 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;
@@ -22,9 +23,11 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
       : msg.content;
     openaiMessages.push({ role: msg.role, content });
   }
-  // Reasoning models (o-series, gpt-5 family) take max_completion_tokens + reasoning_effort
+  // 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.
-  const isReasoning = /^o\d/.test(model) || /^gpt-5/.test(model);
+  // 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 payload: Record<string, unknown> = {
     model,
     messages: openaiMessages,
@@ -102,19 +105,30 @@ export const openaiAdapter: ProviderAdapter = {
     if (!response.body) return;
     let yieldedAny = false;
     let finishReason: string | undefined;
+    // Split inline <think>…</think> (DeepSeek-R1/Qwen-style local models) out of the
+    // visible answer and onto the reasoning channel. No-op for models that never emit it.
+    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; tool_calls?: { index?: number; function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
+      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 } };
       try {
         chunk = JSON.parse(data);
       } catch {
         continue;
       }
-      const delta = chunk.choices?.[0]?.delta?.content;
-      if (delta) {
-        yieldedAny = true;
-        yield delta;
+      const raw = chunk.choices?.[0]?.delta?.content;
+      if (raw) {
+        const visible = think.push(raw);
+        if (visible) {
+          yieldedAny = true;
+          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;
+      if (reason) options.onReasoning?.(reason);
       const tcs = chunk.choices?.[0]?.delta?.tool_calls;
       if (tcs) {
         for (const tc of tcs) {
@@ -128,6 +142,8 @@ export const openaiAdapter: ProviderAdapter = {
       if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
       if (chunk.usage) options.onUsage?.({ inputTokens: chunk.usage.prompt_tokens, outputTokens: chunk.usage.completion_tokens });
     }
+    const trailing = think.flush();
+    if (trailing) { yieldedAny = true; yield trailing; }
     // Native tool calls stream as tool_calls argument fragments — re-serialize once at end.
     const envelope = serializeAccumulatedToolCalls(toolAcc);
     if (envelope) { yieldedAny = true; yield envelope; }

package/src/ai/providers/xai.ts

@@ -0,0 +1,18 @@
+import type { Credential } from "../../auth";
+import { makeOpenAICompatibleAdapter } from "./openai-compatible";
+
+/**
+ * xAI (Grok) — OpenAI-compatible cloud API at https://api.x.ai/v1, keyed by
+ * XAI_API_KEY (or `providers.xai`). The credential (an api_key bearer) is passed
+ * through; grok reasoning models (grok-4.3, grok-4-fast-*, grok-code-fast-1) stream
+ * reasoning via `reasoning_content`, which the openai adapter routes to onReasoning.
+ */
+export const XAI_BASE_URL = "https://api.x.ai/v1";
+
+export const xaiAdapter = makeOpenAICompatibleAdapter({ name: "xai", baseUrl: XAI_BASE_URL });
+
+/** Credential carrier for xAI calls — an api_key bearer (the adapter only reads the
+ *  token); a keyless `none` when no key is set. */
+export function xaiCredential(key: string | undefined): Credential {
+  return key ? { kind: "api_key", provider: "openai", token: key } : { kind: "none", provider: "openai" };
+}

package/src/ai/register-providers.ts

@@ -12,10 +12,28 @@ import { anthropicAdapter } from "./providers/anthropic";
 import { openaiAdapter } from "./providers/openai";
 import { geminiAdapter } from "./providers/gemini";
 import { ollamaAdapter } from "./providers/ollama";
+import { lmstudioAdapter } from "./providers/lmstudio";
+import { xaiAdapter } from "./providers/xai";
 import { antigravityAdapter } from "./providers/antigravity";
+import { kimiAdapter } from "./providers/kimi";
+import { makeOpenAICompatibleAdapter } from "./providers/openai-compatible";
+import { makeAnthropicCompatibleAdapter } from "./providers/anthropic-compatible";
+import { OPENAI_COMPAT_PROVIDERS } from "./providers/openai-compatible-catalog";
 
 providerRegistry.register("anthropic", anthropicAdapter);
 providerRegistry.register("openai", openaiAdapter);
 providerRegistry.register("gemini", geminiAdapter);
 providerRegistry.register("antigravity", antigravityAdapter);
 providerRegistry.register("ollama", ollamaAdapter);
+providerRegistry.register("lmstudio", lmstudioAdapter);
+providerRegistry.register("xai", xaiAdapter);
+providerRegistry.register("kimi", kimiAdapter);
+
+// gjc-style data-driven providers: every catalog entry gets a thin factory adapter,
+// selected by wire protocol. Add a provider by adding ONE catalog row.
+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 });
+  providerRegistry.register(def.name, adapter);
+}

package/src/ai/think-tags.ts

@@ -0,0 +1,84 @@
+/**
+ * Streaming `<think>…</think>` splitter for OpenAI-compatible / Ollama models.
+ *
+ * Many open/local reasoning models (DeepSeek-R1, Qwen "thinking", QwQ, …) do NOT
+ * expose a separate reasoning channel; they inline their chain-of-thought as
+ * `<think>…</think>` inside the normal content stream. Without splitting, that
+ * reasoning is dumped into the answer as literal text. This stateful splitter
+ * routes think-tag content to `onReasoning` (the dimmed live trace) and returns
+ * only the user-visible answer text — handling tags that straddle chunk
+ * boundaries, so it is safe to feed raw streamed deltas one at a time.
+ *
+ * Passthrough is near-free: text with no `<think>` tag flows through unchanged
+ * (only a trailing partial-tag fragment is briefly buffered).
+ */
+const OPEN = "<think>";
+const CLOSE = "</think>";
+
+/** Longest suffix of `s` that is a non-empty proper prefix of `tag` (0 if none). */
+function partialTail(s: string, tag: string): number {
+  const max = Math.min(s.length, tag.length - 1);
+  for (let k = max; k > 0; k--) {
+    if (s.endsWith(tag.slice(0, k))) return k;
+  }
+  return 0;
+}
+
+export interface ThinkSplitter {
+  /** Feed one streamed delta; returns the visible (answer) text to yield. */
+  push(delta: string): string;
+  /** Flush any buffered partial tag at stream end; returns trailing visible text. */
+  flush(): string;
+}
+
+export function createThinkSplitter(onReasoning?: (delta: string) => void): ThinkSplitter {
+  let inThink = false;
+  let pending = ""; // a tail that might be the start of an OPEN/CLOSE tag
+
+  const push = (delta: string): string => {
+    let s = pending + delta;
+    pending = "";
+    let visible = "";
+    for (;;) {
+      if (!inThink) {
+        const idx = s.indexOf(OPEN);
+        if (idx === -1) {
+          const tail = partialTail(s, OPEN);
+          visible += s.slice(0, s.length - tail);
+          pending = s.slice(s.length - tail);
+          break;
+        }
+        visible += s.slice(0, idx);
+        s = s.slice(idx + OPEN.length);
+        inThink = true;
+      } else {
+        const idx = s.indexOf(CLOSE);
+        if (idx === -1) {
+          const tail = partialTail(s, CLOSE);
+          const think = s.slice(0, s.length - tail);
+          if (think) onReasoning?.(think);
+          pending = s.slice(s.length - tail);
+          break;
+        }
+        const think = s.slice(0, idx);
+        if (think) onReasoning?.(think);
+        s = s.slice(idx + CLOSE.length);
+        inThink = false;
+      }
+    }
+    return visible;
+  };
+
+  const flush = (): string => {
+    const out = pending;
+    pending = "";
+    // An unterminated tail is literal content: emit it on whichever channel was open.
+    if (inThink) {
+      if (out) onReasoning?.(out);
+      return "";
+    }
+    return out;
+  };
+
+  return { push, flush };
+}

package/src/ai/types.ts

@@ -1,6 +1,6 @@
 import type { Credential } from "../auth";
 
-export type ProviderName = "anthropic" | "openai" | "gemini" | "antigravity" | "ollama";
+export type ProviderName = "anthropic" | "openai" | "gemini" | "antigravity" | "ollama" | "lmstudio" | "xai" | "kimi" | "groq" | "deepseek" | "mistral" | "openrouter" | "together" | "cerebras" | "fireworks" | "nvidia" | "alibaba-coding-plan" | "huggingface" | "nanogpt" | "qwen-portal" | "synthetic" | "venice" | "zenmux" | "qianfan" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "minimax-code" | "minimax-code-cn" | "zai" | "minimax";
 
 /** An image attached to a (user) message — base64 payload + IANA media type. */
 export interface ImageAttachment {
@@ -17,6 +17,11 @@ export interface Message {
    *  these alongside `content`; history bookkeeping (compaction, transcripts)
    *  keeps treating `content` as the message body. */
   images?: ImageAttachment[];
+  /** Persisted reasoning/thinking text for an assistant turn (the thought before the
+   *  answer). Survives /resume + export so the durable record shows "think → answer".
+   *  Display-only: NOT replayed to providers (anthropic/gemini thinking replay needs
+   *  the original signed block, which the streaming path does not capture). */
+  reasoning?: string;
 }
 
 export interface Usage {

package/src/auth/flows/index.ts

@@ -1,5 +1,5 @@
 /** Per-provider OAuth login + refresh dispatch. */
-import type { AuthProvider } from "../storage";
+import type { AuthProvider, OAuthProvider } from "../storage";
 import type { OAuthController, OAuthCredentials } from "../types";
 import { loginAnthropic, refreshAnthropicToken } from "./anthropic";
 import { loginOpenAI, refreshOpenAIToken } from "./openai";
@@ -7,7 +7,7 @@ import { loginGoogle, refreshGoogleToken } from "./google";
 import { loginAntigravity, refreshAntigravityToken } from "./antigravity";
 
 export interface OAuthFlow {
-  readonly provider: AuthProvider;
+  readonly provider: OAuthProvider;
   readonly label: string;
   /** Run the interactive browser/PKCE login. */
   login(ctrl: OAuthController): Promise<OAuthCredentials>;
@@ -19,7 +19,7 @@ export interface OAuthFlow {
   readonly note?: string;
 }
 
-export const OAUTH_FLOW_REGISTRY: Record<AuthProvider, OAuthFlow> = {
+export const OAUTH_FLOW_REGISTRY: Record<OAuthProvider, OAuthFlow> = {
   anthropic: {
     provider: "anthropic",
     label: "Anthropic (Claude Pro/Max)",

package/src/auth/index.ts

@@ -6,8 +6,11 @@ export {
   setOauthCredential,
   clearOauthToken,
   setApiKey,
+  isOAuthProvider,
+  OAUTH_PROVIDERS,
+  API_KEY_ONLY_PROVIDERS,
 } from "./storage";
-export type { AuthProvider, Credential, AuthSnapshot } from "./storage";
+export type { AuthProvider, OAuthProvider, Credential, AuthSnapshot } from "./storage";
 export {
   OAUTH_FLOWS,
   openInBrowser,

package/src/auth/oauth.ts

@@ -1,4 +1,4 @@
-import type { AuthProvider } from "./storage";
+import type { AuthProvider, OAuthProvider } from "./storage";
 import { setOauthToken, clearOauthToken, setOauthCredential } from "./storage";
 import { OAUTH_FLOW_REGISTRY } from "./flows";
 import type { OAuthController } from "./types";
@@ -10,7 +10,7 @@ export interface OauthFlowDef {
 }
 
 /** Metadata kept for help text / manual-paste fallback. */
-export const OAUTH_FLOWS: Record<AuthProvider, OauthFlowDef> = {
+export const OAUTH_FLOWS: Record<OAuthProvider, OauthFlowDef> = {
   anthropic: {
     label: "Anthropic Console (Claude)",
     authorizeUrl: "https://claude.ai/oauth/authorize",
@@ -64,7 +64,7 @@ export async function openInBrowser(url: string): Promise<void> {
  * the local callback server, wait for the code (or manual paste), exchange it,
  * and persist the full credential set (access + refresh + expiry).
  */
-export async function interactiveLogin(provider: AuthProvider, ctrl: OAuthController): Promise<{ email?: string }> {
+export async function interactiveLogin(provider: OAuthProvider, ctrl: OAuthController): Promise<{ email?: string }> {
   const flow = OAUTH_FLOW_REGISTRY[provider];
   const creds = await flow.login(ctrl);
   await setOauthCredential(provider, {

package/src/auth/refresh.ts

@@ -7,6 +7,7 @@ import {
   acquireLock,
   releaseLock,
   type AuthProvider,
+  isOAuthProvider,
   type Credential,
 } from "./storage";
 import { OAUTH_FLOW_REGISTRY } from "./flows";
@@ -24,6 +25,10 @@ export interface RefreshResult {
  * Mirrors gjc's auth-broker refresher semantics (single source of truth).
  */
 export async function refreshOAuthToken(provider: AuthProvider): Promise<RefreshResult> {
+  // API-key-only providers (xai/kimi) have no OAuth flow — nothing to refresh.
+  if (!isOAuthProvider(provider)) {
+    return { refreshed: false, reason: "no_oauth_token", credential: await resolveCredential(provider) };
+  }
   await acquireLock(provider);
   try {
     const stored = await getStoredOAuth(provider);

package/src/auth/storage.ts

@@ -5,7 +5,18 @@ import { readGlobalConfig, readRawGlobalConfig, saveConfigPatch, type StoredOAut
 import { jeoEnv } from "../util/env";
 
 
-export type AuthProvider = "anthropic" | "openai" | "gemini" | "antigravity";
+/** Providers with an interactive OAuth login + refresh flow. */
+export type OAuthProvider = "anthropic" | "openai" | "gemini" | "antigravity";
+/** Every provider jeo resolves a credential for: OAuth-capable ∪ API-key-only. */
+export type AuthProvider = OAuthProvider | "xai" | "kimi" | "groq" | "deepseek" | "mistral" | "openrouter" | "together" | "cerebras" | "fireworks" | "nvidia" | "alibaba-coding-plan" | "huggingface" | "nanogpt" | "qwen-portal" | "synthetic" | "venice" | "zenmux" | "qianfan" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "minimax-code" | "minimax-code-cn" | "zai" | "minimax";
+
+export const OAUTH_PROVIDERS: readonly OAuthProvider[] = ["anthropic", "openai", "gemini", "antigravity"];
+/** API-key-only providers (no OAuth flow) — resolved from config.providers / `<NAME>_API_KEY`. */
+export const API_KEY_ONLY_PROVIDERS: readonly AuthProvider[] = ["xai", "kimi", "groq", "deepseek", "mistral", "openrouter", "together", "cerebras", "fireworks", "nvidia", "alibaba-coding-plan", "huggingface", "nanogpt", "qwen-portal", "synthetic", "venice", "zenmux", "qianfan", "xiaomi", "xiaomi-token-plan-ams", "xiaomi-token-plan-cn", "xiaomi-token-plan-sgp", "minimax-code", "minimax-code-cn", "zai", "minimax"];
+/** Narrow an AuthProvider to the OAuth-capable subset (xai/kimi have no OAuth flow). */
+export function isOAuthProvider(p: AuthProvider): p is OAuthProvider {
+  return (OAUTH_PROVIDERS as readonly string[]).includes(p);
+}
 
 export type Credential =
   | { kind: "oauth"; provider: AuthProvider; token: string; projectId?: string }

package/src/commands/auth.ts

@@ -14,6 +14,9 @@ import {
   logoutOAuth,
   refreshOAuthToken,
   snapshotProvider,
+  setApiKey,
+  isOAuthProvider,
+  API_KEY_ONLY_PROVIDERS,
   type AuthProvider,
   type OAuthController,
 } from "../auth";
@@ -29,7 +32,7 @@ export async function runAuthCommand(args: string[]): Promise<void> {
   process.exitCode = 1;
 }
 
-const CLOUD_PROVIDERS: readonly AuthProvider[] = ["anthropic", "openai", "gemini", "antigravity"]
+const CLOUD_PROVIDERS: readonly AuthProvider[] = ["anthropic", "openai", "gemini", "antigravity", "xai", "kimi"];
 /** 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)) {
@@ -53,7 +56,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"] as AuthProvider[]) {
+  for (const p of ["anthropic", "openai", "gemini", "antigravity", "xai", "kimi"] as AuthProvider[]) {
     const snap = await snapshotProvider(p);
     const key = p === "antigravity" ? "—" : (snap.apiKey ? "set" : "—");
     let oauth = "—";
@@ -99,6 +102,17 @@ async function runAuthLogin(rest: string[]): Promise<void> {
     rl.close();
     return;
   }
+  // API-key-only providers (xai/kimi): no OAuth flow — store/guide an API key.
+  if ((API_KEY_ONLY_PROVIDERS as readonly string[]).includes(chosen)) {
+    rl.close();
+    if (manualToken) {
+      await setApiKey(chosen, manualToken.trim());
+      console.log(`[SUCCESS] Stored ${chosen.toUpperCase()}_API_KEY in ~/.jeo/config.json.`);
+    } else {
+      console.log(`Provider '${chosen}' is API-key only (no OAuth flow). Set ${chosen.toUpperCase()}_API_KEY, or run 'jeo auth login ${chosen} --token <key>'.`);
+    }
+    return;
+  }
 
   // Non-interactive paste path (`--token`): store as a manual bearer.
   if (manualToken) {
@@ -213,6 +227,9 @@ export async function interactiveOAuthLogin(
   prompt: OAuthPrompt,
   log: (s: string) => void = console.log,
 ): Promise<{ email?: string }> {
+  if (!isOAuthProvider(provider)) {
+    throw new Error(`Provider '${provider}' is API-key only (no OAuth flow) — set ${provider.toUpperCase()}_API_KEY or run 'jeo auth login ${provider} --token <key>'.`);
+  }
   const flow = OAUTH_FLOW_REGISTRY[provider];
   log(`\n=== OAuth login — ${flow.label} ===`);
   if (!flow.verifiedEndToEnd && flow.note) log(`Note: ${flow.note}`);

package/src/commands/launch/flags.ts

@@ -51,7 +51,11 @@ export function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefin
   const supported = catalogMetadata(modelId)?.thinking ?? [];
   if (supported.includes("minimal")) return "minimal";
   if (supported.includes("low")) return "low";
-  if (/gemini-(2\.5|[3-9])/.test(modelId.toLowerCase())) return "minimal";
+  // Digit-count agnostic (gemini-10+ / 2.6+ stay reasoning) — mirrors the gates in
+  // gemini.ts and inferCatalogMetadata. Last resort for prefixed ids (models/gemini-…)
+  // the catalog lookup above misses; catalogued ids already returned via thinking caps.
+  const g = modelId.toLowerCase().match(/gemini-(\d+)(?:\.(\d+))?/);
+  if (g && (Number(g[1]) >= 3 || (Number(g[1]) === 2 && Number(g[2] ?? 0) >= 5))) return "minimal";
   return undefined;
 }
 

package/src/commands/launch/input.ts

@@ -395,3 +395,16 @@ export function createInFlightAbortHarness(opts: AbortHarnessOptions = {}): InFl
     },
   };
 }
+
+/** Classify a mid-turn Enter draft. `/` (slash command) and `$` (skill) are jeo's
+ *  command sigils: such a line must run as a COMMAND, never be steered as literal text
+ *  into the running model. Anything else is a STEER query fed to the live turn; blank
+ *  is EMPTY (ignored). Pure + exported so the live-turn handler and tests can't drift. */
+export function classifyMidTurnLine(line: string): "command" | "steer" | "empty" {
+  const t = line.trim();
+  if (!t) return "empty";
+  // A lone sigil ("/" or "$") has no command name — ignore it instead of aborting the
+  // running turn to dispatch an empty command (a stray slash should not interrupt work).
+  if (t === "/" || t === "$") return "empty";
+  return /^[/$]/.test(t) ? "command" : "steer";
+}

package/src/commands/launch.ts

@@ -20,7 +20,7 @@ import { interactiveOAuthLogin } from "./auth";
 import { logoutOAuth } 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 } 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";
@@ -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,
@@ -219,7 +222,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 +271,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 +480,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 +492,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 +565,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 +599,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 +698,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 +736,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 +903,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;
@@ -1356,6 +1411,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 +1422,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
@@ -2482,7 +2546,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();
@@ -3216,7 +3282,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.