jeo-code 0.6.30 → 0.6.32

package/CHANGELOG.md

@@ -6,6 +6,33 @@ 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.32] - 2026-06-19
+_Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification._
+
+### Fixed
+- **Anthropic extended thinking was never turned on — opus-4-8/4-7 reasoning is now actually requested.** The provider parsed and replayed thinking blocks on the *response* side and sent the `interleaved-thinking` beta, but `anthropicPayload` never put a `thinking` parameter in the *request* body, so the API treated every call as non-thinking and (for the internally-reasoning opus-4-7/4-8) returned signature-only/empty thought — reasoning effectively never activated. The request builder now selects a thinking transport per model (`anthropicThinkingMode` via `parseAnthropicVersion` on `claude-<family>-<major>-<minor>`): Anthropic **≥ 4.6 → adaptive** (`thinking: { type: "adaptive" }` with `display: "summarized"` gated to Opus **≥ 4.7** via `supportsAdaptiveThinkingDisplay`, depth riding `output_config.effort`, no `budget_tokens`); **4.5 → budget-effort** (`{ type: "enabled", budget_tokens, display: "summarized" }` + `output_config.effort`); **older → budget** (budget only). jeo's reasoning effort maps to the adaptive/effort literal via `anthropicAdaptiveEffort` (minimal/low/medium/high; xhigh folded to high upstream), `temperature` stays dropped on the thinking path, and the legacy `interleaved-thinking-2025-05-14` beta is filtered out for Opus ≥ 4.7 (`anthropicBetaHeader`) so it can't shadow the adaptive transport. Mirrors gjc's `inferThinkingControlMode` / `supportsAdaptiveThinkingDisplay` behavior.
+
+### Changed
+- **The trigger highlight now paints *every* `/command`·`$skill` token on the line and keeps it lit after the space.** New pure helpers in `slash.ts` — `allTriggerTokens(line)` (every whitespace-delimited `/`·`$` word, left-to-right, with code-point `start` offsets; paths like `src/cli` and `FOO$BAR` still excluded) and `committedTriggerToken(line)` (the leading invocation once a space follows, so the highlight no longer vanishes the instant you type a trailing space). `InputBoxOptions.highlight` accepts a multi-range `HighlightRange[]`, so a prompt mentioning several invocations lights each one (valid → neon green, no-match → pink) at once, independent of caret position.
+
+### Verified
+- **`jeo --tmux` has no bun memory leak and stays responsive.** A real `--tmux` session flooded with 200 `/command` keystrokes plus 80 SGR mouse-report sequences via `tmux send-keys` holds RSS bounded (159.8 → 161.5 MB peak → 161.4 MB settled, +1.5 MB and *decreasing* after the flood — no per-event linear growth) and the `tmux-verify.sh smoke` + `battery` (boot, `/help`, unknown `$skill`, `/agents`, `$ultragoal`, unresolved `/command`) all pass.
+- **Full suite green:** `bun run typecheck` clean and `bun test` 1708 pass / 0 fail across 211 files (includes the extended `test/anthropic-stream.test.ts` adaptive/budget request-body coverage and the `test/slash.test.ts` / `test/input-box.test.ts` multi-token highlight tests).
+
+## [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.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.32]** (2026-06-19) — Anthropic extended thinking is actually enabled now — the request finally sends a `thinking` block (adaptive for Opus/Sonnet 4.6+, budget for older), fixing reasoning on **opus-4-8** — plus a multi-token `/command`·`$skill` trigger highlight that paints every invocation and survives the trailing space, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.32",
   "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/model-catalog.ts

@@ -65,11 +65,10 @@ export const MODEL_CATALOG: readonly CatalogModel[] = [
   { canonical: "claude-sonnet-4-5", provider: "anthropic", providerModel: "claude-sonnet-4-5-20250929", contextTokens: 200_000, maxOutputTokens: 64_000, thinking: FULL, images: true },
   { canonical: "claude-opus-4-1", provider: "anthropic", providerModel: "claude-opus-4-1-20250805", contextTokens: 200_000, maxOutputTokens: 32_000, thinking: FULL, images: true },
   { canonical: "claude-opus-4-5", provider: "anthropic", providerModel: "claude-opus-4-5-20251101", contextTokens: 200_000, maxOutputTokens: 64_000, thinking: FULL, images: true },
-  // NOTE: opus-4-7 accepts extended thinking but currently returns 0 thinking tokens
-  // (model-internal, no visible thought). opus-4-8 thinks internally (tokens billed,
-  // signature present) but returns empty thinking text. Both are FULL-capable in the
-  // catalog so the budget is always sent — the nativizable path handles signature-only
-  // artifacts for cross-turn continuity.
+  // NOTE: opus 4.6+ use Anthropic ADAPTIVE thinking (type:"adaptive" + output_config.effort).
+  // opus 4.7/4.8 OMIT visible thought unless the request opts into `display: "summarized"` —
+  // anthropic.ts sets that on the adaptive transport so reasoning streams again (gjc parity).
+  // The nativizable path still replays signature-only thinking blocks for cross-turn continuity.
   { canonical: "claude-opus-4-6", provider: "anthropic", providerModel: "claude-opus-4-6", contextTokens: 200_000, maxOutputTokens: 64_000, thinking: FULL, images: true },
   { canonical: "claude-opus-4-7", provider: "anthropic", providerModel: "claude-opus-4-7", contextTokens: 200_000, maxOutputTokens: 64_000, thinking: FULL, images: true },
   { canonical: "claude-opus-4-8", provider: "anthropic", providerModel: "claude-opus-4-8", contextTokens: 200_000, maxOutputTokens: 64_000, thinking: FULL, images: true },

package/src/ai/providers/anthropic.ts

@@ -16,14 +16,25 @@ const CLAUDE_BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
 const ANTHROPIC_API_KEY_BETA = [
   "interleaved-thinking-2025-05-14",
   "prompt-caching-scope-2026-01-05",
-].join(",");
+];
 const ANTHROPIC_OAUTH_BETA = [
   "claude-code-20250219",
   "oauth-2025-04-20",
   "interleaved-thinking-2025-05-14",
   "context-management-2025-06-27",
   "prompt-caching-scope-2026-01-05",
-].join(",");
+];
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+
+/** The interleaved-thinking beta drives BUDGET-based thinking+tools. Adaptive-display models
+ *  (Opus 4.7+) use adaptive thinking and DON'T need it — gjc drops it for these so the legacy
+ *  beta doesn't shadow the adaptive transport. */
+function anthropicBetaHeader(betas: string[], model: string): string {
+  const filtered = supportsAdaptiveThinkingDisplay(model)
+    ? betas.filter(b => b !== INTERLEAVED_THINKING_BETA)
+    : betas;
+  return filtered.join(",");
+}
 
 interface AnthropicSystemBlock {
   type: "text";
@@ -94,6 +105,51 @@ function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxToke
   return Math.min(budget, Math.max(1024, maxTokens - 1024));
 }
 
+/** Parse an Anthropic model id's family + version for thinking-transport selection.
+ *  Matches the modern `claude-<family>-<major>-<minor>[...]` naming (opus/sonnet/haiku 4.x+);
+ *  legacy ids (claude-3-5-sonnet) and non-Anthropic-compatible names return undefined. */
+function parseAnthropicVersion(model: string): { kind: "opus" | "sonnet" | "haiku"; major: number; minor: number } | undefined {
+  const m = /claude-(opus|sonnet|haiku)-(\d+)-(\d+)/.exec(model);
+  if (!m) return undefined;
+  return { kind: m[1] as "opus" | "sonnet" | "haiku", major: Number(m[2]), minor: Number(m[3]) };
+}
+
+/** Adaptive thinking `display` is supported starting with Opus 4.7. Without it, Opus 4.7/4.8
+ *  OMIT thinking content entirely (tokens billed, signature present, but zero visible thought —
+ *  the "reasoning doesn't show" bug). Older adaptive models (Opus 4.6, Sonnet 4.6+) reject the
+ *  field, so it is gated to Opus ≥ 4.7. (gjc: supportsAdaptiveThinkingDisplay) */
+function supportsAdaptiveThinkingDisplay(model: string): boolean {
+  const v = parseAnthropicVersion(model);
+  if (!v || v.kind !== "opus") return false;
+  return v.major > 4 || (v.major === 4 && v.minor >= 7);
+}
+
+/** Thinking transport for a model (gjc parity — inferThinkingControlMode):
+ *  - Anthropic ≥ 4.6 → "adaptive" (model decides depth; effort rides output_config, NO budget)
+ *  - Anthropic 4.5   → "budget-effort" (budget_tokens + output_config effort)
+ *  - otherwise       → "budget" (budget_tokens only).
+ *  The adaptive shift is the core opus-4.7/4.8 reasoning fix: those models reject the legacy
+ *  budget transport's visible-thought contract and require type:"adaptive" + display:summarized. */
+type AnthropicThinkingMode = "adaptive" | "budget-effort" | "budget";
+function anthropicThinkingMode(model: string): AnthropicThinkingMode {
+  const v = parseAnthropicVersion(model);
+  if (!v) return "budget";
+  if (v.major > 4 || (v.major === 4 && v.minor >= 6)) return "adaptive";
+  if (v.major === 4 && v.minor === 5) return "budget-effort";
+  return "budget";
+}
+
+/** Map jeo's reasoning effort to Anthropic's adaptive/output_config effort literal. jeo folds
+ *  xhigh→high upstream, so only minimal/low/medium/high arrive here. (gjc: mapEffortToAnthropicAdaptiveEffort) */
+function anthropicAdaptiveEffort(effort: NonNullable<CallOptions["reasoningEffort"]>): "low" | "medium" | "high" {
+  switch (effort) {
+    case "minimal":
+    case "low": return "low";
+    case "medium": return "medium";
+    case "high": return "high";
+  }
+}
+
 type AnthropicContentBlock = Record<string, unknown>;
 type AnthropicMessage = { role: string; content: string | AnthropicContentBlock[] };
 
@@ -160,10 +216,17 @@ export function anthropicPayload(
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
   // Image attachments + native tool/thinking-block reconstruction live in buildAnthropicMessages.
   const maxTokens = options.maxTokens ?? 4000;
-  const thinkingBudget = anthropicThinkingBudget(options.reasoningEffort, maxTokens);
+  const effort = options.reasoningEffort;
+  const thinkingEnabled = effort !== undefined;
+  // gjc parity: pick the thinking transport per model. Adaptive (Opus/Sonnet 4.6+) carries NO
+  // budget_tokens — depth rides output_config.effort. budget/budget-effort still use a budget.
+  const thinkingMode = thinkingEnabled ? anthropicThinkingMode(model) : "budget";
+  const thinkingBudget = thinkingEnabled && thinkingMode !== "adaptive"
+    ? anthropicThinkingBudget(effort, maxTokens)
+    : undefined;
   // Reconstruct native tool_use / tool_result / thinking blocks for same-model turns when
   // thinking is enabled (and not stripped by a fail-safe retry); else plain string/image.
-  const anthropicMessages = buildAnthropicMessages(messages, options.model, thinkingBudget !== undefined && !stripArtifacts);
+  const anthropicMessages = buildAnthropicMessages(messages, options.model, thinkingEnabled && !stripArtifacts);
   // Conversation prompt caching (gjc parity — the main same-model latency gap):
   // one breakpoint on the LAST message caches the entire conversation prefix, so
   // each agent-loop step only pays input processing for the new tail instead of
@@ -187,12 +250,24 @@ export function anthropicPayload(
     max_tokens: thinkingBudget !== undefined ? Math.max(maxTokens, thinkingBudget + 1024) : maxTokens,
   };
   if (credential.kind === "oauth") payload.metadata = { user_id: createClaudeCloakingUserId() };
-  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 };
+  if (effort !== undefined) {
+    // Enable Claude extended thinking. Extended thinking forbids a custom temperature, so
+    // temperature is only set on the non-thinking path.
+    if (thinkingMode === "adaptive") {
+      // Opus/Sonnet 4.6+: the model decides how much to think. `display: "summarized"` is
+      // REQUIRED on Opus 4.7+ or thinking content is omitted from the response (the empty-thought
+      // bug); older adaptive models (4.6) reject the field, so it is gated. Effort rides
+      // output_config — there is no budget_tokens on this transport.
+      payload.thinking = supportsAdaptiveThinkingDisplay(model)
+        ? { type: "adaptive", display: "summarized" }
+        : { type: "adaptive" };
+      payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
+    } else {
+      // Budget-based extended thinking. `display: "summarized"` keeps human-readable thought
+      // streaming. The 4.5 (budget-effort) transport also carries an output_config effort.
+      payload.thinking = { type: "enabled", budget_tokens: thinkingBudget, display: "summarized" };
+      if (thinkingMode === "budget-effort") payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
+    }
   } else if (includeTemperature && options.temperature !== undefined) {
     payload.temperature = options.temperature;
   }
@@ -221,7 +296,7 @@ export function anthropicRequest(
     // Anthropic-compatible providers (z.ai, MiniMax, …) accept the Messages wire
     // format at their own host; an explicit baseUrl pins `${base}/v1/messages`.
     url: options.baseUrl ? `${options.baseUrl.replace(/\/$/, "")}/v1/messages` : ANTHROPIC_URL,
-    headers: headersFor(credential, stream),
+    headers: headersFor(credential, stream, stripAnthropicPrefix(options.model)),
     body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts),
   };
 }
@@ -353,8 +428,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);
@@ -427,10 +506,10 @@ function mapStainlessArch(arch: string): "x64" | "arm64" | "x86" | `other::${str
   }
 }
 
-function claudeCodeOAuthHeaders(stream: boolean): Record<string, string> {
+function claudeCodeOAuthHeaders(stream: boolean, model: string): Record<string, string> {
   return {
     accept: stream ? "text/event-stream" : "application/json",
-    "anthropic-beta": ANTHROPIC_OAUTH_BETA,
+    "anthropic-beta": anthropicBetaHeader(ANTHROPIC_OAUTH_BETA, model),
     "anthropic-dangerous-direct-browser-access": "true",
     "user-agent": `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`,
     "x-app": "cli",
@@ -445,13 +524,13 @@ function claudeCodeOAuthHeaders(stream: boolean): Record<string, string> {
   };
 }
 
-function headersFor(credential: Credential, stream: boolean): Record<string, string> {
+function headersFor(credential: Credential, stream: boolean, model: string): Record<string, string> {
   if (credential.kind === "oauth") {
     return {
       "content-type": "application/json",
       authorization: `Bearer ${credential.token}`,
       "anthropic-version": "2023-06-01",
-      ...claudeCodeOAuthHeaders(stream),
+      ...claudeCodeOAuthHeaders(stream, model),
     };
   }
   if (credential.kind === "api_key") {
@@ -460,7 +539,7 @@ function headersFor(credential: Credential, stream: boolean): Record<string, str
       "content-type": "application/json",
       "x-api-key": credential.token,
       "anthropic-version": "2023-06-01",
-      "anthropic-beta": ANTHROPIC_API_KEY_BETA,
+      "anthropic-beta": anthropicBetaHeader(ANTHROPIC_API_KEY_BETA, model),
     };
   }
   throw new Error("anthropic adapter requires a credential");

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

@@ -19,7 +19,7 @@ import { formatForgeBox } from "../tui/components/forge";
 import { interactiveOAuthLogin } from "./auth";
 import { logoutOAuth, OAUTH_PROVIDERS, API_KEY_ONLY_PROVIDERS, setApiKey } from "../auth";
 import type { AuthProvider } from "../auth";
-import { matchSlash, isSlashAttempt, suggestSlashCommands, formatSlashCommandList, formatSlashPreview, slashPreviewMatches, activeTriggerToken, tabCompleteSelection, type SlashCommandInfo } from "../tui/components/slash";
+import { matchSlash, isSlashAttempt, suggestSlashCommands, formatSlashCommandList, formatSlashPreview, slashPreviewMatches, activeTriggerToken, allTriggerTokens, tabCompleteSelection, type SlashCommandInfo } from "../tui/components/slash";
 import { staticCompletionContext, readlineCompleter, formatCompletionPreview, formatMidTurnHint, tokenize, type CompletionContext } from "../tui/components/autocomplete";
 import { normalizeBaseUrl } from "./setup-helpers";
 import { EVOLUTION_STAGES, animateAsciiArt } from "../tui/components/ascii-art";
@@ -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,
@@ -61,7 +62,7 @@ import { liveModelPicker, renderLiveModelPicker, type ModelAssignmentBadge } fro
 import { loginPicker, renderLoginPicker, onboardingPicker, renderOnboardingPicker, apiKeyPicker, renderApiKeyPicker, subscriptionLoginPicker, type OnboardingAction } from "../tui/components/provider-picker";
 import { detectLanguage, languageLabel, parseLineRange, sliceLines, formatCodeBlock, formatDiff, sanitizeForTerminal } from "../tui/components/code-view";
 import { categoryBadge } from "../tui/components/category-index";
-import { renderInputFrame, verticalCursorOffset } from "../tui/components/input-box";
+import { renderInputFrame, verticalCursorOffset, type HighlightRange } from "../tui/components/input-box";
 
 import { renderStatusBar } from "../tui/components/status";
 import { detectColorLevel, ColorLevel, visibleWidth } from "../tui/components/color";
@@ -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,37 @@ 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,
+  ): HighlightRange[] => {
+    if (!uiTheme.color) return [];
+    // Highlight EVERY `/command`·`$skill` invocation in the line at once and
+    // independent of caret position, so multiple triggers all stay lit and a
+    // token keeps its color even when the caret jumps elsewhere to edit.
+    const out: HighlightRange[] = [];
+    for (const trigger of allTriggerTokens(rendered)) {
+      const start = Array.from(rendered.slice(0, trigger.start)).length;
+      const end = start + Array.from(trigger.token).length;
+      // "Open" = the word still being typed: it reaches the end of the line with
+      // no space after it. An open token counts as valid-so-far on any match
+      // (incl. fuzzy prefix); every committed token must be an EXACT known
+      // command/skill to stay green, else it shows caution pink (likely typo).
+      const isOpen = trigger.start + trigger.token.length === rendered.length;
+      const matches = slashPreviewMatches(trigger.token, skillSlashDetails, resolvedSkills);
+      const valid = isOpen ? matches.length > 0 : matches.includes(trigger.token);
+      const hex = valid ? TRIGGER_HL_VALID : TRIGGER_HL_UNKNOWN;
+      out.push({ start, end, paint: (s: string) => chalk.hex(hex)(s) });
+    }
+    return out;
+  };
   const refreshUiTheme = (): void => {
     uiTheme = resolveTheme(process.env);
     uiAccent = accentPaint(uiTheme);
@@ -1825,7 +1859,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 +1876,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 +2966,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

@@ -37,10 +37,18 @@ import { formatHintBar } from "./components/hints";
 import { formatDuration, formatUsage } from "./components/duration";
 import { renderHud, type JeoPhase } from "./components/hud";
 import { formatTodoWriteCard } from "./components/todo-card";
-import { renderInputBox } from "./components/input-box";
+import { renderInputBox, type HighlightRange } from "./components/input-box";
 import { jeoEnv } from "../util/env";
 import chalk from "chalk";
 
+/** Stable signature of a highlight range list — offsets plus the painted color
+ *  (probed with a sentinel char) — so equal-length but differently-colored
+ *  re-highlights (valid↔unknown at the same span) still trigger a redraw. */
+function highlightSignature(hl?: readonly HighlightRange[]): string {
+  if (!hl || hl.length === 0) return "";
+  return hl.map(r => `${r.start}:${r.end}:${r.paint("\u0000")}`).join("|");
+}
+
 export interface LaunchTuiOptions {
   model: string;
   /** Resolved provider name for the footer (anthropic / openai / gemini / ollama). */
@@ -68,6 +76,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 +258,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 +426,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 +469,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 +509,7 @@ export class LaunchTui {
         }
         this.streamingReasoning = "";
         this.streamingThought = "";
+        this.thinkingActive = false;
         this.streamingActivity = "";
         if (invocation && invocation.tool !== "done") {
           this.runningTool = true;
@@ -650,6 +676,18 @@ export class LaunchTui {
     this.draw();
   }
 
+  private livePromptHighlight?: readonly HighlightRange[];
+  /** Recolor every active/committed `/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 per token; undefined/empty clears. */
+  setLivePromptHighlight(hl?: readonly HighlightRange[]): void {
+    if (this.finished) return;
+    const next = hl && hl.length ? hl : undefined;
+    if (highlightSignature(this.livePromptHighlight) === highlightSignature(next)) return;
+    this.livePromptHighlight = next;
+    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 +710,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 +964,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 +1422,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,20 @@ 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 contiguous CHARACTER ranges of the typed text (e.g. each active or
+   *  committed `/command`/`$skill` trigger token) so the user sees every
+   *  invocation recognized as it is typed — regardless of caret position or how
+   *  many appear. Offsets index `Array.from(line)` code points ([start, end)).
+   *  Accepts a single range or an array; ranges should not overlap. Ignored for
+   *  the placeholder and when `color` is false. */
+  highlight?: HighlightRange | readonly HighlightRange[];
+}
+
+/** A painted span of the input text: [start, end) code-point offsets + a painter. */
+export interface HighlightRange {
+  start: number;
+  end: number;
+  paint: (s: string) => string;
 }
 
 export interface InputFrame {
@@ -38,6 +52,7 @@ function wrapWithCursor(
   text: string,
   cursor: number,
   width: number,
+  highlights?: readonly HighlightRange[],
 ): { rows: string[]; row: number; col: number } {
   const rows: string[] = [];
   let cur = "";
@@ -67,7 +82,8 @@ function wrapWithCursor(
       continue;
     }
     if (ch !== "") {
-      cur += rendered;
+      const hl = highlights?.find(r => i >= r.start && i < r.end);
+      cur += hl ? hl.paint(rendered) : rendered;
       curW += w;
     }
   }
@@ -75,6 +91,16 @@ function wrapWithCursor(
   return { rows, row, col };
 }
 
+/** Normalize the `highlight` option (single range, array, or absent) into a
+ *  non-empty range array, or undefined when there is nothing to paint. */
+function normalizeHighlights(
+  h?: HighlightRange | readonly HighlightRange[],
+): readonly HighlightRange[] | undefined {
+  if (!h) return undefined;
+  const arr = Array.isArray(h) ? h : [h as HighlightRange];
+  return arr.length ? arr : undefined;
+}
+
 /**
  * Boxed input prompt (gjc-style): a `>` marker leads the first body row, the typed
  * text (or a dim placeholder) follows, and the caret cell is reported so the caller
@@ -95,7 +121,8 @@ export function renderInputFrame(line: string, opts: InputBoxOptions = {}): Inpu
     rows = [placeholder];
     placeholderRow = true;
   } else {
-    const wrapped = wrapWithCursor(line, opts.cursor ?? line.length, textWidth);
+    const hl = useColor ? normalizeHighlights(opts.highlight) : undefined;
+    const wrapped = wrapWithCursor(line, opts.cursor ?? line.length, textWidth, hl);
     rows = wrapped.rows;
     crow = wrapped.row;
     ccol = wrapped.col;
@@ -110,10 +137,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;
+}

package/src/tui/components/slash.ts

@@ -216,6 +216,42 @@ export function activeTriggerToken(line: string): ActiveTrigger | undefined {
   return { kind: token[0] as "/" | "$", token, start: (m.index ?? 0) + m[1]!.length };
 }
 
+/**
+ * The LEADING `/command` or `$skill` keyword once it has been committed with a
+ * trailing space — `"/model gpt-4"` → `/model`, `"$test the bug"` → `$test`.
+ * Unlike {@link activeTriggerToken} (which only matches the word the caret still
+ * sits on) this keeps the invoked keyword recognizable while arguments are typed,
+ * so the trigger highlight persists after the space instead of vanishing. Only
+ * the leading word counts — a command is invoked at the start of the line — and a
+ * still-being-typed keyword (no space yet) returns undefined so the active-token
+ * path owns it. Returns the same shape as {@link activeTriggerToken}.
+ */
+export function committedTriggerToken(line: string): ActiveTrigger | undefined {
+  const m = /^(\s*)([/$]\S+)\s/.exec(line);
+  if (!m) return undefined;
+  const token = m[2]!;
+  return { kind: token[0] as "/" | "$", token, start: Array.from(m[1]!).length };
+}
+
+/**
+ * EVERY `/command` or `$skill` trigger token in the line (mention-style), in
+ * left-to-right order — `"/model x then $test y"` → [`/model`, `$test`]. Each
+ * is a whitespace-delimited word whose first char is `/`·`$` (paths like
+ * `src/cli` and vars like `FOO$BAR` stay excluded, just like the single-token
+ * helpers). `start` is the token's first-character index in `line`. Used to
+ * highlight all invocations at once, independent of caret position. Pure.
+ */
+export function allTriggerTokens(line: string): ActiveTrigger[] {
+  const out: ActiveTrigger[] = [];
+  const re = /(^|\s)([/$]\S*)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(line))) {
+    const token = m[2]!;
+    out.push({ kind: token[0] as "/" | "$", token, start: m.index + m[1]!.length });
+  }
+  return out;
+}
+
 /**
  * Compact live preview shown beneath the input box while a `/command` or
  * `$skill` keyword is being typed — at any position in the line (mention-style,