jeo-code 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -6,6 +6,32 @@ 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.2] - 2026-06-16
+_Interactive `/provider` picker, clearer animated status + labeled block/prose boundaries, and a transient empty-response retry._
+
+### Added
+- **Interactive `/provider` picker** (gjc-style) with a clean screen after login (#26).
+- **Clearer visual structure** — unified labeled boundaries for thinking / reasoning / output blocks and a dimensional animated status line (#29, building on the labeled-boundary work).
+- `docs/minimo/` — a plan to apply MiMo Code's memory & goal-management ideas to jeo (#28).
+
+### Fixed
+- **Retry transient empty-200 responses** (a 200 with an empty body) for stability — gjc parity (#27).
+
+## [0.6.1] - 2026-06-16
+_Live reasoning progress (no more frozen "calling model"), thinking-level fixes for Anthropic/Antigravity, and input-box/Ctrl+O TUI fixes._
+
+### Added
+- **Live reasoning progress.** Codex/OpenAI reasoning models now stream their thinking into the live frame (`reasoning.summary: "auto"` + `response.reasoning*.delta` events surfaced via `onReasoning`), and the status row reads `reasoning (model)…` / `thinking — reasoning, no token stream yet…` after a silent wait instead of a frozen `calling model (Ns)…`.
+
+### Fixed
+- Thinking level is now applied to the **Anthropic and Antigravity** providers (it was a silent no-op there).
+- The **input box + caret stay in place after running a command** — no more vanishing box / caret parked at the reservation top.
+- **Skill runs render a compact `[skill]` card** instead of dumping the injected `SKILL.md` into a user box.
+- **Ctrl+O fold toggle** + incremental session durability across interruption.
+
+### Changed
+- Trimmed `fastThinkingLevelForModel` fallback to the real gap (ponytail pass); added a usage guide + demo video, linked from all READMEs.
+
 ## [0.6.0] - 2026-06-16
 _TUI quality of life: durable input history (↑ recalls past queries across launches), clean `/resume` rendering, and a scrollable mid-turn Ctrl+O panel._
 

package/README.ja.md

@@ -28,6 +28,14 @@
 
 リポジトリ内で `jeo` を実行すると、ファイルを読み・編集し・コマンドを実行してタスクを完了まで進めます — 全ステップがスクロールバック親和なインライン TUI でライブ配信されます。
 
+## ドキュメント
+
+📖 **[使い方ガイド](docs/usage-guide.md)** — インストール、TUI操作（↑履歴、Ctrl+O、`!`シェル）、スラッシュコマンド、`/resume`、スペックファーストワークフローをデモ動画付きで解説。
+
+<video src="https://raw.githubusercontent.com/akillness/jeo-code/main/docs/jeo-code-promo.mp4" controls muted playsinline width="100%"></video>
+
+> インライン再生されない場合は ▶ [デモ動画を再生/ダウンロード](docs/jeo-code-promo.mp4)。
+
 ## ハイライト
 
 - **マルチプロバイダ・単一ループ** — Anthropic / OpenAI(+Codex) / Gemini / Antigravity / Ollama を均一な JSON ツールループで。入力欄から OAuth ログイン(`/provider login`)、モデル選択は即座にデフォルトとして永続化。
@@ -150,11 +158,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.2]** (2026-06-16) — Interactive `/provider` picker, clearer animated status + labeled block/prose boundaries, and a transient empty-response retry.
+- **[0.6.1]** (2026-06-16) — Live reasoning progress (no more frozen "calling model"), thinking-level fixes for Anthropic/Antigravity, and input-box/Ctrl+O TUI fixes.
 - **[0.6.0]** (2026-06-16) — TUI quality of life: durable input history (↑ recalls past queries across launches), clean `/resume` rendering, and a scrollable mid-turn Ctrl+O panel.
 - **[0.5.16]** (2026-06-16) — `/resume` and Ctrl+O no longer corrupt the TUI — clean screen restore + scrollback expand.
 - **[0.5.15]** (2026-06-16) — `jeo update` now actually upgrades — bare command installs the latest release instead of just printing a manual command.
-- **[0.5.14]** (2026-06-16) — `jeo --tmux` live-verification harness — repeatable stability + behavior checks.
-- **[0.5.13]** (2026-06-15) — Workflow `/` commands actually run — `/deep-interview`, `/team`, `/ultragoal`, `/ralplan` dispatch by name.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -28,6 +28,14 @@
 
 저장소 안에서 `jeo`를 실행하면 파일을 읽고, 수정하고, 명령을 실행하며 작업을 완료까지 끌고 갑니다 — 모든 스텝이 스크롤백 친화적인 인라인 TUI로 실시간 스트리밍됩니다.
 
+## 문서
+
+📖 **[사용 가이드](docs/usage-guide.md)** — 설치, TUI 조작(↑ 이전 쿼리, Ctrl+O, `!` 셸), 슬래시 명령, `/resume`, 스펙 우선 워크플로를 데모 영상과 함께 설명합니다.
+
+<video src="https://raw.githubusercontent.com/akillness/jeo-code/main/docs/jeo-code-promo.mp4" controls muted playsinline width="100%"></video>
+
+> 인라인 재생이 안 되면 ▶ [데모 영상 재생/다운로드](docs/jeo-code-promo.mp4).
+
 ## 하이라이트
 
 - **멀티 프로바이더, 단일 루프** — Anthropic / OpenAI(+Codex) / Gemini / Antigravity / Ollama를 균일한 JSON 도구 루프로. 입력창에서 바로 OAuth 로그인(`/provider login`), 모델 선택은 즉시 기본값으로 영속.
@@ -150,11 +158,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.2]** (2026-06-16) — Interactive `/provider` picker, clearer animated status + labeled block/prose boundaries, and a transient empty-response retry.
+- **[0.6.1]** (2026-06-16) — Live reasoning progress (no more frozen "calling model"), thinking-level fixes for Anthropic/Antigravity, and input-box/Ctrl+O TUI fixes.
 - **[0.6.0]** (2026-06-16) — TUI quality of life: durable input history (↑ recalls past queries across launches), clean `/resume` rendering, and a scrollable mid-turn Ctrl+O panel.
 - **[0.5.16]** (2026-06-16) — `/resume` and Ctrl+O no longer corrupt the TUI — clean screen restore + scrollback expand.
 - **[0.5.15]** (2026-06-16) — `jeo update` now actually upgrades — bare command installs the latest release instead of just printing a manual command.
-- **[0.5.14]** (2026-06-16) — `jeo --tmux` live-verification harness — repeatable stability + behavior checks.
-- **[0.5.13]** (2026-06-15) — Workflow `/` commands actually run — `/deep-interview`, `/team`, `/ultragoal`, `/ralplan` dispatch by name.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -28,6 +28,14 @@
 
 Run `jeo` inside a repository and it reads files, edits them, runs commands, and drives the task to completion — streaming every step live in an inline, scrollback-friendly TUI.
 
+## Documentation
+
+📖 **[Usage guide](docs/usage-guide.md)** — install, TUI controls (↑ recall, Ctrl+O, `!` shell), slash commands, `/resume`, and the spec-first workflow, with a demo video.
+
+<video src="https://raw.githubusercontent.com/akillness/jeo-code/main/docs/jeo-code-promo.mp4" controls muted playsinline width="100%"></video>
+
+> Demo not playing inline? ▶ [Play / download the demo video](docs/jeo-code-promo.mp4).
+
 ## Highlights
 
 - **Multi-provider, one loop** — Anthropic / OpenAI (+Codex) / Gemini / Antigravity / Ollama behind a uniform JSON tool loop. OAuth login from the input box (`/provider login`), every model pick persists as the new default.
@@ -150,11 +158,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.2]** (2026-06-16) — Interactive `/provider` picker, clearer animated status + labeled block/prose boundaries, and a transient empty-response retry.
+- **[0.6.1]** (2026-06-16) — Live reasoning progress (no more frozen "calling model"), thinking-level fixes for Anthropic/Antigravity, and input-box/Ctrl+O TUI fixes.
 - **[0.6.0]** (2026-06-16) — TUI quality of life: durable input history (↑ recalls past queries across launches), clean `/resume` rendering, and a scrollable mid-turn Ctrl+O panel.
 - **[0.5.16]** (2026-06-16) — `/resume` and Ctrl+O no longer corrupt the TUI — clean screen restore + scrollback expand.
 - **[0.5.15]** (2026-06-16) — `jeo update` now actually upgrades — bare command installs the latest release instead of just printing a manual command.
-- **[0.5.14]** (2026-06-16) — `jeo --tmux` live-verification harness — repeatable stability + behavior checks.
-- **[0.5.13]** (2026-06-15) — Workflow `/` commands actually run — `/deep-interview`, `/team`, `/ultragoal`, `/ralplan` dispatch by name.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -28,6 +28,14 @@
 
 在仓库内运行 `jeo`，它会读取文件、编辑代码、执行命令，并把任务推进到完成 — 每一步都通过滚动友好的内联 TUI 实时呈现。
 
+## 文档
+
+📖 **[使用指南](docs/usage-guide.md)** — 安装、TUI 操作（↑ 历史、Ctrl+O、`!` shell）、斜杠命令、`/resume`、规格优先工作流，附演示视频。
+
+<video src="https://raw.githubusercontent.com/akillness/jeo-code/main/docs/jeo-code-promo.mp4" controls muted playsinline width="100%"></video>
+
+> 无法内联播放？▶ [播放/下载演示视频](docs/jeo-code-promo.mp4)。
+
 ## 亮点
 
 - **多提供商、单一循环** — Anthropic / OpenAI(+Codex) / Gemini / Antigravity / Ollama 统一在一个 JSON 工具循环中。输入框内直接 OAuth 登录(`/provider login`)，模型选择即刻持久化为默认值。
@@ -150,11 +158,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.2]** (2026-06-16) — Interactive `/provider` picker, clearer animated status + labeled block/prose boundaries, and a transient empty-response retry.
+- **[0.6.1]** (2026-06-16) — Live reasoning progress (no more frozen "calling model"), thinking-level fixes for Anthropic/Antigravity, and input-box/Ctrl+O TUI fixes.
 - **[0.6.0]** (2026-06-16) — TUI quality of life: durable input history (↑ recalls past queries across launches), clean `/resume` rendering, and a scrollable mid-turn Ctrl+O panel.
 - **[0.5.16]** (2026-06-16) — `/resume` and Ctrl+O no longer corrupt the TUI — clean screen restore + scrollback expand.
 - **[0.5.15]** (2026-06-16) — `jeo update` now actually upgrades — bare command installs the latest release instead of just printing a manual command.
-- **[0.5.14]** (2026-06-16) — `jeo --tmux` live-verification harness — repeatable stability + behavior checks.
-- **[0.5.13]** (2026-06-15) — Workflow `/` commands actually run — `/deep-interview`, `/team`, `/ultragoal`, `/ralplan` dispatch by name.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/ai/providers/anthropic.ts

@@ -72,6 +72,18 @@ function anthropicSystemBlocks(
   return blocks;
 }
 
+/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Off for
+ *  low/minimal/unset effort so /fast and minimal thinking stay non-thinking (cheaper/faster). */
+function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxTokens: number): number | undefined {
+  let budget: number;
+  switch (effort) {
+    case "medium": budget = 4096; break;
+    case "high": budget = 10000; break;
+    default: return undefined;
+  }
+  return Math.min(budget, Math.max(1024, maxTokens - 1024));
+}
+
 export function anthropicPayload(
   messages: Message[],
   options: CallOptions,
@@ -109,13 +121,24 @@ export function anthropicPayload(
       last.content[last.content.length - 1] = { ...tail, cache_control: { type: "ephemeral" } };
     }
   }
+  const maxTokens = options.maxTokens ?? 4000;
+  const thinkingBudget = anthropicThinkingBudget(options.reasoningEffort, maxTokens);
   const payload: Record<string, unknown> = {
     model,
     messages: anthropicMessages,
-    max_tokens: options.maxTokens ?? 4000,
+    // Extended thinking requires max_tokens strictly above the thinking budget.
+    max_tokens: thinkingBudget !== undefined ? Math.max(maxTokens, thinkingBudget + 1024) : maxTokens,
   };
   if (credential.kind === "oauth") payload.metadata = { user_id: createClaudeCloakingUserId() };
-  if (includeTemperature && options.temperature !== undefined) payload.temperature = options.temperature;
+  if (thinkingBudget !== undefined) {
+    // Apply the thinking level: enable Claude extended thinking (the interleaved-thinking
+    // beta is already in the headers). Extended thinking forbids a custom temperature, so
+    // temperature is only set on the non-thinking path. Previously the thinking level only
+    // changed max_tokens and never reached Claude as actual reasoning depth.
+    payload.thinking = { type: "enabled", budget_tokens: thinkingBudget };
+  } else if (includeTemperature && options.temperature !== undefined) {
+    payload.temperature = options.temperature;
+  }
   if (options.tools?.length) {
     // NATIVE tool-calling: declare jeo's tools as Anthropic functions. tool_choice
     // "auto" keeps prose-salvage reachable and lets the model call `done` (declared as
@@ -232,7 +255,7 @@ export const anthropicAdapter: ProviderAdapter = {
         type?: string;
         index?: number;
         content_block?: { type?: string; name?: string };
-        delta?: { type?: string; text?: string; partial_json?: string; stop_reason?: string };
+        delta?: { type?: string; text?: string; partial_json?: string; thinking?: string; stop_reason?: string };
         message?: { usage?: AnthropicUsage };
         usage?: { output_tokens?: number };
       };
@@ -249,6 +272,8 @@ export const anthropicAdapter: ProviderAdapter = {
       } else if (evt.type === "content_block_delta" && evt.delta?.type === "text_delta" && evt.delta.text) {
         yieldedAny = true;
         yield evt.delta.text;
+      } else if (evt.type === "content_block_delta" && evt.delta?.type === "thinking_delta" && evt.delta.thinking) {
+        options.onReasoning?.(evt.delta.thinking);
       } else if (evt.type === "message_start" && evt.message?.usage) {
         // Cache only — usage is reported ONCE at message_delta so an accumulating
         // sink can't double-count input (and a pre-first-chunk retry that replays

package/src/ai/providers/antigravity.ts

@@ -4,6 +4,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { serializeToolCalls } from "../../agent/tool-schemas";
+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";
@@ -130,6 +131,11 @@ export function antigravityRequest(messages: Message[], options: CallOptions, cr
   if (options.temperature !== undefined) generationConfig.temperature = options.temperature;
   // Upstream Antigravity strips maxOutputTokens for non-Claude models; do the same.
   if (model.toLowerCase().includes("claude")) generationConfig.maxOutputTokens = options.maxTokens ?? 4000;
+  // Apply the thinking level: antigravity serves Gemini models through CCA, so reuse the
+  // Gemini thinkingConfig budget (off at minimal, scaling with reasoning effort). Without
+  // this the thinking level only changed token budget, never actual reasoning depth.
+  const agThinkingBudget = geminiThinkingBudget(model, options.reasoningEffort);
+  if (agThinkingBudget !== undefined) generationConfig.thinkingConfig = { thinkingBudget: agThinkingBudget };
 
   const request: Record<string, unknown> = {
     contents: antigravityContents(messages),

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

@@ -72,7 +72,9 @@ export function codexResponsesRequest(
   // Map thinkingLevel → reasoning effort for Codex reasoning models (gjc parity).
   // Drop out-of-enum values instead of forwarding them — the backend 400s on unknown efforts.
   if (options.reasoningEffort && VALID_REASONING_EFFORTS.has(options.reasoningEffort)) {
-    payload.reasoning = { effort: options.reasoningEffort };
+    // `summary: "auto"` makes the backend stream reasoning-summary deltas so the live
+    // frame can show the model's thinking instead of a frozen "calling model (Ns)…".
+    payload.reasoning = { effort: options.reasoningEffort, summary: "auto" };
   }
   const accountId = extractChatgptAccountId(token);
   const headers: Record<string, string> = {
@@ -88,6 +90,9 @@ export function codexResponsesRequest(
 
 export interface ResponsesEvent {
   delta?: string;
+  /** Reasoning-summary text delta (`response.reasoning_summary_text.delta` and the
+   *  Codex backend's `reasoning_text` variant) — streamed live as the model thinks. */
+  reasoningDelta?: string;
   usage?: { inputTokens?: number; outputTokens?: number };
   error?: string;
   /** `response.incomplete` cause (e.g. max_output_tokens) — surfaced when the
@@ -125,6 +130,12 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
     return { toolCallArgsDelta: o.delta, toolCallIndex: o.output_index };
   }
   if (o.type === "response.output_text.delta" && typeof o.delta === "string") return { delta: o.delta };
+  // Reasoning-summary streaming: surface the model's thinking live. Accept the
+  // documented `response.reasoning_summary_text.delta` and the Codex backend's
+  // `response.reasoning_text.delta` (any reasoning*.delta variant) uniformly.
+  if (typeof o.delta === "string" && /^response\.reasoning[a-z_]*\.delta$/.test(o.type ?? "")) {
+    return { reasoningDelta: o.delta };
+  }
   // `response.incomplete` (max_output_tokens / content filter) also carries usage — don't drop it.
   if ((o.type === "response.completed" || o.type === "response.incomplete") && o.response?.usage) {
     return {
@@ -175,6 +186,7 @@ export async function codexResponsesCall(messages: Message[], options: CallOptio
   for await (const data of readSse(response.body)) {
     const ev = parseResponsesEvent(data);
     if (ev.delta) out += ev.delta;
+    if (ev.reasoningDelta) options.onReasoning?.(ev.reasoningDelta);
     accumulateResponsesToolCall(toolAcc, ev);
     if (ev.usage) options.onUsage?.(ev.usage);
     if (ev.incompleteReason) incompleteReason = ev.incompleteReason;
@@ -202,6 +214,7 @@ export async function* codexResponsesStream(
   const toolAcc = new Map<number, { name: string; args: string }>();
   for await (const data of readSse(response.body)) {
     const ev = parseResponsesEvent(data);
+    if (ev.reasoningDelta) options.onReasoning?.(ev.reasoningDelta);
     if (ev.delta) {
       yieldedAny = true;
       yield ev.delta;

package/src/commands/launch.ts

@@ -45,6 +45,7 @@ import { SelectList, renderSelectList, type SelectItem } from "../tui/components
 import {
   formatModelLine,
   formatProviderPanel,
+  emitLoginCleanup,
   formatAgentsPanel,
   formatAgentDetail,
   formatConfigPanel,
@@ -55,7 +56,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 { providerPicker, renderProviderPicker, buildProviderChoices } 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 } from "../tui/components/input-box";
@@ -142,6 +143,12 @@ function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefined {
   const supported = catalogMetadata(modelId)?.thinking ?? [];
   if (supported.includes("minimal")) return "minimal";
   if (supported.includes("low")) return "low";
+  // Fallback for the one thinking-capable family that misses a catalog entry in practice:
+  // the dynamic antigravity `gemini-3.x` variants (gemini-3.5-flash-low/-extra-low, …) the
+  // CCA backend serves but the static catalog can't enumerate. They apply a thinking budget,
+  // so /fast offers `minimal` as the fast level instead of reporting "unsupported". (openai
+  // reasoning models and *-thinking/-high/-low antigravity ids are already catalogued.)
+  if (/gemini-(2\.5|[3-9])/.test(modelId.toLowerCase())) return "minimal";
   return undefined;
 }
 
@@ -1311,6 +1318,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       base.onToolResult?.(tool, success, output);
     },
   });
+  /** Compose a session-persistence flush into onStep so each completed step is
+   *  written as it lands (durability across mid-turn interruption) without
+   *  disturbing the original onStep sink. */
+  const withStepPersistence = (
+    base: AgentLoopEvents,
+    persist: () => Promise<void>,
+  ): AgentLoopEvents => ({
+    ...base,
+    onStep: async (step: number) => {
+      await base.onStep?.(step);
+      await persist();
+    },
+  });
   /** The Ctrl+O detail block (shared by the prompt-time keypress handler and the
    *  mid-turn TUI binding): full last reply + full last tool output. */
   const composeDetailLines = (): string[] => {
@@ -1372,7 +1392,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const runTurn = async (
     userInput: string,
     useTui: boolean,
-    images?: ImageAttachment[]
+    images?: ImageAttachment[],
+    // What to show as the user card in the live frame: undefined → the prompt
+    // itself (normal turns); null → suppress it entirely (skill runs, where the
+    // injected SKILL.md is NOT user-authored and the [skill] card already names it,
+    // gjc-style); a string → show that compact label instead of the raw input.
+    opts?: { userCard?: string | null },
   ): Promise<{ done: boolean; steps: number; reply: string; rendered: boolean; usage: string }> => {
     const turnConfig = await readGlobalConfig();
     const activeModel = sessionModel || turnConfig.defaultModel;
@@ -1389,6 +1414,17 @@ 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;
+    // 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
+    // Ctrl+C / crash / ESC can't lose the prompt + finished steps before /resume.
+    let persistedLen = beforeLen;
+    const persistTurnTail = async (): Promise<void> => {
+      if (!sessionId || history.length <= persistedLen) return;
+      const tail = history.slice(persistedLen);
+      persistedLen = history.length;
+      try { await appendMessages(sessionId, tail, cwd); } catch { /* best-effort */ }
+    };
     let result;
     try {
       // Paint the live frame + spinner the INSTANT the turn is accepted, BEFORE the
@@ -1413,17 +1449,24 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         tui?.events().onNotice?.(`(compacted ${compRes.removed} older message${compRes.removed === 1 ? "" : "s"})`);
       }
       beforeLen = history.length;
+      persistedLen = beforeLen; // re-baseline after compaction mutated history
       if (images?.length && catalogMetadata(activeModel)?.images === false) {
         const warn = `! ${activeModel} does not advertise image input — sending the attachment anyway.`;
         if (tui) tui.events().onNotice?.(warn);
         else console.log(warn);
       }
       history.push(images?.length ? { role: "user", content: userInput, images } : { role: "user", content: userInput });
+      // Persist the user prompt immediately so an interrupted turn keeps it on disk.
+      await persistTurnTail(); // persist the user prompt immediately
       // Keep the submitted query in scrollback: the prompt that STARTS a turn shows
       // only as the transient HUD turn-title otherwise, which vanishes when the live
       // frame clears at turn-end — so the conversation transcript lost every user
       // prompt. Flush a `user` card (same surface as a mid-turn steer) so it persists.
-      if (tui && userInput.trim()) tui.flushUserCard(userInput);
+      // Flush a `user` card (same surface as a mid-turn steer) so the prompt persists
+      // in scrollback. opts.userCard overrides it: null suppresses the card entirely
+      // (skill runs), a string shows a compact label instead of the raw input.
+      const cardText = opts?.userCard === undefined ? userInput : opts.userCard;
+      if (tui && cardText && cardText.trim()) tui.flushUserCard(cardText);
       tui?.setContextUsage(historyTokens(history), contextTokens);
 
       // Per-turn steering inbox (gjc parity): additional queries typed mid-turn land
@@ -1548,7 +1591,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           maxTokens: sessionThinking ? thinkingMaxTokens(sessionThinking) : undefined,
           signal: ac.signal,
           steer: drainSteer,
-          events: wrapEvents({ ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone }, opik),
+          events: wrapEvents(withStepPersistence({ ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone }, persistTurnTail), opik),
         });
         if (result.done && looksLikeSkillEcho(result.doneReason ?? "", resolvedSkills)) {
           history.push({
@@ -1603,13 +1646,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       || (result.done
         ? `(done in ${result.steps} step${result.steps === 1 ? "" : "s"} — the model returned no summary)`
         : `(reached the ${result.steps}-step limit without signaling done)`);
-    // Full-fidelity persistence: append every message the engine added this turn
-    // (user prompt + intermediate tool-call/tool-result turns), then the final reply.
+    // Persist any messages this turn produced that onStep hasn't flushed yet (the
+    // final step's tool-call/result + any retry-loop messages), then the reply.
+    // Incremental onStep flushes already wrote the prompt and completed steps, so
+    // this only covers the tail — net content is the full turn either way.
     try {
-      if (sessionId) {
-        // One batched fs append for the whole turn (was: one awaited append per message).
-        await appendMessages(sessionId, history.slice(beforeLen), cwd);
-      }
+      await persistTurnTail();
       history.push({ role: "assistant", content: reply });
       if (sessionId) await appendMessage(sessionId, { role: "assistant", content: reply }, cwd);
       if (tui) tui.finish(reply);
@@ -1729,7 +1771,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         console.log(`▶ Running skill: ${inv.skill.name}${inv.intent ? ` — ${inv.intent}` : ""}`);
       }
       const task = buildSkillTask(inv.skill, inv.intent, inv.invokedAs);
-      const { reply, rendered, usage } = await runTurn(task, useOneShotTui);
+      const { reply, rendered, usage } = await runTurn(task, useOneShotTui, undefined, { userCard: null });
       if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
       else if (usage) console.log(usage.trim());
     };
@@ -1837,7 +1879,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // starts — skill name, resolved SKILL.md path, and the prompt size.
     {
       const card = formatForgeBox(
-        { title: "[skill]", lines: skillInvocationCard(skill) },
+        { title: "[skill]", lines: skillInvocationCard(skill, intent) },
         { width: Math.min(100, Math.max(40, (process.stdout.columns ?? 80) - 2)), unicode: supportsUnicode(), paint: accentPaint(uiTheme), paintShadow: accentShadowPaint(uiTheme), color: uiTheme.color },
       );
       logLines(card);
@@ -1918,7 +1960,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // final reply is the skill's result.
       if (!useTui) console.log(`▶ Running skill: ${skill.name}${intent ? ` — ${intent}` : ""}`);
       const task = buildSkillTask(skill, intent, invokedAs);
-      const { reply, rendered, usage } = await runTurn(task, useTui);
+      const { reply, rendered, usage } = await runTurn(task, useTui, undefined, { userCard: null });
       if (!rendered) console.log(`jeo> ${stripMarkdown(renderMarkdownTables(reply))}${usage}`);
       else if (usage) console.log(usage.trim());
     }
@@ -2299,6 +2341,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     }
   };
   let previewPending = false;
+  // Idle-prompt Ctrl+O detail panel: a REVERSIBLE, scrollable overlay drawn inside
+  // the footer reservation. Toggle open/closed with Ctrl+O; ↑↓/PgUp/PgDn scroll so
+  // long/CJK content is fully reachable (no "… N more" clip). null = closed.
+  let promptHistoryLines: string[] | null = null;
+  let promptHistoryScroll = 0;
+  let promptHistoryMaxScroll = 0;
+  let promptHistoryPage = 1;
 
   // Inline boxed-footer rendering with a FIXED reservation (the "@-mention typing
   // pushes the box down" fix). The footer reserves its full `footerRows` height
@@ -2450,6 +2499,44 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const preview = (slash.length ? slash : args).map(l => chalk.gray(truncateAnsi(l, cols)));
     return [statusBarLine(cols), "", ...input, ...preview].slice(0, footerRows);
   };
+  // Render the reversible Ctrl+O detail panel into the footer reservation: a status
+  // bar, a title (with scroll hint when needed), then a windowed slice of the detail
+  // with ↑/↓ counters. Recomputes the scroll bound/page size each paint so scroll
+  // keys can clamp correctly. Mirrors the mid-turn LaunchTui panel.
+  const historyPreviewLines = (detail: string[]): string[] => {
+    const cols = Math.max(24, (process.stdout.columns ?? 80) - 1);
+    const physical = detail.flatMap(line => line.split("\n")).map(line => truncateAnsi(line, cols));
+    const bodyLimit = Math.max(1, footerRows - 2); // status bar + title rows
+    const scrollable = physical.length > bodyLimit;
+    const cap = scrollable ? Math.max(1, bodyLimit - 2) : bodyLimit;
+    promptHistoryPage = cap;
+    promptHistoryMaxScroll = Math.max(0, physical.length - cap);
+    if (promptHistoryScroll > promptHistoryMaxScroll) promptHistoryScroll = promptHistoryMaxScroll;
+    const hint = scrollable ? "· ↑↓/PgUp/PgDn scroll · Ctrl+O closes" : "· Ctrl+O closes";
+    const title = `${uiAccent("history")} ${chalk.dim(hint)}`;
+    let body: string[];
+    if (!scrollable) {
+      body = physical;
+    } else {
+      const start = promptHistoryScroll;
+      const above = start;
+      const reserveTop = above > 0 ? 1 : 0;
+      let innerLimit = Math.max(1, bodyLimit - reserveTop - 1);
+      let win = physical.slice(start, start + innerLimit);
+      let below = physical.length - (start + win.length);
+      if (below === 0) {
+        innerLimit = Math.max(1, bodyLimit - reserveTop);
+        win = physical.slice(start, start + innerLimit);
+        below = physical.length - (start + win.length);
+      }
+      body = [];
+      if (above > 0) body.push(chalk.dim(`↑ ${above} more above`));
+      body.push(...win);
+      if (below > 0) body.push(chalk.dim(`↓ ${below} more below`));
+    }
+    footerCursor = { row: Math.min(1, footerRows - 1), col: 1 };
+    return [statusBarLine(cols), title, ...body].slice(0, footerRows);
+  };
   const drawFooter = (lines: string[]) => {
     if (!previewArmed || footerRendered === 0) return;
     // ALWAYS paint exactly footerRendered rows so the reservation is fully covered
@@ -2896,24 +2983,41 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         return;
       }
       if (!previewArmed || pickerActive) return;
-      // Ctrl+O: expand the last assistant response into scrollback for a full,
-      // scrollable read. The live-turn TUI path uses LaunchTui.showDetail(); this
-      // idle-prompt path prints the same content above a cleanly re-armed footer.
-      // (Cmd+O is intercepted by macOS/terminal and never reaches the app.)
+      // Ctrl+O: toggle a reversible, scrollable detail panel inside the footer
+      // (expand on the first press, FOLD on the next). ↑↓/PgUp/PgDn scroll it while
+      // open — long/CJK content is fully reachable, nothing is clipped. The live-turn
+      // path uses LaunchTui.showDetail(). (Cmd+O is intercepted by the terminal.)
       if (key?.ctrl && key.name === "o") {
+        if (promptHistoryLines) {
+          promptHistoryLines = null; // fold
+          drawFooter(previewLines(typedLine, navIdx));
+          return;
+        }
         const detail = composeDetailLines();
         if (detail.length === 0) return;
-        // Expand the last response into scrollback CLEANLY instead of cramming it
-        // into the ~10-row footer reservation (which clipped long/CJK content and
-        // could garble the box). Disarm → print full detail → re-arm + repaint is
-        // the same path the resize handler/main loop use, so the input box and the
-        // typed draft restore without corruption.
-        disarmPreview();
-        logLines(detail);
-        armPreview();
-        drawFooter(previewLines(typedLine, navIdx));
+        promptHistoryLines = detail;
+        promptHistoryScroll = 0;
+        drawFooter(historyPreviewLines(detail));
         return;
       }
+      // While the detail panel is open, arrows / PgUp / PgDn scroll it instead of
+      // navigating slash/history; every other key (below) closes it.
+      if (promptHistoryLines && key && (key.name === "up" || key.name === "down" || key.name === "pageup" || key.name === "pagedown")) {
+        const page = key.name === "pageup" || key.name === "pagedown";
+        const dir = key.name === "up" || key.name === "pageup" ? -1 : 1;
+        const step = page ? Math.max(1, promptHistoryPage - 1) : 1;
+        const next = Math.min(promptHistoryMaxScroll, Math.max(0, promptHistoryScroll + dir * step));
+        if (next !== promptHistoryScroll) {
+          promptHistoryScroll = next;
+          drawFooter(historyPreviewLines(promptHistoryLines));
+        }
+        return;
+      }
+      if (promptHistoryLines) {
+        // Any other key dismisses the panel, then falls through to normal handling.
+        promptHistoryLines = null;
+        drawFooter(previewLines(typedLine, navIdx));
+      }
       // Ctrl+V: attach a clipboard IMAGE to the next message. Terminal text paste
       // never arrives as a ctrl+v keypress (it streams as plain stdin data), so this
       // binding is image-only; when the clipboard holds no image it's a silent no-op.
@@ -2956,7 +3060,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         if (!previewArmed) return;
         try {
           if (key && (key.name === "return" || key.name === "enter")) {
-            drawFooter([]);
+            // Redraw the REAL box (not drawFooter([]), which erases it): this runs in a
+            // setImmediate and can fire AFTER the loop already re-armed + repainted the box
+            // for the next prompt (slash command / turn). An empty draw there wiped the fresh
+            // box and parked the cursor at the reservation top — the "input box vanishes and
+            // the caret leaves the prompt after a command" bug. Drawing previewLines keeps the
+            // box present and the caret in it whether this fires before submit or after re-arm.
+            drawFooter(previewLines(typedLine, navIdx));
             return;
           }
           // Arrow up/down: move the highlight over the slash keyword preview list.
@@ -3016,7 +3126,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       try {
         disarmPreview();
         armPreview();
-        drawFooter(previewLines(typedLine, navIdx));
+        drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
       } catch { /* ignore resize render races */ }
     };
     process.stdout.on("resize", idleResizeHandler);
@@ -3055,6 +3165,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // window where the box is gone and keystrokes echo nowhere (the "no response
       // after the result" gap). readline's own echo stays gated while armed.
       armPreview();
+      promptHistoryLines = null; // each fresh prompt starts with the Ctrl+O panel closed
       if (prefilledLine) {
         rli.line = prefilledLine;
         rli.cursor = prefilledLine.length;
@@ -3521,7 +3632,7 @@ 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();
         const explicitModel = tokens[1];
         // `/provider login|auth [name]` → run OAuth login from the REPL.
         if (name === "login" || name === "auth") {
@@ -3550,20 +3661,34 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           console.log(`Starting OAuth login for ${target}…`);
           try {
             const { email } = await interactiveOAuthLogin(target as AuthProvider, rl);
-            console.log(`[SUCCESS] OAuth login complete for ${target}${email ? ` (${email})` : ""}. Tokens saved to ~/.jeo/config.json.`);
+            // Tidy back to the initial query-input screen: the OAuth flow printed
+            // browser prompts / "waiting…" lines that clutter scrollback. Clear the
+            // screen + scrollback and re-render the welcome (same path as /clear),
+            // then a single concise confirmation. lastPickIndex is still seeded so
+            // `/model #N` works; the verbose live-model dump is dropped (it cluttered).
             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 or /provider ${target} #N${viaCatalog ? "  (live list endpoint rejected this token; 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}`);
-            }
+            if (forProvider.some(r => r.ok && r.models.length > 0)) lastPickIndex = flattenModels(forProvider);
+            // Tidy back to the initial query-input screen: the OAuth flow printed
+            // browser prompts / "waiting…" lines that clutter scrollback. emitLoginCleanup
+            // clears + re-renders the welcome (same path as /clear) then prints one
+            // confirmation; the verbose live-model dump is dropped (lastPickIndex is
+            // still seeded so /model #N works). Orchestration is unit-tested.
+            emitLoginCleanup(
+              {
+                clear: () => { disarmPreview(); process.stdout.write("\x1b[2J\x1b[3J\x1b[H"); },
+                write: line => console.log(line),
+              },
+              {
+                isTty: process.stdout.isTTY === true,
+                provider: target,
+                email,
+                ready: after?.ready ?? false,
+                label: after?.label,
+                welcomeLines: renderWelcome(welcomeData),
+              },
+            );
           } catch (err) {
             console.log(`[FAILED] ${(err as Error).message} — or set ${target.toUpperCase()}_API_KEY.`);
           }
@@ -3572,10 +3697,25 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const cfgNow = await readGlobalConfig();
         const statuses = await describeAllProviders(cfgNow);
         if (!name) {
-          console.log("Providers (credential · base URL):");
-          logLines(formatProviderPanel(statuses));
-          console.log("Switch with: /provider <name> [model]  ·  arrows+Enter picker: /provider <name>  ·  choose models: /model");
-          continue;
+          if (process.stdin.isTTY && process.stdout.isTTY) {
+            // gjc-style interactive picker (grouped ready / needs-setup, current marked)
+            // instead of a static text dump — arrows + Enter switch, Esc cancels.
+            const current = (await describeModel(sessionModel || cfgNow.defaultModel, cfgNow)).provider;
+            const items = buildProviderChoices(statuses, true, current).map(c => ({
+              value: c.value as string,
+              label: c.label,
+              hint: c.hint,
+              group: c.group,
+            }));
+            const picked = await pickFromOptions("Select a provider  ↑↓ move · Enter switch · Esc cancel", items);
+            if (!picked) { console.log("(switch cancelled)"); continue; }
+            name = picked.toLowerCase(); // fall through to the switch logic below
+          } else {
+            console.log("Providers (credential · base URL):");
+            logLines(formatProviderPanel(statuses));
+            console.log("Switch with: /provider <name> [model]  ·  choose models: /model");
+            continue;
+          }
         }
         if (!isProviderName(name)) {
           console.log(`Unknown provider '${name}'. Known: ${statuses.map(s => s.name).join(", ")}.`);

package/src/skills/catalog.ts

@@ -450,13 +450,20 @@ export async function loadSkills(cwd: string = process.cwd()): Promise<SkillDoc[
 /** gjc-style skill-invocation card body (the `[skill]` block shown in the TUI
  *  when `$name`//skill runs): name, resolved SKILL.md path (or the bundled
  *  module path), and the prompt size actually injected. Pure — testable. */
-export function skillInvocationCard(skill: SkillDoc): string[] {
+export function skillInvocationCard(skill: SkillDoc, intent?: string): string[] {
   const promptLines = (skill.raw ?? skill.details ?? "").split("\n").filter(l => l.trim().length > 0).length;
   // jeo-ref tree-connector detail: the skill name leads, resolved metadata hangs
-  // off ├─/└─ connectors so the card scans like the reference's Skill panel.
+  // off ├─/└─ connectors so the card scans like the reference's Skill panel. The
+  // intent (when given) is shown here so it isn't lost — the injected SKILL.md is
+  // NOT echoed as a user box (gjc-style: compact card, not the raw doc).
+  const trimmedIntent = intent?.trim();
+  const intentLine = trimmedIntent
+    ? [`├─ intent: ${trimmedIntent.length > 88 ? `${trimmedIntent.slice(0, 87)}…` : trimmedIntent}`]
+    : [];
   return [
     `Skill: ${skill.name}`,
     `├─ path: ${skill.sourcePath ?? `(bundled) src/prompts/skills/${skill.name}/SKILL.md`}`,
+    ...intentLine,
     `└─ prompt: ${promptLines} lines`,
   ];
 }

package/src/tui/app.ts

@@ -21,7 +21,7 @@ import { evolutionTrack, createStageProgress, type StageProgress, transitionMess
 import type { TaskSubEvent } from "../agent/task-tool";
 import { supportsUnicode } from "./components/capability";
 import { centerBlock, padLineTo, boxBlock, BOX_ASCII, BOX_UNICODE } from "./components/layout";
-import { SECTION_GAP, stackSections } from "./components/section";
+import { SECTION_GAP, sectionLabel, stackSections } from "./components/section";
 import { resolveTheme, themeGradient, accentPaint, accentShadowPaint, diffPaint, mutedPaint, cardFillPaint } from "./components/themes";
 import { detectColorLevel, animatedGradientText, ColorLevel } from "./components/color";
 import { formatForgeBox, summarizeForgeInvocation, summarizeForgeResult, fitForgeBoxes, webSearchCardLines, type ForgeSummary } from "./components/forge";
@@ -414,12 +414,21 @@ export class LaunchTui {
         this.thinking = false; // model replied; now dispatching the tool
         this.retryNotice = null; // the call got through — clear any backoff notice
         // Flush the streamed reasoning once into scrollback as a jeo-ref reasoning
-        // block — the agent NAME on its own accent line, the prose below it (the
-        // durable record) — then stop showing the transient live reasoning row.
+        // block — a muted "Reasoning" divider header, the prose below it (the durable
+        // record) — then stop showing the transient live reasoning row.
         if (this.streamingReasoning && this.streamingReasoning !== this.flushedReasoning) {
           this.flushedReasoning = this.streamingReasoning;
-          const name = this.theme.color ? chalk.bold(accentPaint(this.theme)("jeo")) : "jeo";
-          this.appendLedger(`${name}\n${this.streamingReasoning}\n`, "reasoning");
+          // A muted "Reasoning" card-header divider announces the reasoning block
+          // boundary (consistent with the section design tokens — Thinking/Reasoning/
+          // Output share one visual language); the prose below it is the durable record.
+          // A full-width divider ROW respects appendLedger's 1-line=1-row pre-wrap
+          // invariant (no per-line prefix), unlike a left-border enclosure which would
+          // push wrapped lines past `cols` and tear the frame.
+          const header = sectionLabel("Reasoning", Math.max(20, size().cols), {
+            color: this.theme.color,
+            unicode: this.unicode,
+          });
+          this.appendLedger(`${header}\n${this.streamingReasoning}\n`, "reasoning");
         }
         this.streamingReasoning = "";
         this.streamingThought = "";
@@ -766,6 +775,15 @@ export class LaunchTui {
       // (e.g. "rate limited (HTTP 429) — auto-retry #2 in 4s") instead of an opaque
       // ever-growing "calling model (18.4s)…".
       if (this.retryNotice) return `${this.retryNotice} (${elapsed}s)`;
+      // Reasoning is streaming → the live thought block already shows it; label the row.
+      if (this.streamingThought.trim() || this.streamingReasoning.trim()) {
+        return `reasoning (${this.footer.model}) (${elapsed}s)…`;
+      }
+      // No tokens after a few seconds: the model is almost certainly reasoning
+      // server-side (e.g. OpenAI hidden reasoning), NOT hung — say so instead of a
+      // frozen "calling model …" so a long silent wait still reads as progress.
+      const waited = this.currentStepStartedAt ? (Date.now() - this.currentStepStartedAt) / 1000 : 0;
+      if (waited >= 8) return `thinking (${this.footer.model}) — reasoning, no token stream yet (${elapsed}s)…`;
       return `calling model (${this.footer.model}) (${elapsed}s)…`;
     }
     if (running) {
@@ -1227,7 +1245,7 @@ export class LaunchTui {
       // (duplicate model bar) is gone; height now toggles only at lifecycle boundaries.
       const ROWS = 6;
       const shown = wrapped.slice(-ROWS);
-      tail.push(dim(`${this.unicode ? "│" : "|"} thinking`));
+      tail.push(sectionLabel("Thinking", Math.max(8, Math.min(120, cols)), { color: this.theme.color, unicode: this.unicode }));
       for (let k = 0; k < ROWS - shown.length; k++) tail.push("");
       for (const l of shown) tail.push(dim(`  ${l}`));
       tail.push("");
@@ -1246,7 +1264,7 @@ export class LaunchTui {
       // so cumulative stdout growth does not thrash the frame height.
       const ROWS = 8;
       const shown = wrapped.slice(-ROWS);
-      tail.push(dim(`${this.unicode ? "│" : "|"} output`));
+      tail.push(sectionLabel("Output", Math.max(8, Math.min(120, cols)), { color: this.theme.color, unicode: this.unicode }));
       for (let k = 0; k < ROWS - shown.length; k++) tail.push("");
       for (const l of shown) tail.push(dim(`  ${l}`));
       tail.push("");

package/src/tui/components/config-panel.ts

@@ -46,6 +46,35 @@ export function formatProviderPanel(statuses: ProviderStatus[]): string[] {
   });
 }
 
+/** Side-effect sinks for {@link emitLoginCleanup} — injected so the orchestration
+ *  (ordering + conditionals + the confirmation string) is unit-testable without a
+ *  real terminal. The caller wires `clear` to the actual screen+scrollback escape. */
+export interface LoginCleanupIO {
+  clear: () => void;
+  write: (line: string) => void;
+}
+export interface LoginCleanupOpts {
+  isTty: boolean;
+  provider: string;
+  email?: string;
+  ready: boolean;
+  label?: string;
+  welcomeLines: string[];
+}
+/** Tidy the screen after a successful `/provider login`: on a TTY clear the screen
+ *  and re-render the welcome (drops the OAuth flow's browser/"waiting…" noise — the
+ *  same path `/clear` uses), then print ONE confirmation line; off a TTY just the
+ *  confirmation. Pure orchestration over the injected IO. */
+export function emitLoginCleanup(io: LoginCleanupIO, opts: LoginCleanupOpts): void {
+  if (opts.isTty) {
+    io.clear();
+    io.write(opts.welcomeLines.join("\n"));
+  }
+  const who = opts.email ? ` (${opts.email})` : "";
+  const status = !opts.ready && opts.label ? ` — ${opts.label}` : "";
+  io.write(`✓ Logged in to ${opts.provider}${who}${status}. Pick a model with /model.`);
+}
+
 /** Subagent roster: ` id        title — model · thinking ≤N steps  (read-only)`. */
 export function formatAgentsPanel(
   roles: readonly SubagentRole[],

package/src/tui/components/evolution.ts

@@ -1,3 +1,4 @@
+import { ColorLevel, hexToRgb, lerpColor, fgEscape, bgEscape, resetEscape, stripAnsi } from "./color";
 import chalk from "chalk";
 
 /**
@@ -33,10 +34,10 @@ export const EVOLUTION_STAGE_COLORS: readonly ((s: string) => string)[] = [
 /** Spinner frame sets, one per evolution stage. */
 export const EVOLUTION_SPINNER_FRAMES: readonly string[][] = [
   [".   ", "..  ", "... ", "....", "... ", "..  "],
-  ["\u2801", "\u2802", "\u2804", "\u2808", "\u2810", "\u2820"],
-  ["|", "/", "-", "\\"],
+  ["\u2801", "\u2803", "\u2807", "\u2827", "\u2837", "\u283f", "\u283e", "\u283d", "\u283b", "\u2819", "\u2818", "\u2810"],
+  ["▲", "▶", "▼", "◀"],
   ["\u280b", "\u2819", "\u2839", "\u2838", "\u283c", "\u2834", "\u2826", "\u2827", "\u2807", "\u280f"],
-  ["\u25dc", "\u25dd", "\u25de", "\u25df"],
+  ["\u25f0", "\u25f3", "\u25f2", "\u25f1"],
 ];
 
 /**
@@ -303,3 +304,81 @@ export const EVOLUTION_TRANSITION_MESSAGES: readonly string[] = [
 export function transitionMessage(index: number): string {
   return EVOLUTION_TRANSITION_MESSAGES[clampStageIndex(index)]!;
 }
+/**
+ * Applies a dimensional, animated gradient (foreground or background) to a string of text.
+ * Driven by a phaseMs timestamp, it creates a slow, tasteful shimmer wave
+ * and adds depth cues (bright core, dimmer edges).
+ */
+export function applyDimensionalGradient(
+  text: string,
+  timeMs: number,
+  fromHex: string,
+  toHex: string,
+  level: ColorLevel,
+  isBg: boolean,
+  fgHex: string = "#ebebeb"
+): string {
+  const plain = stripAnsi(text);
+  if (level === ColorLevel.None || plain.length === 0) return plain;
+
+  const from = hexToRgb(fromHex);
+  const to = hexToRgb(toHex);
+  const fg = hexToRgb(fgHex);
+
+  const L = plain.length;
+  let out = "";
+  if (isBg) {
+    out += fgEscape(fg, level);
+  }
+
+  // Slow period: 4.5 seconds for a complete wave cycle
+  const p = (timeMs / 4500) % 1;
+
+  for (let i = 0; i < L; i++) {
+    const ch = plain[i]!;
+    if (!isBg && ch === " ") {
+      out += ch;
+      continue;
+    }
+
+    const x = L > 1 ? i / (L - 1) : 0;
+    const base = lerpColor(from, to, x);
+
+    // 3D depth cue: bright center (1.0), dimmer edges (0.75)
+    // Using a parabolic/sin curve
+    const depth = 0.75 + 0.25 * Math.sin(x * Math.PI);
+
+    // Shimmer highlight wave
+    // Shortest circular distance between position x and wave phase p
+    let dist = Math.abs(x - p);
+    if (dist > 0.5) dist = 1 - dist;
+
+    const waveWidth = 0.22;
+    const highlight = dist < waveWidth ? Math.cos((dist / waveWidth) * (Math.PI / 2)) : 0;
+
+    // Apply depth
+    let r = base.r * depth;
+    let g = base.g * depth;
+    let b = base.b * depth;
+
+    // Apply shimmer highlight (blending towards white)
+    const shimmerIntensity = 0.45;
+    r += (255 - r) * highlight * shimmerIntensity;
+    g += (255 - g) * highlight * shimmerIntensity;
+    b += (255 - b) * highlight * shimmerIntensity;
+
+    const rgb = {
+      r: Math.max(0, Math.min(255, Math.round(r))),
+      g: Math.max(0, Math.min(255, Math.round(g))),
+      b: Math.max(0, Math.min(255, Math.round(b))),
+    };
+
+    if (isBg) {
+      out += bgEscape(rgb, level) + ch;
+    } else {
+      out += fgEscape(rgb, level) + ch;
+    }
+  }
+
+  return out + resetEscape(level);
+}

package/src/tui/components/forge.ts

@@ -419,8 +419,8 @@ export function summarizeForgeResult(tool: string, success: boolean, output: str
     }
   }
   const lines = previewLines(body, success ? 5 : 10, success ? 600 : 1200);
+  lines.unshift(forgeDivider("Output"));
   if (normalized === "bash") {
-    lines.unshift(forgeDivider("Output"));
     if (exitNote) lines.push("", exitNote);
   }
   return {

package/src/tui/components/markdown-text.ts

@@ -74,33 +74,85 @@ export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {})
 
   const out: string[] = [];
   let inFence = false;
+  
+  // Track the type of the last pushed content line to manage rhythm
+  // Types: "empty" | "heading" | "blockquote" | "list" | "code" | "prose"
+  let lastType: "empty" | "heading" | "blockquote" | "list" | "code" | "prose" = "empty";
+
+  const ensureBlankLine = () => {
+    if (out.length > 0 && out[out.length - 1] !== "") {
+      out.push("");
+    }
+  };
+
   for (const line of text.split("\n")) {
-    if (/^```/.test(line.trim())) {
+    const trimmed = line.trim();
+    
+    // Check if we are toggling a code fence
+    if (/^```/.test(trimmed)) {
+      ensureBlankLine();
       inFence = !inFence;
-      continue; // drop the fence row itself (stripMarkdown parity)
+      lastType = inFence ? "code" : "empty";
+      continue;
     }
+
     if (inFence) {
-      out.push(line); // code bodies verbatim — never styled or reflowed
+      out.push(line); // code bodies verbatim
+      lastType = "code";
       continue;
     }
+
+    if (trimmed === "") {
+      ensureBlankLine();
+      lastType = "empty";
+      continue;
+    }
+
     const heading = line.match(/^(#{1,6})\s+(.+)$/);
     if (heading) {
-      // Vertical rhythm: a heading that follows content gets one blank line of
-      // breathing room above it (final-report readability), never a leading blank.
-      if (out.length > 0 && out[out.length - 1]!.trim() !== "") out.push("");
+      ensureBlankLine();
       out.push(accent(styleInline(heading[2]!)));
+      lastType = "heading";
       continue;
     }
+
     const quote = line.match(/^>\s+(.+)$/);
     if (quote) {
+      if (lastType !== "blockquote" && lastType !== "empty") {
+        ensureBlankLine();
+      }
       out.push(chalk.dim(`▎ ${styleInline(quote[1]!)}`));
+      lastType = "blockquote";
       continue;
     }
+
     if (/^[-\*_]{3,}\s*$/.test(line)) {
+      ensureBlankLine();
       out.push(chalk.dim("─".repeat(24)));
+      ensureBlankLine();
+      lastType = "empty";
+      continue;
+    }
+
+    // Check if list item
+    const isList = /^\s*([*\-+]\s|\d+\.\s)/.test(line);
+    if (isList) {
+      if (lastType !== "list" && lastType !== "empty") {
+        ensureBlankLine();
+      }
+      out.push(styleInline(line));
+      lastType = "list";
       continue;
     }
+
+    // Default prose line
+    if (lastType !== "prose" && lastType !== "empty" && lastType !== "list" && lastType !== "heading") {
+      // Transitioning from list/quote/code to prose -> ensure blank line
+      ensureBlankLine();
+    }
     out.push(styleInline(line));
+    lastType = "prose";
   }
+
   return out.join("\n").trim();
 }

package/src/tui/components/provider-picker.ts

@@ -16,14 +16,16 @@ export function providerHint(s: ProviderStatus, unicode = true): string {
   return parts.join(" \u00b7 ");
 }
 
-/** Build provider choices, ready providers first (stable within each group). */
-export function buildProviderChoices(statuses: ProviderStatus[], unicode = true): SelectItem<ProviderName>[] {
+/** Build provider choices, ready providers first (stable within each group). When
+ *  `current` is given, that provider's row is marked `· ● current` so the active
+ *  provider is obvious in the picker (gjc-style). */
+export function buildProviderChoices(statuses: ProviderStatus[], unicode = true, current?: ProviderName): SelectItem<ProviderName>[] {
   const sorted = [...statuses].sort((a, b) => (a.ready === b.ready ? 0 : a.ready ? -1 : 1));
   return sorted.map(s => ({
     value: s.name,
     label: `${s.name} (${companyLabel(s.name)})`,
     group: s.ready ? "ready" : "needs setup",
-    hint: providerHint(s, unicode),
+    hint: s.name === current ? `${providerHint(s, unicode)} · ${unicode ? "●" : "*"} current` : providerHint(s, unicode),
   }));
 }
 

package/src/tui/components/section.ts

@@ -29,7 +29,10 @@ export interface SectionLabelOpts {
 export function sectionLabel(title: string, width: number, opts: SectionLabelOpts = {}): string {
   const unicode = opts.unicode !== false;
   const dash = unicode ? "─" : "-";
-  const head = `${dash.repeat(2)} ${title.trim()} `;
+  // A 3-dash lead-in makes the card header read as a distinct boundary (stronger than a
+  // single rule) without becoming loud.
+  const startDash = unicode ? "───" : "---";
+  const head = `${startDash} ${title.trim()} `;
   const headW = visibleWidth(head);
   const fill = Math.max(0, Math.trunc(width) - headW);
   const line = head + dash.repeat(fill);
@@ -59,12 +62,23 @@ export function stackSections(sections: Section[], opts: StackOptions): string[]
   const gap = Math.max(0, opts.gap ?? SECTION_GAP);
   const out: string[] = [];
   for (const section of sections) {
-    if (!section.lines.length) continue;
-    if (out.length) for (let i = 0; i < gap; i++) out.push("");
+    const lines = [...section.lines];
+    while (lines.length && lines[0] === "") {
+      lines.shift();
+    }
+    while (lines.length && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    if (!lines.length) continue;
+    if (out.length) {
+      for (let i = 0; i < gap; i++) out.push("");
+    }
     if (section.title) {
       out.push(sectionLabel(section.title, opts.width, { color: opts.color, unicode: opts.unicode }));
     }
-    for (const line of section.lines) out.push(line);
+    for (const line of lines) {
+      out.push(line);
+    }
   }
   return out;
 }

package/src/tui/components/spinner.ts

@@ -4,6 +4,7 @@ import { spinnerFramesFor, stageIndexForStep, clampStageIndex } from "./evolutio
  * Stage-aware spinner. Frames evolve with the agent's step against its budget,
  * sourced from the canonical evolution model so the spinner stays in lockstep
  * with the ASCII art, meter, and footer track.
+ * Enriched with 3D/dimensional quadrant and twisting braille helix elements.
  */
 export class Spinner {
   private defaultFrames: string[];

package/src/tui/components/status.ts

@@ -5,6 +5,7 @@ import { animatedGradientText, applyBgGradient, hexToRgb, visibleWidth, ColorLev
 import * as os from "node:os";
 import { formatUsage } from "./duration";
 import { formatCost } from "../../ai/pricing";
+import { applyDimensionalGradient, stageGradient, stageIndexForStep } from "./evolution";
 
 /**
  * One-row status bar pinned directly above the boxed input (gjc-layout parity):
@@ -100,7 +101,7 @@ export function renderStatusBar(d: StatusBarData): string {
   const level = d.colorLevel ?? (useColor ? ColorLevel.TrueColor : ColorLevel.None);
   const grad = d.gradient ?? { from: "#0a3d62", to: "#48dbfb" };
   const paintedLeft = useColor
-    ? applyBgGradient(left, hexToRgb(grad.from), hexToRgb(grad.to), level)
+    ? applyDimensionalGradient(left, Date.now(), grad.from, grad.to, level, true)
     : left;
   return `${paintedLeft}${" ".repeat(gap)}${right}`;
 }
@@ -151,9 +152,19 @@ export function renderJeoStatus(data: JeoStatusData): string[] {
   const elapsed = `${seconds(data.elapsedMs)}s`;
   let msg = data.message ?? "thinking through the next tool call";
   const level = data.colorLevel ?? (useColor ? ColorLevel.TrueColor : ColorLevel.None);
-  if (useColor && data.isThinking && level === ColorLevel.TrueColor && data.palette && data.palette.length > 0) {
-    const phase = data.phase ?? 0;
-    msg = animatedGradientText(msg, data.palette, phase, { colorLevel: level });
+  if (useColor && level !== ColorLevel.None && (data.isThinking !== false)) {
+    let fromHex = "#0a3d62";
+    let toHex = "#48dbfb";
+    if (data.palette && data.palette.length > 0) {
+      fromHex = data.palette[0]!;
+      toHex = data.palette[data.palette.length - 1]!;
+    } else {
+      const stageIdx = stageIndexForStep(data.step ?? 0, data.maxSteps ?? 25);
+      const grad = stageGradient(stageIdx);
+      fromHex = grad.from;
+      toHex = grad.to;
+    }
+    msg = applyDimensionalGradient(msg, Date.now(), fromHex, toHex, level, false);
   }
   const current = data.currentTool ? `forging ${data.currentTool}` : "forge idle";
   const stage = data.stage ? `${data.stage} · ` : "";
@@ -260,8 +271,19 @@ export function renderStatusBox(data: StatusBoxData): string[] {
     activity = cut + (unicode ? "…" : "...");
   }
   const plainActivityWidth = visibleWidth(activity);
-  if (useColor && data.isThinking && level === ColorLevel.TrueColor && data.palette && data.palette.length > 0) {
-    activity = animatedGradientText(activity, data.palette, data.phase ?? 0, { colorLevel: level });
+  if (useColor && level !== ColorLevel.None && (data.isThinking !== false)) {
+    let fromHex = "#0a3d62";
+    let toHex = "#48dbfb";
+    if (data.palette && data.palette.length > 0) {
+      fromHex = data.palette[0]!;
+      toHex = data.palette[data.palette.length - 1]!;
+    } else {
+      const stageIdx = stageIndexForStep(data.step ?? 0, data.maxSteps ?? 25);
+      const grad = stageGradient(stageIdx);
+      fromHex = grad.from;
+      toHex = grad.to;
+    }
+    activity = applyDimensionalGradient(activity, Date.now(), fromHex, toHex, level, false);
   }
   const escPad = esc
     ? " ".repeat(Math.max(1, cols - 1 - visibleWidth(headPlain) - plainActivityWidth - visibleWidth(esc))) + dim(esc)

package/src/tui/components/transcript.ts

@@ -131,6 +131,9 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
           : [];
     const toolCalls = calls.filter(c => c.tool !== "done");
     if (toolCalls.length > 0) {
+      if (lines.length > 0 && lines[lines.length - 1] !== "") {
+        lines.push("");
+      }
       // The matching `Tool [x] result (ok|fail)` user message follows; for a batch it
       // is ONE message with several blocks. Parse verdicts in call order.
       const next = messages[i + 1];
@@ -153,6 +156,9 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
           ? ""
           : m.content;
     if (!reason.trim()) continue;
+    if (lines.length > 0 && lines[lines.length - 1] !== "") {
+      lines.push("");
+    }
     lines.push(`${magentaBold(`jeo ${jeoMark}`)}`);
     lines.push(...clipBody(reason.trim(), bodyCap));
   }

package/src/util/retry.ts

@@ -61,6 +61,15 @@ export function defaultRetryable(err: unknown): boolean {
     return true;
   }
 
+  // Transient empty 200s — a provider returned a successful response with no content.
+  // This is a known intermittent failure (load/edge races on Anthropic/Gemini/OpenAI), so
+  // retry it like an overload instead of letting one empty reply drop the turn. EXCEPTION:
+  // deterministic budget exhaustion (max_tokens / length / "output budget exhausted") re-empties
+  // on every retry — fail fast so the caller sees the raise-maxTokens/lower-thinking hint.
+  if (lowerMessage.includes("returned no content")) {
+    return !/max_tokens|max_output_tokens|finish_reason=length|done_reason=length|output budget exhausted/.test(lowerMessage);
+  }
+
   // Numeric `.status` field (structured provider errors, fetch responses).
   if (typeof err === "object" && err !== null) {
     const status = (err as any).status;