jeo-code 0.6.30 → 0.6.31

package/CHANGELOG.md

@@ -6,6 +6,20 @@ 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.31] - 2026-06-19
+_Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification._
+
+### Added
+- **The prompt box now recolors the `/command` / `$skill` trigger token live as you type it.** While typing an invocation, the active trigger token (anywhere on the line, mention-style via `activeTriggerToken`) is repainted inside the input box so the user can SEE the trigger was recognized: a valid, matchable invocation turns neon green (`#39ff14`), while a typo with no match turns pink (`#ff6b81`) — a visual heads-up that it will be sent as plain text. Wired through a new `InputBoxOptions.highlight` ({start,end,paint}, code-point offsets over `Array.from(line)`) into both the idle prompt (`launch.ts` `previewLines`) and the mid-turn live box (`app.ts` `setLivePromptHighlight`, reset at each new turn). Scroll ellipses now use ANSI-safe `truncateToWidth` so a painted token never gets sliced mid-escape.
+- **Rich `/resume` session picker (gjc parity).** A new `src/tui/components/session-picker.ts` renders a search/filter line, a scrolling window of multi-line entries (title + dimmed first-message preview + a `relative-time · size · N msgs` metadata line), a position indicator, and Del-to-delete / Enter-to-resume / Esc-to-cancel hints. `SessionSummary` now carries `sizeBytes` for the metadata line.
+
+### Fixed
+- **Signature-only reasoning models now show a live Thinking block while the model thinks.** Models that reason internally and stream a `signature` but NO `thinking_delta` text (claude-opus-4-7/4-8) opened a thinking block that produced zero visible deltas, so the TUI's dimmed live "Thinking" trace never appeared — the response wait read as a frozen "calling model …". The Anthropic stream adapter now fires a new display-only `onReasoningStart` signal the instant a `thinking` / `redacted_thinking` block opens, and the TUI renders a live `Thinking · Ns` block with a `(thinking…)` placeholder that is replaced the moment any real thought or answer text streams. Replay/artifact capture is unchanged.
+
+### Verified
+- **`jeo --tmux` has no bun memory leak and stays responsive.** A real `--tmux` session flooded with ~30,000 SGR mouse-report sequences via `tmux send-keys` plateaus in RSS (147 → 246 MB asymptotically: +83 / +12 / +3 / +0.2 / +0.4 MB per 6k-report round → no per-event linear growth) and stays responsive afterward (`/model` preview renders in 14 ms with the trigger highlight intact). The mouse-report swallow guard drops the reports instead of buffering/echoing them.
+- **Full suite green:** `bun run typecheck` clean and `bun test` 1703 pass / 0 fail across 211 files (includes the new `test/input-box.test.ts`, `test/tui-app.test.ts`, and `test/session-picker.test.ts` highlight/picker coverage).
+
 ## [0.6.30] - 2026-06-19
 _gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down._
 

package/README.ja.md

@@ -200,11 +200,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 - **[0.6.29]** (2026-06-19) — Signature-only thinking-block replay (Anthropic opus-4-7/4-8), plus a tmux mouse-flood memory guard confirming `jeo --tmux` does not leak.
 - **[0.6.28]** (2026-06-19) — Signed thinking-block replay: native reasoning is now sent BACK to providers across steps/turns, restoring multi-step reasoning continuity (gajae parity).
 - **[0.6.27]** (2026-06-19) — Ponytail pass on the reasoning-tier mapper, plus a real-tmux verification of `jeo --tmux`.
-- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -200,11 +200,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 - **[0.6.29]** (2026-06-19) — Signature-only thinking-block replay (Anthropic opus-4-7/4-8), plus a tmux mouse-flood memory guard confirming `jeo --tmux` does not leak.
 - **[0.6.28]** (2026-06-19) — Signed thinking-block replay: native reasoning is now sent BACK to providers across steps/turns, restoring multi-step reasoning continuity (gajae parity).
 - **[0.6.27]** (2026-06-19) — Ponytail pass on the reasoning-tier mapper, plus a real-tmux verification of `jeo --tmux`.
-- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -200,11 +200,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 - **[0.6.29]** (2026-06-19) — Signature-only thinking-block replay (Anthropic opus-4-7/4-8), plus a tmux mouse-flood memory guard confirming `jeo --tmux` does not leak.
 - **[0.6.28]** (2026-06-19) — Signed thinking-block replay: native reasoning is now sent BACK to providers across steps/turns, restoring multi-step reasoning continuity (gajae parity).
 - **[0.6.27]** (2026-06-19) — Ponytail pass on the reasoning-tier mapper, plus a real-tmux verification of `jeo --tmux`.
-- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -200,11 +200,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.6.31]** (2026-06-19) — Live "Thinking" indicator for signature-only reasoning models (Anthropic opus-4-7/4-8), a live color cue when a `/command` or `$skill` trigger is recognized in the prompt, and a rich gjc-style `/resume` session picker — plus a fresh `jeo --tmux` no-leak re-verification.
 - **[0.6.30]** (2026-06-19) — gjc-style intermediate-judgment guard classification extracted from the engine loop, plus a re-verification that `jeo --tmux` does not leak bun memory or slow down.
 - **[0.6.29]** (2026-06-19) — Signature-only thinking-block replay (Anthropic opus-4-7/4-8), plus a tmux mouse-flood memory guard confirming `jeo --tmux` does not leak.
 - **[0.6.28]** (2026-06-19) — Signed thinking-block replay: native reasoning is now sent BACK to providers across steps/turns, restoring multi-step reasoning continuity (gajae parity).
 - **[0.6.27]** (2026-06-19) — Ponytail pass on the reasoning-tier mapper, plus a real-tmux verification of `jeo --tmux`.
-- **[0.6.26]** (2026-06-19) — The forge emblem is redrawn again as the mascot crayfish, foregrounding its signature pincer claws (집게).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/engine.ts

@@ -35,6 +35,7 @@ async function invokeCallLlm(history: Message[], options: {
   onRetry?: (attempt: number, err: unknown, delayMs: number) => void;
   onToken?: (delta: string) => void;
   onReasoning?: (delta: string) => void;
+  onReasoningStart?: () => void;
   onReasoningArtifact?: (artifact: import("../ai/types").ReasoningArtifact) => void;
   tools?: import("../ai/types").NativeToolSchema[];
 }): Promise<string> {
@@ -196,6 +197,10 @@ export interface AgentLoopEvents {
   /** Accumulated native reasoning/thinking text so far — drives a transient dimmed
    *  "thinking" view. Only requested when a consumer (TUI) attaches. */
   onReasoningStream?(textSoFar: string): void;
+  /** Fired once when the model opens an extended-thinking block (before/without any
+   *  thinking text). Lets the TUI show a live "thinking" indicator for signature-only
+   *  reasoning models (opus-4-7/4-8) whose wait would otherwise look frozen. */
+  onReasoningStart?(): void;
   /** Each provider-native reasoning ARTIFACT as it is captured (signature / thoughtSignature /
    *  reasoning item). Lets the final-reply path (launch.ts) persist artifacts for replay. */
   onReasoningArtifactStream?(artifact: import("../ai/types").ReasoningArtifact): void;
@@ -526,6 +531,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
               onUsage: u => { acc.inputTokens += u.inputTokens ?? 0; acc.outputTokens += u.outputTokens ?? 0; sawUsage = true; },
               onToken,
               onReasoning,
+              onReasoningStart: ev.onReasoningStart,
               onReasoningArtifact,
               // Make provider auto-retry visible: previously a rate-limited call sat in a
               // silent backoff wait, then surfaced "auto-retry was exhausted" with no trace

package/src/agent/session.ts

@@ -32,6 +32,8 @@ export interface SessionSummary {
   messageCount: number;
   preview: string;
   mtimeMs?: number;
+  /** Session file size in bytes (for the resume picker's metadata line). */
+  sizeBytes?: number;
   title?: string;
 }
 
@@ -288,6 +290,7 @@ export async function listSessions(cwd = process.cwd()): Promise<SessionSummary[
         messageCount,
         preview,
         mtimeMs: stat.mtimeMs,
+        sizeBytes: stat.size,
         title: header.title,
       });
     } catch {

package/src/ai/providers/anthropic.ts

@@ -353,8 +353,12 @@ export const anthropicAdapter: ProviderAdapter = {
         toolBlocks.set(evt.index, { name: evt.content_block.name ?? "", args: "" });
       } else if (evt.type === "content_block_start" && evt.content_block?.type === "thinking" && typeof evt.index === "number") {
         thinkBlocks.set(evt.index, { text: "" });
+        // Signal the thinking phase started so the UI shows a live "thinking" indicator
+        // even for signature-only models (opus-4-7/4-8) that stream NO thinking_delta text.
+        options.onReasoningStart?.();
       } else if (evt.type === "content_block_start" && evt.content_block?.type === "redacted_thinking" && evt.content_block.data) {
         // Redacted thinking carries opaque `data` directly (no deltas) — emit immediately.
+        options.onReasoningStart?.();
         options.onReasoningArtifact?.({ provider: "anthropic", model: options.model, redacted: evt.content_block.data });
       } else if (evt.type === "content_block_delta" && evt.delta?.type === "input_json_delta" && typeof evt.index === "number") {
         const b = toolBlocks.get(evt.index);

package/src/ai/types.ts

@@ -116,6 +116,11 @@ export interface CallOptions {
    *  answer text). Surfaced as a transient dimmed view; absent for models that emit no
    *  thought text. */
   onReasoning?: (delta: string) => void;
+  /** Fired ONCE when the model opens an extended-thinking block, before (or without) any
+   *  thinking-text deltas. Lets a UI show a live "thinking" indicator even for models
+   *  (e.g. claude-opus-4-7/4-8) that reason internally and stream NO visible thought text,
+   *  so the response wait does not look frozen. Display-only — carries no content. */
+  onReasoningStart?: () => void;
   /** Sink for provider-native reasoning ARTIFACTS captured during streaming (signature /
    *  thoughtSignature / reasoning item id+encrypted). Separate from `onReasoning` (display
    *  text) because these arrive on different SSE events and are opaque replay data. */

package/src/commands/launch.ts

@@ -45,6 +45,7 @@ import { openaiCompatDef, SUBSCRIPTION_PROVIDER_NAMES } from "../ai/providers/op
 
 import { allSubagentRoles, getSubagentRole, resolveSubagentModel, resolveSubagentMaxSteps, resolveSubagentThinking, parseMaxSteps, withSubagentSetting, clearSubagentSetting } from "../agent/subagents";
 import { SelectList, renderSelectList, type SelectItem } from "../tui/components/select-list";
+import { SessionPicker, renderSessionPicker } from "../tui/components/session-picker";
 import {
   formatModelLine,
   formatProviderPanel,
@@ -760,6 +761,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               queueBusyClear?.();
               tui.setLivePromptInput("");
               tui.setLivePromptHint([]);
+              tui.setLivePromptHighlight(undefined);
               if (classifyMidTurnLine(line) === "command") {
                 // Run it as a real COMMAND: queue it for immediate dispatch by the prompt
                 // loop and abort the turn (the same controller Esc uses). The abort ends a
@@ -798,6 +800,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             tui.setLivePromptHint(
               /^\s*[/$]/.test(draft) ? formatMidTurnHint(draft.trimStart(), completionContext(), 5) : [],
             );
+            tui.setLivePromptHighlight(triggerHighlight(expandSentinel(draft)));
           }
         },
         onAbortNotice: msg => {
@@ -1790,6 +1793,26 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     if (sessionId) { const hex = SESSION_BOX_ACCENTS[sessionBoxColorIdx]!; return { accent: hexPaint(hex), shadow: hexShadowPaint(hex) }; }
     return { accent: uiAccent, shadow: uiAccentShadow };
   };
+  // Recolor the active `/command` or `$skill` trigger token INSIDE the input box so a
+  // real invocation is visibly recognized as it is typed: neon green once the token
+  // resolves to ≥1 command/skill, caution pink while it matches none (a likely typo
+  // that would be sent as plain text). Offsets are code-point indices into the SAME
+  // string the box renders, so multi-byte preceding text stays aligned with the box's
+  // Array.from() char model. Returns undefined for colorless themes / no active trigger.
+  const TRIGGER_HL_VALID = "#39ff14";
+  const TRIGGER_HL_UNKNOWN = "#ff6b81";
+  const triggerHighlight = (
+    rendered: string,
+  ): { start: number; end: number; paint: (s: string) => string } | undefined => {
+    if (!uiTheme.color) return undefined;
+    const trigger = activeTriggerToken(rendered);
+    if (!trigger) return undefined;
+    const start = Array.from(rendered.slice(0, trigger.start)).length;
+    const end = start + Array.from(trigger.token).length;
+    const valid = slashPreviewMatches(rendered, skillSlashDetails, resolvedSkills).length > 0;
+    const hex = valid ? TRIGGER_HL_VALID : TRIGGER_HL_UNKNOWN;
+    return { start, end, paint: (s: string) => chalk.hex(hex)(s) };
+  };
   const refreshUiTheme = (): void => {
     uiTheme = resolveTheme(process.env);
     uiAccent = accentPaint(uiTheme);
@@ -1825,7 +1848,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const rli = rl as unknown as { line?: string; cursor?: number };
     const caret = rli.line === line && typeof rli.cursor === "number" ? rli.cursor : line.length;
     const { accent: boxAccent, shadow: boxShadow } = boxAccents(line);
-    const frame = renderInputFrame(expandSentinel(line), {
+    const rendered = expandSentinel(line);
+    const frame = renderInputFrame(rendered, {
       // Full terminal width (cols is already columns - 1, leaving the last column free
       // so a full-width row never wraps). Matches the live-turn box, user/forge cards,
       // and the welcome banner — all share this cols-1 width so nothing jumps on the
@@ -1841,6 +1865,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         : undefined,
       maxBodyRows: Math.max(1, footerRows - 7),
       cursor: caret,
+      highlight: triggerHighlight(rendered),
     });
     const input = frame.lines.map(l => truncateAnsi(l, cols));
     // jeo-ref layout: a blank spacer row between the status bar (row 0) and the
@@ -2930,26 +2955,71 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           if (arg) { await applyResume(arg); continue; }
           // No id → only sessions with a real conversation are resumable (every launch
           // creates an empty session; those are noise).
-          const sessions = (await listSessions(cwd)).filter(s => s.messageCount > 0);
-          if (sessions.length === 0) {
+          let pool = (await listSessions(cwd)).filter(s => s.messageCount > 0);
+          if (pool.length === 0) {
             console.log("(no saved sessions with history)");
             continue;
           }
-          // Interactive arrow-key picker on a TTY: ↑↓ to move, Enter to resume, Esc cancels.
+          // Interactive gjc-style picker on a TTY: type to filter, ↑↓/PgUp/PgDn to
+          // move, Enter resumes, Del deletes (press Del twice to confirm), Esc cancels.
           if (process.stdin.isTTY && process.stdout.isTTY) {
-            const items: SelectItem<string>[] = sessions.slice(0, 50).map(s => ({
-              value: s.id,
-              label: `${s.title ? `[${s.title}] ` : ""}${(s.preview || s.id).replace(/\s+/g, " ")}`.slice(0, 76) || s.id,
-              hint: `${s.messageCount} msgs${s.id === sessionId ? " · current" : ""}`,
-            }));
-            const picked = await pickFromOptions("Resume a session  ↑↓ move · Enter resume · Esc cancel", items);
-            if (picked) await applyResume(picked);
-            else console.log("(resume cancelled)");
+            // Loop so a delete refreshes the list and re-opens the picker in place.
+            for (;;) {
+              const picker = new SessionPicker(pool);
+              let action: { kind: "resume" | "delete"; id: string } | undefined;
+              let confirmDeleteId: string | undefined;
+              await runSelectPicker(
+                (cols, rows) => renderSessionPicker(picker, {
+                  title: "Resume a session",
+                  cols,
+                  rows: Math.max(8, rows),
+                  unicode: true,
+                  color: true,
+                  confirmDeleteId,
+                }),
+                (ch, key) => {
+                  if (key?.name === "up") { confirmDeleteId = undefined; picker.up(); return false; }
+                  if (key?.name === "down") { confirmDeleteId = undefined; picker.down(); return false; }
+                  if (key?.name === "pageup") { confirmDeleteId = undefined; picker.page(-1); return false; }
+                  if (key?.name === "pagedown") { confirmDeleteId = undefined; picker.page(1); return false; }
+                  if (key?.name === "escape" || (key?.ctrl && key.name === "c")) return true;
+                  if (key?.name === "delete") {
+                    const sel = picker.selected();
+                    if (!sel) return false;
+                    if (confirmDeleteId === sel.id) { action = { kind: "delete", id: sel.id }; return true; }
+                    confirmDeleteId = sel.id;
+                    return false;
+                  }
+                  if (key?.name === "return" || key?.name === "enter") {
+                    const sel = picker.selected();
+                    if (sel) { action = { kind: "resume", id: sel.id }; return true; }
+                    return false;
+                  }
+                  confirmDeleteId = undefined;
+                  if (key?.name === "backspace") { picker.backspace(); return false; }
+                  if (ch && ch >= " " && !key?.ctrl && !key?.meta) picker.typeChar(ch);
+                  return false;
+                },
+              );
+              if (!action) { console.log("(resume cancelled)"); break; }
+              if (action.kind === "resume") { await applyResume(action.id); break; }
+              // Delete: drop the file, refresh the pool, and re-open the picker.
+              const delId = action.id;
+              try {
+                const removed = await deleteSession(delId, cwd);
+                console.log(removed ? `(deleted session ${delId})` : `(session ${delId} already gone)`);
+              } catch (err) {
+                console.log(`! delete failed: ${(err as Error).message}`);
+              }
+              if (delId === sessionId) await startFreshSession("dropped current session");
+              pool = pool.filter(s => s.id !== delId);
+              if (pool.length === 0) { console.log("(no saved sessions with history)"); break; }
+            }
             continue;
           }
           // Non-TTY fallback: static list (resume with /session resume <id>).
           console.log("Saved sessions — resume with /session resume <id>:");
-          for (const s of sessions.slice(0, 15)) {
+          for (const s of pool.slice(0, 15)) {
             const marker = s.id === sessionId ? "*" : " ";
             console.log(` ${marker}${s.id}  (${s.messageCount} msgs)  ${s.title ? `[${s.title}] ` : ""}${s.preview}`);
           }

package/src/tui/app.ts

@@ -68,6 +68,9 @@ export interface AgentEventsLike {
   onUsage?(usage: { inputTokens: number; outputTokens: number }): void;
   onModelStream?(textSoFar: string): void;
   onReasoningStream?(textSoFar: string): void;
+  /** Fired once when the model opens an extended-thinking block — drives a live "thinking"
+   *  placeholder for signature-only reasoning models (opus-4-7/4-8) that stream no thought text. */
+  onReasoningStart?(): void;
   /** Per-artifact native reasoning replay records (signature / thoughtSignature / reasoning
    *  item). The TUI ignores these; launch.ts uses them to persist the final reply's artifacts. */
   onReasoningArtifactStream?(artifact: import("../ai/types").ReasoningArtifact): void;
@@ -247,6 +250,11 @@ export class LaunchTui {
    *  streams, then persisted once into scrollback as a "Thinking" block on commit so the
    *  model's reasoning stays visible above the answer (gjc "think → answer" parity). */
   private streamingThought = "";
+  /** True once the model opens an extended-thinking block this step. Signature-only
+   *  reasoning models (opus-4-7/4-8) stream NO thinking text, so without this flag the
+   *  live Thinking block never appears and the wait looks frozen. Drives a placeholder
+   *  Thinking block until real thought/answer text streams. Reset each step / on commit. */
+  private thinkingActive = false;
   /** Uniform live-activity text for the live status field (reasoning OR derived fallback). */
   private streamingActivity = "";
   /** Last stream-driven draw (ms epoch) — throttles per-delta repaints to ≤10/s. */
@@ -410,6 +418,7 @@ export class LaunchTui {
         this.retryNotice = null; // a new step starts a fresh model call
         this.streamingReasoning = ""; // fresh model response this step
         this.streamingThought = "";
+        this.thinkingActive = false;
         this.streamingActivity = "";
         this.flushedReasoning = "";
         this.flushedThought = "";
@@ -452,6 +461,14 @@ export class LaunchTui {
           this.draw();
         }
       },
+      onReasoningStart: () => {
+        // The model opened an extended-thinking block. Signature-only reasoning models
+        // (opus-4-7/4-8) stream no thinking text, so flag the thinking phase so the live
+        // Thinking block renders a placeholder instead of leaving the wait blank.
+        if (this.finished || this.thinkingActive) return;
+        this.thinkingActive = true;
+        this.draw();
+      },
       onAssistant: (_raw, invocation) => {
         this.thinking = false; // model replied; now dispatching the tool
         this.retryNotice = null; // the call got through — clear any backoff notice
@@ -484,6 +501,7 @@ export class LaunchTui {
         }
         this.streamingReasoning = "";
         this.streamingThought = "";
+        this.thinkingActive = false;
         this.streamingActivity = "";
         if (invocation && invocation.tool !== "done") {
           this.runningTool = true;
@@ -650,6 +668,18 @@ export class LaunchTui {
     this.draw();
   }
 
+  private livePromptHighlight?: { start: number; end: number; paint: (s: string) => string };
+  /** Recolor the active `/command`·`$skill` trigger token inside the mid-turn live
+   *  input box (idle-prompt parity). Caller supplies code-point offsets into the
+   *  draft text + a painter; undefined clears it. */
+  setLivePromptHighlight(hl?: { start: number; end: number; paint: (s: string) => string }): void {
+    if (this.finished) return;
+    const a = this.livePromptHighlight, b = hl;
+    if (a?.start === b?.start && a?.end === b?.end && (!a) === (!b)) return;
+    this.livePromptHighlight = hl;
+    this.draw();
+  }
+
   private livePromptHint: string[] = [];
   /** Mid-turn command/skill preview lines shown above the live input box, so a
    *  /command or $skill typed WHILE a turn runs visibly reacts (idle-prompt parity). */
@@ -672,6 +702,7 @@ export class LaunchTui {
       accentShadow: this.theme.color ? accentShadowPaint(this.theme) : undefined,
       placeholder: "Type your next message...",
       maxBodyRows: 2,
+      highlight: this.livePromptHighlight,
     });
     if (this.livePromptHint.length === 0) return box;
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
@@ -925,6 +956,7 @@ export class LaunchTui {
     this.lastLedgerKind = null; // fresh turn: no leading spacer before the first ledger line
     this.livePromptInput = ""; // fresh turn: no next-prompt draft yet
     this.livePromptHint = []; // fresh turn: no mid-turn command preview yet
+    this.livePromptHighlight = undefined; // fresh turn: no active trigger token
     this.subagentLive = null; // fresh turn: no nested subagent in flight
     this.activityLog.length = 0; // per-turn ring: timestamps are turn-relative
     this.spinner.updateStep(0, this.footer.maxSteps);
@@ -1382,6 +1414,13 @@ export class LaunchTui {
       const liveMs = this.currentStepStartedAt ? Date.now() - this.currentStepStartedAt : undefined;
       const liveLabel = liveMs !== undefined ? `Thinking · ${(liveMs / 1000).toFixed(1)}s` : "Thinking";
       tail.push(...this.renderLiveBlock(liveLabel, liveThink, cols, rows, 6, "Thinking"));
+    } else if (isThinking && this.thinkingActive) {
+      // Signature-only reasoning models (opus-4-7/4-8) open a thinking block but stream no
+      // thought text — show a live placeholder so the wait reads as active thinking, not a
+      // frozen screen. Replaced the instant any real thought/answer text streams (branch above).
+      const liveMs = this.currentStepStartedAt ? Date.now() - this.currentStepStartedAt : undefined;
+      const liveLabel = liveMs !== undefined ? `Thinking · ${(liveMs / 1000).toFixed(1)}s` : "Thinking";
+      tail.push(...this.renderLiveBlock(liveLabel, "(thinking…)", cols, rows, 6, "Thinking"));
     }
 
     // Live tool output (gjc-style streaming bash stdout): while a tool runs, its

package/src/tui/components/input-box.ts

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { BOX_ASCII, BOX_UNICODE, boxBlock } from "./layout";
-import { visibleWidth } from "./width";
+import { visibleWidth, truncateToWidth } from "./width";
 
 export interface InputBoxOptions {
   cols?: number;
@@ -18,6 +18,11 @@ export interface InputBoxOptions {
   /** Shadow painter for the bottom/right "shaded" edges; defaults to a dim accent.
    *  The lit-vs-shaded two-tone contrast gives the box visible depth. */
   accentShadow?: (s: string) => string;
+  /** Paint a contiguous CHARACTER range of the typed text (e.g. the active
+   *  `/command` or `$skill` trigger token) so the user sees the invocation is
+   *  recognized as it is typed. Offsets index `Array.from(line)` code points
+   *  ([start, end)). Ignored for the placeholder and when `color` is false. */
+  highlight?: { start: number; end: number; paint: (s: string) => string };
 }
 
 export interface InputFrame {
@@ -38,6 +43,7 @@ function wrapWithCursor(
   text: string,
   cursor: number,
   width: number,
+  highlight?: { start: number; end: number; paint: (s: string) => string },
 ): { rows: string[]; row: number; col: number } {
   const rows: string[] = [];
   let cur = "";
@@ -67,7 +73,8 @@ function wrapWithCursor(
       continue;
     }
     if (ch !== "") {
-      cur += rendered;
+      const lit = highlight && i >= highlight.start && i < highlight.end;
+      cur += lit ? highlight.paint(rendered) : rendered;
       curW += w;
     }
   }
@@ -95,7 +102,7 @@ export function renderInputFrame(line: string, opts: InputBoxOptions = {}): Inpu
     rows = [placeholder];
     placeholderRow = true;
   } else {
-    const wrapped = wrapWithCursor(line, opts.cursor ?? line.length, textWidth);
+    const wrapped = wrapWithCursor(line, opts.cursor ?? line.length, textWidth, useColor ? opts.highlight : undefined);
     rows = wrapped.rows;
     crow = wrapped.row;
     ccol = wrapped.col;
@@ -110,10 +117,10 @@ export function renderInputFrame(line: string, opts: InputBoxOptions = {}): Inpu
     hidden = Math.min(Math.max(0, crow - maxBodyRows + 1), totalRows - maxBodyRows);
     if (crow < hidden) hidden = crow; // caret above the window → scroll up to it
     rows = rows.slice(hidden, hidden + maxBodyRows);
-    if (hidden > 0) rows[0] = `…${rows[0] ?? ""}`.slice(0, textWidth);
+    if (hidden > 0) rows[0] = truncateToWidth(`…${rows[0] ?? ""}`, textWidth);
     if (hidden + maxBodyRows < totalRows) {
       const last = rows.length - 1;
-      rows[last] = `${rows[last] ?? ""}…`.slice(0, textWidth);
+      rows[last] = truncateToWidth(`${rows[last] ?? ""}…`, textWidth);
     }
   }
   let visRow = Math.max(0, Math.min(crow - hidden, rows.length - 1));

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

@@ -0,0 +1,226 @@
+/**
+ * Rich, gjc-style session picker for `/resume`.
+ *
+ * Mirrors Gajae-Code's session selector UX: a search/filter line at the top, a
+ * scrolling window of multi-line entries (title + dimmed first-message preview +
+ * a "relative time · size · N msgs" metadata line), a position indicator, and a
+ * footer with Del-to-delete / Enter-to-resume / Esc-to-cancel hints.
+ *
+ * Pure rendering — no I/O. The owning REPL drives navigation/deletion via the
+ * `SessionPicker` model and feeds the rendered lines to its picker loop.
+ */
+import chalk from "chalk";
+import { truncateToWidth } from "./width";
+import type { SessionSummary } from "../../agent/session";
+
+/** Human-readable byte size (e.g. "0 B", "12.3 KB", "4.2 MB"). */
+export function formatBytes(n: number | undefined): string {
+  const v = typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : 0;
+  if (v < 1024) return `${v} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let size = v / 1024;
+  let i = 0;
+  while (size >= 1024 && i < units.length - 1) {
+    size /= 1024;
+    i++;
+  }
+  return `${size < 10 ? size.toFixed(1) : Math.round(size)} ${units[i]}`;
+}
+
+/** Relative "X ago" timestamp, matching gjc's session-selector phrasing. */
+export function formatRelativeTime(fromMs: number | undefined, nowMs: number = Date.now()): string {
+  if (typeof fromMs !== "number" || !Number.isFinite(fromMs) || fromMs <= 0) return "unknown";
+  const diff = Math.max(0, nowMs - fromMs);
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins} minute${mins !== 1 ? "s" : ""} ago`;
+  if (hours < 24) return `${hours} hour${hours !== 1 ? "s" : ""} ago`;
+  if (days === 1) return "1 day ago";
+  if (days < 7) return `${days} days ago`;
+  return new Date(fromMs).toLocaleDateString();
+}
+
+/**
+ * Navigable model for the resume picker: an ordered session list with a
+ * case-insensitive AND-of-terms filter across id/title/preview/cwd, a cursor
+ * into the *filtered* view, and in-place removal for delete.
+ */
+export class SessionPicker {
+  private readonly all: SessionSummary[];
+  private query = "";
+  private cursor = 0;
+
+  constructor(sessions: readonly SessionSummary[]) {
+    this.all = sessions.slice();
+  }
+
+  /** Sessions matching the current filter (every whitespace term must match). */
+  visible(): SessionSummary[] {
+    const q = this.query.trim().toLowerCase();
+    if (!q) return this.all;
+    const terms = q.split(/\s+/);
+    return this.all.filter(s => {
+      const hay = [s.id, s.title ?? "", s.preview ?? "", s.cwd ?? ""].join(" ").toLowerCase();
+      return terms.every(t => hay.includes(t));
+    });
+  }
+
+  cursorIndex(): number {
+    const n = this.visible().length;
+    if (n === 0) return 0;
+    return Math.max(0, Math.min(this.cursor, n - 1));
+  }
+
+  selected(): SessionSummary | undefined {
+    return this.visible()[this.cursorIndex()];
+  }
+
+  isEmpty(): boolean {
+    return this.visible().length === 0;
+  }
+
+  filter(): string {
+    return this.query;
+  }
+
+  setFilter(query: string): void {
+    this.query = query;
+    this.cursor = 0;
+  }
+
+  typeChar(ch: string): void {
+    this.setFilter(this.query + ch);
+  }
+
+  backspace(): void {
+    this.setFilter(this.query.slice(0, -1));
+  }
+
+  up(): void {
+    const n = this.visible().length;
+    if (n === 0) return;
+    this.cursor = (this.cursorIndex() - 1 + n) % n;
+  }
+
+  down(): void {
+    const n = this.visible().length;
+    if (n === 0) return;
+    this.cursor = (this.cursorIndex() + 1) % n;
+  }
+
+  /** Move by a window without wrapping (PageUp/PageDown). */
+  page(dir: 1 | -1, size = 3): void {
+    const n = this.visible().length;
+    if (n === 0) return;
+    this.cursor = Math.max(0, Math.min(n - 1, this.cursorIndex() + dir * Math.max(1, size)));
+  }
+
+  /** Remove the highlighted session from the model; returns it (or undefined). */
+  removeSelected(): SessionSummary | undefined {
+    const sel = this.selected();
+    if (!sel) return undefined;
+    const idx = this.all.findIndex(s => s.id === sel.id);
+    if (idx >= 0) this.all.splice(idx, 1);
+    const n = this.visible().length;
+    if (this.cursor >= n) this.cursor = Math.max(0, n - 1);
+    return sel;
+  }
+}
+
+export interface RenderSessionPickerOptions {
+  /** Title line(s) shown above the search line. */
+  title?: string;
+  /** Total width to fit each line to (default 80). */
+  cols?: number;
+  /** Total body rows available; the visible window is derived from this (default 24). */
+  rows?: number;
+  /** Use unicode glyphs (default true). */
+  unicode?: boolean;
+  /** Apply chalk color (default true). */
+  color?: boolean;
+  /** Clock override for relative-time formatting (tests). */
+  nowMs?: number;
+  /** When set, the matching session shows a "press Del again to delete" prompt. */
+  confirmDeleteId?: string;
+}
+
+/** Render a `SessionPicker` to lines (gjc-style multi-line entries). Pure. */
+export function renderSessionPicker(picker: SessionPicker, opts: RenderSessionPickerOptions = {}): string[] {
+  const unicode = opts.unicode !== false;
+  const color = opts.color !== false;
+  const cols = Math.max(20, opts.cols ?? 80);
+  const nowMs = opts.nowMs ?? Date.now();
+  const tint = (s: string, fn: (x: string) => string): string => (color ? fn(s) : s);
+  const fit = (s: string): string => truncateToWidth(s, cols);
+  const pointer = unicode ? "\u276f" : ">"; // ❯
+  const dot = unicode ? "\u00b7" : "-"; // ·
+  const arrow = unicode ? "\u203a" : ">"; // ›
+
+  const out: string[] = [];
+  const titleLines = opts.title ? opts.title.split("\n") : [];
+  for (const t of titleLines) out.push(fit(t ? tint(t, chalk.bold) : ""));
+
+  // Search/filter line (gjc places an input box at the top).
+  const q = picker.filter();
+  const searchValue = q ? q : tint("type to filter", chalk.gray);
+  out.push(fit(`${tint("search", chalk.gray)} ${tint(arrow, chalk.cyan)} ${searchValue}`));
+  out.push("");
+
+  const items = picker.visible();
+  const footerKeys = unicode
+    ? `\u2191/\u2193 move \u00b7 enter resume \u00b7 del delete \u00b7 esc cancel`
+    : `up/down move - enter resume - del delete - esc cancel`;
+
+  if (items.length === 0) {
+    out.push(fit(tint("  no sessions match", chalk.gray)));
+    out.push("");
+    out.push(fit(tint(`  [${footerKeys}]`, chalk.gray)));
+    return out;
+  }
+
+  // Each entry occupies up to 3 content lines + 1 blank; derive the window from
+  // available rows, leaving room for title/search/footer chrome.
+  const linesPerItem = 4;
+  const chrome = titleLines.length + 2 /* search + blank */ + 2 /* position + footer */;
+  const avail = Math.max(linesPerItem, (opts.rows ?? 24) - chrome);
+  const maxVisible = Math.max(1, Math.min(items.length, Math.floor(avail / linesPerItem)));
+
+  const cur = picker.cursorIndex();
+  let start = Math.max(0, cur - Math.floor(maxVisible / 2));
+  start = Math.min(start, Math.max(0, items.length - maxVisible));
+  const end = Math.min(items.length, start + maxVisible);
+
+  for (let i = start; i < end; i++) {
+    const s = items[i]!;
+    const isCur = i === cur;
+    const isConfirm = !!opts.confirmDeleteId && s.id === opts.confirmDeleteId;
+    const cursorStr = isCur ? tint(`${pointer} `, chalk.cyan) : "  ";
+    const maxw = Math.max(1, cols - 2); // cursor/indent prefix is 2 columns
+    const firstMsg = (s.preview || "(no preview)").replace(/\s+/g, " ").trim();
+
+    if (s.title) {
+      const titleTxt = truncateToWidth(s.title, maxw);
+      out.push(fit(cursorStr + (isCur ? tint(titleTxt, (x: string) => chalk.cyan.bold(x)) : titleTxt)));
+      out.push(fit("  " + tint(truncateToWidth(firstMsg, maxw), chalk.dim)));
+    } else {
+      const msg = truncateToWidth(firstMsg, maxw);
+      out.push(fit(cursorStr + (isCur ? tint(msg, (x: string) => chalk.cyan.bold(x)) : msg)));
+    }
+
+    if (isConfirm) {
+      out.push(fit(tint(`  press Del again to delete ${dot} any other key cancels`, chalk.yellow)));
+    } else {
+      const meta = `  ${formatRelativeTime(s.mtimeMs, nowMs)} ${dot} ${formatBytes(s.sizeBytes)} ${dot} ${s.messageCount} msg${s.messageCount !== 1 ? "s" : ""}`;
+      out.push(fit(tint(truncateToWidth(meta, cols), chalk.dim)));
+    }
+    out.push("");
+  }
+
+  if (start > 0 || end < items.length) {
+    out.push(fit(tint(`  (${cur + 1}/${items.length})`, chalk.gray)));
+  }
+  out.push(fit(tint(`  [${footerKeys}]`, chalk.gray)));
+  return out;
+}