jeo-code 0.5.16 → 0.6.1

package/CHANGELOG.md

@@ -6,6 +6,31 @@ 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.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._
+
+### Added
+- **Durable input history.** ↑/↓ at the prompt now recall "이전에 사용한 쿼리" across launches, not just lines typed in the current run: submitted prompts persist to a per-workspace `.jeo/input-history` file (deduped, capped, best-effort) and hydrate readline's ring on the next launch. Composes with `/resume`, which already seeds the resumed session's own prompts into the ring. New `src/agent/input-history.ts` (`loadInputHistory`/`appendInputHistory`).
+
+### Fixed
+- **`/resume` dumped raw JSON and broke the TUI.** When a resumed session's assistant turn was stored as a ```json-fenced (or reasoning-decorated) tool call, the transcript renderer's naive `JSON.parse` failed and dumped the raw JSON block into the screen. `formatTranscript` now uses the engine's robust extractor (`tryExtractJsonObject`) and only treats a message as a tool call when it actually begins with `{` (after stripping a leading fence) — so fenced/decorated tool calls render as proper `✔ title` cards, prose that merely contains JSON stays prose, and no raw JSON ever leaks into the resumed view.
+- **Ctrl+O while a turn runs cropped the detail panel** at "… N more line(s)", so a long reply / tool output (especially CJK) couldn't be read past the first screenful. The live panel now WINDOWS the content with `↑ N more above` / `↓ N more below` counters and is scrollable with ↑/↓ and PgUp/PgDn — every line is reachable, nothing is dropped, and short content still renders as a plain non-scrollable panel. The in-flight key harness routes arrow/PageUp/PageDown to a new `onScrollKey` hook (a no-op when the panel is closed, so those keys stay inert otherwise); `LaunchTui.scrollDetail()` clamps within `[0, max]` and guarantees the last line is reachable. Mirrors the 0.5.16 idle-prompt Ctrl+O fix for the mid-turn path.
+
 ## [0.5.16] - 2026-06-16
 _`/resume` and Ctrl+O no longer corrupt the TUI — clean screen restore + scrollback expand._
 

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.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.
-- **[0.5.12]** (2026-06-15) — Yellow status animation while a process runs, and elapsed `(Nms)` on every completed tool card.
 
 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.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.
-- **[0.5.12]** (2026-06-15) — Yellow status animation while a process runs, and elapsed `(Nms)` on every completed tool card.
 
 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.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.
-- **[0.5.12]** (2026-06-15) — Yellow status animation while a process runs, and elapsed `(Nms)` on every completed tool card.
 
 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.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.
-- **[0.5.12]** (2026-06-15) — Yellow status animation while a process runs, and elapsed `(Nms)` on every completed tool card.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/input-history.ts

@@ -0,0 +1,79 @@
+/**
+ * Cross-launch input-history persistence for the interactive prompt.
+ *
+ * readline only remembers lines typed in the CURRENT run, so ↑ at the prompt
+ * recalled nothing on a fresh launch (and only this-run prompts otherwise). This
+ * persists submitted prompts to a per-workspace file so ↑ recalls "previously
+ * used queries" across launches — the same recall a shell gives you — and it
+ * composes with `/resume`'s in-session seeding (gjc-style durable input history).
+ *
+ * Pure filesystem helpers, kept tiny and best-effort: a read/write failure never
+ * breaks the prompt. The file is newline-delimited, oldest→newest on disk.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const FILE = "input-history";
+/** How many recent entries to hydrate into readline on launch. */
+export const HISTORY_LOAD_LIMIT = 200;
+/** Hard cap on the on-disk file so it can't grow without bound. */
+export const HISTORY_FILE_CAP = 1000;
+/** Skip persisting pathological single lines (giant pastes etc.). */
+const MAX_ENTRY_LEN = 2000;
+
+function jeoDir(cwd: string): string {
+  return path.join(cwd, ".jeo");
+}
+
+export function inputHistoryPath(cwd: string): string {
+  return path.join(jeoDir(cwd), FILE);
+}
+
+function readLines(cwd: string): string[] {
+  try {
+    return fs
+      .readFileSync(inputHistoryPath(cwd), "utf-8")
+      .split("\n")
+      .map(l => l.replace(/\s+$/, ""))
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load recent prompts NEWEST-FIRST, deduplicated, for readline's `rl.history`
+ * (which is itself newest-first). At most `limit` entries; never throws.
+ */
+export function loadInputHistory(cwd: string, limit = HISTORY_LOAD_LIMIT): string[] {
+  const lines = readLines(cwd); // oldest → newest
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (let i = lines.length - 1; i >= 0 && out.length < limit; i--) {
+    const line = lines[i]!;
+    if (seen.has(line)) continue;
+    seen.add(line);
+    out.push(line); // walking backward → already newest-first
+  }
+  return out;
+}
+
+/**
+ * Append one submitted prompt (best-effort, never throws). Skips blanks, the
+ * immediate duplicate of the last entry, multi-line/over-long pastes, and trims
+ * the file to `cap` lines so it stays bounded.
+ */
+export function appendInputHistory(cwd: string, line: string, cap = HISTORY_FILE_CAP): void {
+  try {
+    const entry = line.trim();
+    if (!entry || entry.includes("\n") || entry.length > MAX_ENTRY_LEN) return;
+    const existing = readLines(cwd);
+    if (existing.length > 0 && existing[existing.length - 1] === entry) return;
+    existing.push(entry);
+    const trimmed = existing.length > cap ? existing.slice(existing.length - cap) : existing;
+    fs.mkdirSync(jeoDir(cwd), { recursive: true });
+    fs.writeFileSync(inputHistoryPath(cwd), `${trimmed.join("\n")}\n`, "utf-8");
+  } catch {
+    /* best-effort: history persistence must never break the prompt */
+  }
+}

package/src/agent/tool-schemas.ts

@@ -130,3 +130,17 @@ export function serializeToolCalls(calls: { tool: string; arguments: Record<stri
 export function normalizeNativeToolName(name: string): string {
   return (name ?? "").replace(/^default_api\s*[.:]\s*/, "").trim();
 }
+
+/**
+ * Re-serialize a streamed native tool-call accumulator (name + raw-JSON-args string per
+ * output index — the shape every streaming adapter builds) into the engine's canonical
+ * JSON. Bad arg JSON degrades to `{}` rather than dropping the call. Returns null when empty.
+ */
+export function serializeAccumulatedToolCalls(acc: Map<number, { name: string; args: string }>): string | null {
+  const calls = [...acc.values()].map(b => {
+    let args: Record<string, unknown> = {};
+    try { args = b.args ? JSON.parse(b.args) : {}; } catch { args = {}; }
+    return { tool: b.name, arguments: args };
+  });
+  return serializeToolCalls(calls);
+}

package/src/ai/providers/anthropic.ts

@@ -3,6 +3,7 @@ import type { Credential } from "../../auth";
 import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { ProviderHttpError, parseRetryAfter, parseRetryFromBody, providerHttpError } from "./errors";
+import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 
 const ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 
@@ -71,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,
@@ -108,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
@@ -198,25 +222,6 @@ function emptyCompletionError(stopReason: string | undefined): Error {
   return new Error(`Anthropic returned no content${stopReason ? ` (stop_reason=${stopReason})` : ""}${hint}.`);
 }
 
-/**
- * Re-serialize Anthropic native `tool_use` content block(s) into the engine's canonical
- * JSON string — the linchpin of the adapter-internal-serialization design: the engine,
- * anti-spin guards, and done-gate keep consuming the SAME {"tool":...}/{"tools":[...]}
- * shape they parse from the JSON-in-prose path. A batched `done` is coalesced to a single
- * done envelope (the engine rejects done-in-batch). Returns null when there is no tool_use.
- */
-function serializeAnthropicToolUse(
-  content: { type: string; name?: string; input?: unknown }[],
-): string | null {
-  const calls = content
-    .filter(c => c.type === "tool_use" && typeof c.name === "string")
-    .map(c => ({ tool: c.name as string, arguments: (c.input ?? {}) as Record<string, unknown> }));
-  if (calls.length === 0) return null;
-  const done = calls.find(c => c.tool === "done");
-  if (done) return JSON.stringify(done);
-  if (calls.length === 1) return JSON.stringify(calls[0]);
-  return JSON.stringify({ tools: calls });
-}
 export const anthropicAdapter: ProviderAdapter = {
   name: "anthropic",
   supportsNativeTools: true,
@@ -225,7 +230,11 @@ export const anthropicAdapter: ProviderAdapter = {
     const result = (await response.json()) as { content: { type: string; text?: string; name?: string; input?: unknown }[]; stop_reason?: string; usage?: AnthropicUsage };
     if (result.usage) options.onUsage?.({ inputTokens: totalInputTokens(result.usage), outputTokens: result.usage.output_tokens });
     // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
-    const toolCall = serializeAnthropicToolUse(result.content);
+    const toolCall = serializeToolCalls(
+      result.content
+        .filter(c => c.type === "tool_use" && typeof c.name === "string")
+        .map(c => ({ tool: c.name as string, arguments: (c.input ?? {}) as Record<string, unknown> })),
+    );
     if (toolCall) return toolCall;
     const text = result.content.find(c => c.type === "text")?.text ?? "";
     if (!text) throw emptyCompletionError(result.stop_reason);
@@ -240,13 +249,13 @@ export const anthropicAdapter: ProviderAdapter = {
     // Native tool_use streams as content_block_start (name) + input_json_delta fragments,
     // never as text_delta — accumulate per block index, then re-serialize to canonical
     // JSON and yield it once at the end (concatenation still equals call()).
-    const toolBlocks = new Map<number, { name: string; json: string }>();
+    const toolBlocks = new Map<number, { name: string; args: string }>();
     for await (const data of readSse(response.body)) {
       let evt: {
         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 };
       };
@@ -256,13 +265,15 @@ export const anthropicAdapter: ProviderAdapter = {
         continue;
       }
       if (evt.type === "content_block_start" && evt.content_block?.type === "tool_use" && typeof evt.index === "number") {
-        toolBlocks.set(evt.index, { name: evt.content_block.name ?? "", json: "" });
+        toolBlocks.set(evt.index, { name: evt.content_block.name ?? "", args: "" });
       } else if (evt.type === "content_block_delta" && evt.delta?.type === "input_json_delta" && typeof evt.index === "number") {
         const b = toolBlocks.get(evt.index);
-        if (b) b.json += evt.delta.partial_json ?? "";
+        if (b) b.args += evt.delta.partial_json ?? "";
       } 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
@@ -273,21 +284,8 @@ export const anthropicAdapter: ProviderAdapter = {
         if (evt.usage) options.onUsage?.({ inputTokens: cachedInput, outputTokens: evt.usage.output_tokens });
       }
     }
-    if (toolBlocks.size > 0) {
-      const calls = [...toolBlocks.values()]
-        .map(b => {
-          let args: Record<string, unknown> = {};
-          try { args = b.json ? JSON.parse(b.json) : {}; } catch { args = {}; }
-          return { tool: b.name, arguments: args };
-        })
-        .filter(c => c.tool);
-      if (calls.length > 0) {
-        const done = calls.find(c => c.tool === "done");
-        const envelope = done ? JSON.stringify(done) : calls.length === 1 ? JSON.stringify(calls[0]) : JSON.stringify({ tools: calls });
-        yieldedAny = true;
-        yield envelope;
-      }
-    }
+    const envelope = serializeAccumulatedToolCalls(toolBlocks);
+    if (envelope) { yieldedAny = true; yield envelope; }
     if (!yieldedAny) throw emptyCompletionError(stopReason);
   },
 };

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

@@ -14,7 +14,7 @@ import type { Credential } from "../../auth";
 import type { CallOptions, Message } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
-import { serializeToolCalls } from "../../agent/tool-schemas";
+import { serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 
 export const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 
@@ -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 {
@@ -154,16 +165,6 @@ function accumulateResponsesToolCall(acc: Map<number, { name: string; args: stri
   }
 }
 
-/** Re-serialize accumulated Responses function calls into the engine's canonical JSON. */
-function serializeResponsesToolCalls(acc: Map<number, { name: string; args: string }>): string | null {
-  if (acc.size === 0) return null;
-  const calls = [...acc.values()].map(b => {
-    let args: Record<string, unknown> = {};
-    try { args = b.args ? JSON.parse(b.args) : {}; } catch { args = {}; }
-    return { tool: b.name, arguments: args };
-  });
-  return serializeToolCalls(calls);
-}
 
 /** Round-5 #1: no-text completions surface their cause instead of returning "". */
 function emptyCompletionError(reason: string | undefined): Error {
@@ -185,13 +186,14 @@ 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;
     if (ev.error) throw new Error(`OpenAI Codex response failed: ${ev.error}`);
   }
   // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
-  const envelope = serializeResponsesToolCalls(toolAcc);
+  const envelope = serializeAccumulatedToolCalls(toolAcc);
   if (envelope) return envelope;
   if (!out) throw emptyCompletionError(incompleteReason);
   return out;
@@ -212,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;
@@ -222,7 +225,7 @@ export async function* codexResponsesStream(
     if (ev.error) throw new Error(`OpenAI Codex response failed: ${ev.error}`);
   }
   // Native tool calls have no output_text deltas — yield the re-serialized envelope once.
-  const envelope = serializeResponsesToolCalls(toolAcc);
+  const envelope = serializeAccumulatedToolCalls(toolAcc);
   if (envelope) { yieldedAny = true; yield envelope; }
   if (!yieldedAny) throw emptyCompletionError(incompleteReason);
 }

package/src/ai/providers/openai.ts

@@ -3,7 +3,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
-import { serializeToolCalls } from "../../agent/tool-schemas";
+import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 
 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;
@@ -129,15 +129,8 @@ export const openaiAdapter: ProviderAdapter = {
       if (chunk.usage) options.onUsage?.({ inputTokens: chunk.usage.prompt_tokens, outputTokens: chunk.usage.completion_tokens });
     }
     // Native tool calls stream as tool_calls argument fragments — re-serialize once at end.
-    if (toolAcc.size > 0) {
-      const calls = [...toolAcc.values()].map(b => {
-        let args: Record<string, unknown> = {};
-        try { args = b.args ? JSON.parse(b.args) : {}; } catch { args = {}; }
-        return { tool: b.name, arguments: args };
-      });
-      const envelope = serializeToolCalls(calls);
-      if (envelope) { yieldedAny = true; yield envelope; }
-    }
+    const envelope = serializeAccumulatedToolCalls(toolAcc);
+    if (envelope) { yieldedAny = true; yield envelope; }
     if (!yieldedAny) throw emptyCompletionError(finishReason);
   },
 };

package/src/commands/launch.ts

@@ -63,6 +63,7 @@ import { renderStatusBar } from "../tui/components/status";
 import { detectColorLevel, ColorLevel } from "../tui/components/color";
 import { readClipboardImage } from "../util/clipboard-image";
 import { formatTranscript } from "../tui/components/transcript";
+import { loadInputHistory, appendInputHistory } from "../agent/input-history";
 import type { ImageAttachment } from "../ai/types";
 import { renderMarkdownTables } from "../tui/components/markdown-table";
  
@@ -141,6 +142,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;
 }
 
@@ -485,6 +492,9 @@ interface AbortHarnessOptions {
    *  Without this hook the byte would be swallowed into the buffered input queue,
    *  which is why Ctrl+O historically "did nothing" while the TUI owned stdin. */
   onDetailKey?: () => void;
+  /** Invoked when an arrow / PageUp / PageDown key arrives mid-turn — scrolls the
+   *  open Ctrl+O detail panel. dir -1 = up/back, +1 = down/forward; page = full jump. */
+  onScrollKey?: (dir: -1 | 1, page: boolean) => void;
   /** Invoked with printable keyboard input received while the live turn owns stdin. */
   onBufferedInput?: (chunk: string) => void;
   /** True while the input queue is inside a bracketed paste (mid-paste chunks
@@ -712,6 +722,14 @@ export function createInFlightAbortHarness(opts: AbortHarnessOptions = {}): InFl
       opts.onDetailKey?.();
       return;
     }
+    // Arrow / PageUp / PageDown — scroll the open Ctrl+O detail panel. Exact-match
+    // (whole chunk) like Ctrl+O so embedded sequences in pasted/streamed data don't
+    // trigger; bracketed paste already returned above. When the panel is closed the
+    // hook is a no-op, so these keys stay inert mid-turn as before.
+    if (text === "\u001b[A") { opts.onScrollKey?.(-1, false); return; }
+    if (text === "\u001b[B") { opts.onScrollKey?.(1, false); return; }
+    if (text === "\u001b[5~") { opts.onScrollKey?.(-1, true); return; }
+    if (text === "\u001b[6~") { opts.onScrollKey?.(1, true); return; }
     const escAt = text.indexOf("\u001b");
     const sigintAt = text.indexOf("\u0003");
     const controlAt =
@@ -1299,6 +1317,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[] => {
@@ -1360,7 +1391,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;
@@ -1377,6 +1413,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
@@ -1401,17 +1448,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
@@ -1440,6 +1494,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           if (lines.length === 0) return;
           tui.showDetail(lines);
         },
+        onScrollKey: (dir, page) => tui?.scrollDetail(dir, page),
         onBufferedInput: chunk => {
           if (!tui) return;
           // gjc-style mid-turn steering: a typed Enter (outside a bracketed paste)
@@ -1535,7 +1590,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({
@@ -1590,13 +1645,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);
@@ -1716,7 +1770,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());
     };
@@ -1824,7 +1878,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);
@@ -1905,7 +1959,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());
     }
@@ -2061,6 +2115,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     completer: (line: string) => readlineCompleter(line, completionContext()),
   });
   activeRl = rl; // wire the input filter's empty-line backspace guard to the live buffer
+  // Cross-launch input history: hydrate readline's ↑/↓ ring with prompts from
+  // previous sessions in this workspace, so a fresh launch can recall "이전에
+  // 사용한 쿼리" — not just lines typed in the current run. readline keeps history
+  // newest-first, which is exactly the order loadInputHistory returns.
+  if (process.stdin.isTTY) {
+    const rliHist = rl as unknown as { history?: string[] };
+    if (Array.isArray(rliHist.history)) {
+      for (const entry of loadInputHistory(cwd)) {
+        if (!rliHist.history.includes(entry)) rliHist.history.push(entry);
+      }
+    }
+  }
   const promptStdin = process.stdin as typeof process.stdin & { isRaw?: boolean; setRawMode?(raw: boolean): void };
   const promptWasRaw = !!promptStdin.isRaw;
   let promptRawChanged = false;
@@ -2274,6 +2340,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
@@ -2425,6 +2498,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
@@ -2871,24 +2982,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.
@@ -2931,7 +3059,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.
@@ -2991,7 +3125,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);
@@ -3030,6 +3164,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;
@@ -3047,6 +3182,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       if (rawText.includes("\u0003")) forceExitFromCtrlC();
       const raw = rawText.trim();
       disarmPreview();
+      // Persist the submitted line so ↑ recalls it on a future launch (best-effort).
+      if (raw && process.stdin.isTTY) appendInputHistory(cwd, raw);
       // Pasted batch command: echo what is about to run (with the remaining queue
       // depth) so a multi-line paste reads as a visible, ordered script.
       if (promptServedFromPaste && raw) {

package/src/commands/update.ts

@@ -38,6 +38,9 @@ export interface UpdateDeps {
   install: (version?: string) => Promise<{ success: boolean; stdout?: string; stderr?: string }>;
   /** Display release notes after a successful self-update (best-effort, no-op in tests). */
   showWhatsNew?: () => void;
+  /** Version of the `jeo` actually on PATH, read after install to catch a silent no-op
+   *  (installed but PATH still points at a different/older binary). Optional in tests. */
+  activeVersion?: () => string | null;
 }
 
 export const defaultDeps: UpdateDeps = {
@@ -59,15 +62,41 @@ export const defaultDeps: UpdateDeps = {
     return pkg.version;
   },
   install: async (version?: string) => {
-    // Self-update the global install. jeo runs on Bun (see the `#!/usr/bin/env bun`
-    // shebang), so Bun is always present; `@<version>` (default `latest`) forces the
-    // newest publish even if a stale global is cached.
+    // Self-update the global install via the SAME toolchain it was installed with. jeo
+    // ships as a `#!/usr/bin/env bun` script so bun is the common case, but npm-installed
+    // globals exist too — try bun first, fall back to npm (and tolerate either missing).
+    // `@<version>` (the resolved latest) forces the newest publish past a stale global cache.
     const target = `jeo-code@${version ?? "latest"}`;
-    const proc = Bun.spawnSync(["bun", "install", "-g", target], {
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    return { success: proc.success };
+    const managers: string[][] = [
+      ["bun", "install", "-g", target],
+      ["npm", "install", "-g", target],
+    ];
+    let lastErr = "";
+    for (const cmd of managers) {
+      try {
+        const proc = Bun.spawnSync(cmd, { stdout: "inherit", stderr: "inherit" });
+        if (proc.success) return { success: true };
+        lastErr = `${cmd[0]} exited with code ${proc.exitCode}`;
+      } catch (err: any) {
+        lastErr = `${cmd[0]} unavailable: ${err?.message ?? String(err)}`;
+      }
+    }
+    return { success: false, stderr: lastErr };
+  }
+,
+  activeVersion: () => {
+    // Read the version of the `jeo` actually on PATH (may differ from this process's bundled
+    // version after a self-update, e.g. when bun installed to ~/.bun/bin but PATH prefers an
+    // npm global). Used to detect a silent "installed but PATH unchanged" no-op.
+    try {
+      const proc = Bun.spawnSync(["jeo", "--version"], { stdout: "pipe", stderr: "pipe" });
+      if (!proc.success) return null;
+      const out = new TextDecoder().decode(proc.stdout);
+      const m = out.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+      return m ? m[1] : null;
+    } catch {
+      return null;
+    }
   }
   ,
   showWhatsNew: () => {
@@ -193,6 +222,16 @@ export async function runUpdateCommandWith(args: string[], deps: UpdateDeps): Pr
             }));
           } else {
             console.log(`Successfully installed jeo-code@${latest}`);
+            // Verify the `jeo` on PATH actually picked up the new install — a bun-vs-npm or
+            // PATH mismatch can leave an older binary in front, which looks like "update did
+            // nothing". Surface that loudly with the manual fix instead of failing silently.
+            const active = deps.activeVersion?.();
+            if (active && latest && compareVersions(active, latest) < 0) {
+              console.warn(`Warning: installed ${latest}, but the active 'jeo' on PATH still reports ${active}.`);
+              console.warn(`Your PATH points at a different install. Fix it with one of:`);
+              console.warn(`  npm install -g jeo-code@${latest}`);
+              console.warn(`  bun install -g jeo-code@${latest}`);
+            }
             deps.showWhatsNew?.();
           }
         } else {

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

@@ -225,6 +225,12 @@ export class LaunchTui {
   // block above the heartbeat; pressing Ctrl+O again clears it and restores the
   // normal activity view. Kept as data, not scrollback text, so it can actually close.
   private historyLines: string[] | null = null;
+  // Ctrl+O detail panel scroll: a window offset so long/CJK content is fully
+  // reachable (↑↓/PgUp/PgDn) instead of clipped at "… N more". Bound + page size
+  // are recomputed each render from the visible body height.
+  private historyScroll = 0;
+  private historyMaxScroll = 0;
+  private historyPageSize = 1;
   // Kind of the last ledger entry — drives the gjc-reference vertical rhythm: a
   // blank line separates DIFFERENT ledger groups (card ↔ ✓-tool lines ↔ reasoning
   // ↔ notices), while same-kind lines (consecutive ✓ reads) stay adjacent.
@@ -543,9 +549,10 @@ export class LaunchTui {
     };
   }
 
-  /** Ctrl+O history/detail toggle, mid-turn: first press opens a live panel with
-   *  the full last reply / tool output, second press closes it and returns to the
-   *  normal activity frame. Unlike the old scrollback dump, this is reversible. */
+  /** Ctrl+O history/detail toggle, mid-turn: first press opens a SCROLLABLE live
+   *  panel with the full last reply / tool output, second press closes it and
+   *  returns to the normal activity frame. Reversible; the full content is reachable
+   *  via scrollDetail (↑↓/PgUp/PgDn) so nothing is lost to "… N more" clipping. */
   showDetail(lines: string[]): void {
     if (this.finished) return;
     if (this.historyLines) {
@@ -555,6 +562,19 @@ export class LaunchTui {
     }
     if (lines.length === 0) return;
     this.historyLines = lines;
+    this.historyScroll = 0;
+    this.draw();
+  }
+
+  /** Scroll the open Ctrl+O detail panel. dir -1 = up/back, +1 = down/forward;
+   *  `page` jumps a full visible body height. No-op when the panel is closed, so it
+   *  is safe to wire unconditionally to arrow/PgUp/PgDn keys. */
+  scrollDetail(dir: -1 | 1, page = false): void {
+    if (this.finished || !this.historyLines) return;
+    const step = page ? Math.max(1, this.historyPageSize - 1) : 1;
+    const next = Math.min(this.historyMaxScroll, Math.max(0, this.historyScroll + dir * step));
+    if (next === this.historyScroll) return;
+    this.historyScroll = next;
     this.draw();
   }
 
@@ -746,6 +766,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) {
@@ -1085,20 +1114,42 @@ export class LaunchTui {
     const inner = Math.max(10, boxWidth - 2);
     const accent = this.theme.color ? accentPaint(this.theme) : (s: string) => s;
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
-    const title = `${accent("history")} ${dim("· Ctrl+O closes")}`;
     const wrapped = this.historyLines.flatMap(line => {
       const physical = line.split("\n");
       return physical.flatMap(part => (visibleWidth(part) <= inner ? [part] : wrapTextWithAnsi(part, inner)));
     });
+    const bodyLimit = Math.max(1, maxRows - 4); // box borders (2) + title + divider
+    const scrollable = wrapped.length > bodyLimit;
+    // Window capacity at the bottom (worst case: both ↑ and ↓ indicators take a row),
+    // so the last line is always reachable by scrolling.
+    const cap = scrollable ? Math.max(1, bodyLimit - 2) : bodyLimit;
+    this.historyPageSize = cap;
+    this.historyMaxScroll = Math.max(0, wrapped.length - cap);
+    if (this.historyScroll > this.historyMaxScroll) this.historyScroll = this.historyMaxScroll;
+    const hint = scrollable ? "· ↑↓/PgUp/PgDn scroll · Ctrl+O closes" : "· Ctrl+O closes";
+    const title = `${accent("history")} ${dim(hint)}`;
     const header = [title, "DIVIDER"];
-    const bodyLimit = Math.max(0, maxRows - 2 - header.length);
-    let body = wrapped;
-    if (wrapped.length > bodyLimit) {
-      const keep = Math.max(0, bodyLimit - 1);
-      body = wrapped.slice(0, keep);
-      body.push(dim(`… ${wrapped.length - keep} more line(s)`));
+    let body: string[];
+    if (!scrollable) {
+      body = wrapped;
     } else {
-      body = wrapped.slice(0, bodyLimit);
+      // Window the content and show ↑/↓ counters instead of dropping the tail at
+      // "… N more": every line is reachable via scrollDetail (arrows / PgUp-PgDn).
+      const start = this.historyScroll;
+      const above = start;
+      const reserveTop = above > 0 ? 1 : 0;
+      let innerLimit = Math.max(1, bodyLimit - reserveTop - 1);
+      let win = wrapped.slice(start, start + innerLimit);
+      let below = wrapped.length - (start + win.length);
+      if (below === 0) {
+        innerLimit = Math.max(1, bodyLimit - reserveTop);
+        win = wrapped.slice(start, start + innerLimit);
+        below = wrapped.length - (start + win.length);
+      }
+      body = [];
+      if (above > 0) body.push(dim(`↑ ${above} more above`));
+      body.push(...win);
+      if (below > 0) body.push(dim(`↓ ${below} more below`));
     }
     return boxBlock([...header, ...body], boxWidth, {
       glyphs: this.unicode ? BOX_UNICODE : BOX_ASCII,

package/src/tui/components/transcript.ts

@@ -14,6 +14,7 @@
 import chalk from "chalk";
 import type { Message } from "../../ai/types";
 import { summarizeForgeInvocation } from "./forge";
+import { tryExtractJsonObject } from "../../agent/json";
 
 export interface TranscriptOptions {
   color?: boolean;
@@ -106,15 +107,20 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
       lines.push(...clipBody(m.content, bodyCap));
       continue;
     }
-    // assistant: one or more JSON tool calls (compact ledger lines) or a prose reply.
-    // Handles BOTH the single `{tool,arguments}` form AND the batched `{tools:[...]}`
-    // form — the batch case previously parsed to no `tool` field, fell through, and
-    // dumped the raw JSON object into the transcript (the "/resume shows JSON" bug).
-    let parsed: { tool?: unknown; tools?: unknown; arguments?: unknown } | null = null;
-    try {
-      const p: unknown = JSON.parse(m.content);
-      if (p && typeof p === "object") parsed = p as { tool?: unknown; tools?: unknown; arguments?: unknown };
-    } catch { /* prose reply */ }
+    // assistant: a JSON tool call (compact ledger lines) or a prose/done reply.
+    // A tool-call message IS a JSON object (optionally inside a ```json fence) — so
+    // only parse when the content actually begins with `{` after stripping a leading
+    // fence. This renders fenced/decorated tool calls as cards (the "/resume shows
+    // raw JSON and breaks the TUI" bug — naive JSON.parse failed on any fence and
+    // dumped the block) while prose that merely CONTAINS tool-like JSON stays prose.
+    const stripped = m.content.trim().replace(/^```(?:json)?[ \t]*\r?\n?/i, "").trimStart();
+    const looksLikeCall = stripped.startsWith("{");
+    const parsed = looksLikeCall
+      ? tryExtractJsonObject<{ tool?: unknown; tools?: unknown; arguments?: unknown }>(
+          m.content,
+          { preferKeys: ["tool", "tools"] },
+        )
+      : null;
     const calls: { tool: string; arguments?: unknown }[] =
       parsed && typeof parsed.tool === "string"
         ? [{ tool: parsed.tool, arguments: parsed.arguments }]
@@ -138,10 +144,14 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
       });
       continue;
     }
-    // A lone `done` (show its reason) or a plain prose reply.
-    const reason = parsed
-      ? String((parsed.arguments as { reason?: unknown } | undefined)?.reason ?? "")
-      : m.content;
+    // No tool calls → a lone `{tool:"done", reason}` (show its reason), a JSON object
+    // that isn't a renderable call (skip — never dump raw JSON), or genuine prose.
+    const reason =
+      parsed && parsed.tool === "done"
+        ? String((parsed.arguments as { reason?: unknown } | undefined)?.reason ?? "")
+        : looksLikeCall
+          ? ""
+          : m.content;
     if (!reason.trim()) continue;
     lines.push(`${magentaBold(`jeo ${jeoMark}`)}`);
     lines.push(...clipBody(reason.trim(), bodyCap));