jeo-code 0.5.15 → 0.6.0

package/CHANGELOG.md

@@ -6,6 +6,23 @@ 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.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._
+
+### Fixed
+- **`/resume` corrupted the screen on a TTY.** After picking a session the resumed transcript was dumped on top of whatever was on screen (picker remnants, the prior conversation, the live input frame), so replayed ANSI/forge boxes from the old session collided with the live layout. Resume now wipes the screen + scrollback and re-renders the welcome banner BEFORE replaying the transcript — the same proven path `/clear` uses — so the restored view is a single, intact screen (verified live: one input box, one status bar, no picker remnants).
+- **Ctrl+O at the prompt crammed the last response into the ~10-row footer**, clipping long/CJK content with "… N more line(s)" and risking a garbled box. Ctrl+O now expands the full last assistant response into scrollback (clean `disarm → print → re-arm` path), so it is fully scrollable and the input box + typed draft restore without corruption. Removed the now-dead footer history-panel machinery (`promptHistoryLines`, `historyPreviewLines`).
+
 ## [0.5.15] - 2026-06-16
 _`jeo update` now actually upgrades — bare command installs the latest release instead of just printing a manual command._
 

package/README.ja.md

@@ -150,11 +150,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[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.
-- **[0.5.11]** (2026-06-15) — Backspace on an empty prompt line no longer quits jeo.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -150,11 +150,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[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.
-- **[0.5.11]** (2026-06-15) — Backspace on an empty prompt line no longer quits jeo.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -150,11 +150,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[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.
-- **[0.5.11]** (2026-06-15) — Backspace on an empty prompt line no longer quits jeo.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -150,11 +150,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[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.
-- **[0.5.11]** (2026-06-15) — Backspace on an empty prompt line no longer quits jeo.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.5.15",
+  "version": "0.6.0",
   "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";
 
@@ -198,25 +199,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 +207,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,7 +226,7 @@ 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;
@@ -256,10 +242,10 @@ 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;
@@ -273,21 +259,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/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";
 
@@ -154,16 +154,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 {
@@ -191,7 +181,7 @@ export async function codexResponsesCall(messages: Message[], options: CallOptio
     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;
@@ -222,7 +212,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";
  
@@ -485,6 +486,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 +716,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 =
@@ -1440,6 +1452,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)
@@ -2061,6 +2074,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,7 +2299,6 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     }
   };
   let previewPending = false;
-  let promptHistoryLines: string[] | null = null;
 
   // Inline boxed-footer rendering with a FIXED reservation (the "@-mention typing
   // pushes the box down" fix). The footer reserves its full `footerRows` height
@@ -2426,22 +2450,6 @@ 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);
   };
-  const historyPreviewLines = (detail: string[]): string[] => {
-    const cols = Math.max(24, (process.stdout.columns ?? 80) - 1);
-    const title = `${uiAccent("history")} ${chalk.dim("· Ctrl+O closes")}`;
-    const budget = Math.max(0, footerRows - 2);
-    const physical = detail.flatMap(line => line.split("\n")).map(line => truncateAnsi(line, cols));
-    let body = physical;
-    if (physical.length > budget) {
-      const keep = Math.max(0, budget - 1);
-      body = physical.slice(0, keep);
-      body.push(chalk.gray(`… ${physical.length - keep} more line(s)`));
-    } else {
-      body = physical.slice(0, budget);
-    }
-    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
@@ -2888,23 +2896,24 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         return;
       }
       if (!previewArmed || pickerActive) return;
-      // Ctrl+O: toggle a reversible history/detail panel. The live-turn TUI path
-      // uses LaunchTui.showDetail(); this idle-prompt path paints the same content
-      // into the fixed footer reservation, so the second Ctrl+O can close it.
+      // 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.)
       if (key?.ctrl && key.name === "o") {
-        if (promptHistoryLines) {
-          promptHistoryLines = null;
-          drawFooter(previewLines(typedLine, navIdx));
-          return;
-        }
         const detail = composeDetailLines();
         if (detail.length === 0) return;
-        promptHistoryLines = detail;
-        drawFooter(historyPreviewLines(detail));
+        // 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));
         return;
       }
-      if (promptHistoryLines) promptHistoryLines = null;
       // 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.
@@ -2947,7 +2956,6 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         if (!previewArmed) return;
         try {
           if (key && (key.name === "return" || key.name === "enter")) {
-            promptHistoryLines = null;
             drawFooter([]);
             return;
           }
@@ -3008,7 +3016,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       try {
         disarmPreview();
         armPreview();
-        drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
+        drawFooter(previewLines(typedLine, navIdx));
       } catch { /* ignore resize render races */ }
     };
     process.stdout.on("resize", idleResizeHandler);
@@ -3064,6 +3072,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) {
@@ -3221,6 +3231,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
                   if (rli.history[0] !== p) rli.history.unshift(p);
                 }
               }
+              // Clean restore: wipe the screen + scrollback BEFORE replaying the
+              // transcript so it can't collide with picker remnants, the prior
+              // conversation, or the live input frame — the "/resume corrupts the
+              // TUI" fix. Same proven path as /clear; re-render the welcome banner
+              // so the resumed view reads like a fresh, intact screen.
+              if (process.stdout.isTTY) {
+                disarmPreview();
+                process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+                console.log(renderWelcome(welcomeData).join("\n"));
+              }
               const sep = "─".repeat(Math.min(48, Math.max(20, (process.stdout.columns ?? 80) - 1)));
               logLines([
                 sep,

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/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();
   }
 
@@ -1085,20 +1105,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));