jeo-code 0.6.31 → 0.6.32

package/CHANGELOG.md

@@ -6,6 +6,19 @@ 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._
 

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`.
 
 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`.
 
 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`.
 
 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`.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

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),
   };
 }
@@ -431,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",
@@ -449,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") {
@@ -464,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/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";
@@ -62,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";
@@ -1803,15 +1803,26 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   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) };
+  ): 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);

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). */
@@ -668,15 +676,15 @@ 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 {
+  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 a = this.livePromptHighlight, b = hl;
-    if (a?.start === b?.start && a?.end === b?.end && (!a) === (!b)) return;
-    this.livePromptHighlight = hl;
+    const next = hl && hl.length ? hl : undefined;
+    if (highlightSignature(this.livePromptHighlight) === highlightSignature(next)) return;
+    this.livePromptHighlight = next;
     this.draw();
   }
 

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

@@ -18,11 +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 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 };
+  /** 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 {
@@ -43,7 +52,7 @@ function wrapWithCursor(
   text: string,
   cursor: number,
   width: number,
-  highlight?: { start: number; end: number; paint: (s: string) => string },
+  highlights?: readonly HighlightRange[],
 ): { rows: string[]; row: number; col: number } {
   const rows: string[] = [];
   let cur = "";
@@ -73,8 +82,8 @@ function wrapWithCursor(
       continue;
     }
     if (ch !== "") {
-      const lit = highlight && i >= highlight.start && i < highlight.end;
-      cur += lit ? highlight.paint(rendered) : rendered;
+      const hl = highlights?.find(r => i >= r.start && i < r.end);
+      cur += hl ? hl.paint(rendered) : rendered;
       curW += w;
     }
   }
@@ -82,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
@@ -102,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, useColor ? opts.highlight : undefined);
+    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;

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,