jeo-code 0.6.31 → 0.6.33

package/CHANGELOG.md

@@ -6,6 +6,32 @@ 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.33] - 2026-06-19
+_A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification._
+
+### Changed
+- **The forge mark is a hollow line-board emblem now.** `FORGE_MARK_ART`, its grand `FORGE_MARK_ART_GRAND` hero variant, the claw-snap blink frames (`FORGE_MARK_FRAMES`), and every ASCII fallback (`*_ASCII`) were redrawn as the `>-<` silhouette of two pincer CLAWS (집게) whose top arms bend inward toward a narrow central eyeglass-frame (안경태) BRIDGE — each stroke a thick rounded-corner tube (`╭╮╰╯` + `─│`, ASCII `.-'|`) so the shape reads as a heavy neon outline instead of a filled block. The old wordmark glyphs (`J E O`) and the `╳` DNA double-helix nodes are gone; every line stays width-1 and equal-width so the blue→violet→pink flow gradient and the padding/centering math are untouched.
+- **Forge cards render at a compact reduced width.** New `FORGE_SCALE` (1.2) + `scaleForgeWidth(available)` in `forge.ts` divide the caller's available column run down to a compact panel width (floored at 24). `app.ts` routes both the inline `flushForgeCard` and the static forge summary through it, so a card reads as a contained panel instead of stretching edge-to-edge with a dead right margin.
+- **One source for the done-time verification directive.** New `VERIFICATION_DIRECTIVE` constant in `engine.ts` replaces the string that was duplicated verbatim in `executorSystemPrompt`'s default and `launch.ts`'s interactive prompt. It folds in gjc's `<verification>` test-quality contract — written tests must exercise observable behavior, edge values, branch conditions, invariants, and error handling, never asserting defaults or tautologies — and `prompts/agents/executor.md` gains a matching constraint line.
+
+### Verified
+- **No bun memory leak / slowdown.** `scripts/mem-probe.ts` drove 2000 realistic LaunchTui turns: post-GC heap returns to baseline (per-turn slope **−480 bytes/turn**, net +3.28 MB held flat), with `exit`/`resize`/`SIGINT` process-listener counts stable (no accumulation).
+- **`jeo --tmux` live.** `scripts/tmux-verify.sh smoke` OK and `battery` **6/6 PASSED** (boot, `/help`, unknown `$skill` feedback, `/agents` roster, `$ultragoal` dispatch, unresolved `/command` report).
+- **Green gates.** `bun run typecheck` clean; `bun test` **1710 pass / 0 fail** across 211 files.
+
+## [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.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.33]** (2026-06-19) — A redesigned `jeo` forge mark — a hollow line-board crayfish/eyeglass emblem drawn as thick rounded-corner tubes (no letters, no DNA helix) — that now renders inside compact-scaled forge cards, plus a unified verification directive that adds gjc's test-quality contract, and a fresh `jeo --tmux` no-leak re-verification.
+- **[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.33",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/engine.ts

@@ -164,10 +164,18 @@ export const OUTPUT_DISCIPLINE = [
   "- Match reply length to the task: a one-line change gets a one-line report.",
 ].join("\n");
 
+/** gjc-inherited verification directive (plan/gjc-inheritance.md, round 16): the
+ *  done self-check PLUS gjc's `<verification>` test-quality contract — what makes a
+ *  test worth writing. Single source consumed by both executorSystemPrompt's default
+ *  and launch.ts's interactive prompt (was duplicated verbatim in both). */
+export const VERIFICATION_DIRECTIVE =
+  "Before calling done, self-check: did I run the test or command that exercises this change, are directly-affected callsites/tests/docs updated, and does my claim match real output? If any answer is no, keep working — do not call done. " +
+  "When you write tests, exercise observable behavior, edge values, branch conditions, invariants, and error handling — never assert defaults or tautologies.";
+
 export function executorSystemPrompt(
   role = "Executor Agent, a senior software developer",
   protocol: string = TOOL_PROTOCOL,
-  verificationDirective = "Before calling done, self-check: did I run the test or command that exercises this change, are directly-affected callsites/tests/docs updated, and does my claim match real output? If any answer is no, keep working — do not call done.",
+  verificationDirective = VERIFICATION_DIRECTIVE,
 ): string {
   return (
     `You are the ${role}.\n` +

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

@@ -1,7 +1,7 @@
 import { createInterface } from "node:readline/promises";
 import { emitKeypressEvents } from "node:readline";
 import { PassThrough } from "node:stream";
-import { runAgentLoop, DEFAULT_TOOLS, TOOL_PROTOCOL, WORKING_DISCIPLINE, OUTPUT_DISCIPLINE, type AgentLoopEvents } from "../agent/engine";
+import { runAgentLoop, DEFAULT_TOOLS, TOOL_PROTOCOL, WORKING_DISCIPLINE, OUTPUT_DISCIPLINE, VERIFICATION_DIRECTIVE, type AgentLoopEvents } from "../agent/engine";
 import { createOpikTracer, wrapEvents } from "../agent/opik-tracer";
 import { initialDynamicStepLimit } from "../agent/step-budget";
 import { memoryPromptSection, spawnDetachedDistill } from "../agent/memory";
@@ -15,11 +15,11 @@ import { runRalplanEngine, type RalplanEngineOptions } from "./ralplan";
 import { runTeamEngine, type TeamEngineOptions } from "./team";
 import { runUltragoalEngine, type UltragoalEngineOptions } from "./ultragoal";
 import { skillsPromptSection, loadSkills, buildSkillTask, workflowSkillsForPrompt, parseSkillInvocation, parseSkillChain, looksLikeSkillEcho, skillInvocationCard, type SkillDoc, type SkillInvocation } from "../skills/catalog";
-import { formatForgeBox } from "../tui/components/forge";
+import { formatForgeBox, scaleForgeWidth } 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";
@@ -470,7 +470,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     preamble + "\n\n" + protocol + "\n\n" +
     WORKING_DISCIPLINE + "\n\n" +
     OUTPUT_DISCIPLINE + "\n\n" +
-    "Before calling done, self-check: did I run the test or command that exercises this change, are directly-affected callsites/tests/docs updated, and does my claim match real output? If any answer is no, keep working — do not call done." +
+    VERIFICATION_DIRECTIVE +
     "\nWhen you have finished the user's request, or need to reply to or ask the user something, call done with {\"reason\": <your natural-language reply to the user>}. The reason text is shown to the user as your message." +
     (allowedTools.has("task") ? "\n\nDelegation: " + taskToolProtocolLine(cfg) +
     " Call task with {\"role\": <one of the advertised roles>, \"task\": <assignment>, \"context\": <optional>} to hand a focused slice to a subagent." : "") +
@@ -1194,7 +1194,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     {
       const card = formatForgeBox(
         { title: "[skill]", lines: skillInvocationCard(skill, intent) },
-        { width: Math.min(100, Math.max(40, (process.stdout.columns ?? 80) - 2)), unicode: supportsUnicode(), paint: accentPaint(uiTheme), paintShadow: accentShadowPaint(uiTheme), color: uiTheme.color },
+        { width: scaleForgeWidth(Math.min(100, Math.max(40, (process.stdout.columns ?? 80) - 2))), unicode: supportsUnicode(), paint: accentPaint(uiTheme), paintShadow: accentShadowPaint(uiTheme), color: uiTheme.color },
       );
       logLines(card);
     }
@@ -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/prompts/agents/executor.md

@@ -10,6 +10,7 @@ Turn a bounded task into a working, verified outcome with the smallest correct c
 - Keep diffs small and aligned to existing patterns.
 - Do not broaden scope or invent abstractions unless the task requires them.
 - Verify the task before calling done.
+- When you add tests, exercise observable behavior, edge values, branch conditions, invariants, and error handling — never assert defaults or tautologies.
 - Communicate the result through `done.reason` using the required output contract.
 </constraints>
 

package/src/tui/app.ts

@@ -24,7 +24,7 @@ import { centerBlock, padLineTo, boxBlock, BOX_ASCII, BOX_UNICODE } from "./comp
 import { SECTION_GAP, sectionLabel, stackSections } from "./components/section";
 import { resolveTheme, themeGradient, accentPaint, accentShadowPaint, diffPaint, mutedPaint, cardFillPaint } from "./components/themes";
 import { detectColorLevel, animatedGradientText, ColorLevel } from "./components/color";
-import { formatForgeBox, summarizeForgeInvocation, summarizeForgeResult, fitForgeBoxes, webSearchCardLines, type ForgeSummary } from "./components/forge";
+import { formatForgeBox, summarizeForgeInvocation, summarizeForgeResult, fitForgeBoxes, webSearchCardLines, scaleForgeWidth, type ForgeSummary } from "./components/forge";
 import { renderStatusBar, renderStatusBox, type StatusBoxData } from "./components/status";
 import { costForUsage } from "../ai/pricing";
 import { renderMarkdownTables } from "./components/markdown-table";
@@ -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();
   }
 
@@ -1198,7 +1206,7 @@ export class LaunchTui {
    *  Non-inline modes keep the card in `forgeSummaries` for the final static summary. */
   private flushForgeCard(summary: ForgeSummary, success?: boolean): void {
     if (!this.inline || this.finished) return;
-    const width = Math.max(24, size().cols - 1);
+    const width = scaleForgeWidth(size().cols - 1);
     // gjc D2 (state-encoded border): a FAILED card gets a red border so it pops
     // out of scrollback at a glance; OK/neutral cards keep the theme accent
     // identity. The ✓/✗ title mark already encodes state, but the border tone
@@ -1227,10 +1235,9 @@ export class LaunchTui {
     anim?: { phase: number; colorLevel: ColorLevel; beat: string },
     dim = false,
   ): string[] {
-    const floor = Math.min(24, width);
-    // Fill the available width so an in-frame box does not leave a dead right-margin
-    // column inside the outer panel.
-    const boxWidth = Math.max(floor, width);
+    // Forge cards render at a reduced (÷FORGE_SCALE) compact width rather than
+    // spanning the full available column run.
+    const boxWidth = scaleForgeWidth(width);
     const paint = this.theme.color ? accentPaint(this.theme) : (s: string) => s;
     const lines: string[] = [];
     for (const [i, summary] of this.forgeSummaries.slice(-maxEntries).entries()) {

package/src/tui/components/ascii-art.ts

@@ -412,46 +412,61 @@ export async function animateFrames(stage: AsciiStage, opts: AnimateFramesOption
   }
   return total;
 }
-/** The compact jeo forge mark: a symmetrical crayfish (가재) brand emblem composed
- *  of SIMPLE, DISCONNECTED shapes (no connecting strokes) that highlight the signature
- *  pincer CLAWS (집게) flanking the sides (◤◣ and ❮ on the left, ◥◢ and ❯ on the right),
- *  the body carrying the JEO wordmark (J E O), and a DNA double-helix woven above and
- *  below as a row of crossing nodes (╳ = base-pair crossings). gjc-forge aesthetic:
- *  clean negative space, geometric symmetry, the blue→violet→pink flow gradient applied
- *  by renderForgeMark doing the neon glow. Width-1 glyphs only (box drawing + geometrics)
- *  so padding/centering math stays exact. Frame 0 is the static symbol. */
+/** The compact jeo forge mark: a symmetrical crayfish (가재) brand emblem drawn as a
+ *  2.5×-thick LINE-BOARD (hollow outline, no fill) — the `>-<` silhouette of two pincer
+ *  CLAWS (집게) whose top arms bend (꺾임) inward toward a narrow central BRIDGE (the
+ *  eyeglass-frame / 안경태 bar). Every stroke is rendered as a thick rounded-corner tube
+ *  (╭╮╰╯ + ─│) so the shape reads as a heavy neon outline, not a filled block. No letters.
+ *  Width-1 glyphs only (box drawing) so padding/centering math stays exact, and the
+ *  blue→violet→pink flow gradient from renderForgeMark supplies the neon glow. Frame 0 is
+ *  the static symbol. */
 export const FORGE_MARK_ART: string[] = [
-  "◤   ╳ ╳ ╳ ╳   ◥",
-  "❮    J E O    ❯",
-  "◣   ╳ ╳ ╳ ╳   ◢"
+  "╭─────╮             ╭─────╮",
+  "│     │             │     │",
+  "╰─╮   │ ╭─────────╮ │   ╭─╯",
+  "  │   │ │         │ │   │  ",
+  "╭─╯ ╭─╯ ╰─────────╯ ╰─╮ ╰─╮",
+  "│   │                 │   │",
+  "╰───╯                 ╰───╯"
 ];
 
 export const FORGE_MARK_ART_ASCII: string[] = [
-  "/   x x x x   \\",
-  "<    J E O    >",
-  "\\   x x x x   /"
+  ".-----.             .-----.",
+  "|     |             |     |",
+  "'-.   | .---------. |   .-'",
+  "  |   | |         | |   |  ",
+  ".-' .-' '---------' '-. '-.",
+  "|   |                 |   |",
+  "'---'                 '---'"
 ];
 
-/** Claw-snap blink frames for the compact lobster forge mark: the helix nodes, the
- *  JEO body and the inner claw/tail glyphs stay fixed while the four splayed pincer
- *  CORNERS snap (◤◣ / ◥◢ open → ◢◥ / ◣◤ closed), so the lobster "clicks" its claws.
- *  Frame 0 === FORGE_MARK_ART, so a frameless render is byte-identical to the static
+/** Claw-snap blink frames for the compact lobster forge mark: the central bridge stays
+ *  fixed while the four pincer arms snap (open → clenched), so the lobster "clicks" its
+ *  claws. Frame 0 === FORGE_MARK_ART, so a frameless render is byte-identical to the static
  *  symbol. All lines share the same width and width-1 glyphs. */
 export const FORGE_MARK_FRAMES: string[][] = [
   FORGE_MARK_ART,
   [
-    "◢   ╳ ╳ ╳ ╳   ◣",
-    "❮    J E O    ❯",
-    "◥   ╳ ╳ ╳ ╳   ◤"
+    "╭───╮                 ╭───╮",
+    "│   │                 │   │",
+    "╰─╮ ╰─╮ ╭─────────╮ ╭─╯ ╭─╯",
+    "  │   │ │         │ │   │  ",
+    "╭─╯   │ ╰─────────╯ │   ╰─╮",
+    "│     │             │     │",
+    "╰─────╯             ╰─────╯"
   ]
 ];
 
 export const FORGE_MARK_FRAMES_ASCII: string[][] = [
   FORGE_MARK_ART_ASCII,
   [
-    "\\   x x x x   /",
-    "<    J E O    >",
-    "/   x x x x   \\"
+    ".---.                 .---.",
+    "|   |                 |   |",
+    "'-. '-. .---------. .-' .-'",
+    "  |   | |         | |   |  ",
+    ".-'   | '---------' |   '-.",
+    "|     |             |     |",
+    "'-----'             '-----'"
   ]
 ];
 
@@ -461,23 +476,34 @@ export function forgeMarkFrameCount(): number {
 }
 
 /** Grand hero variant for the welcome forge box (gjc-style spacious banner): the same
- *  symmetrical crayfish emblem rendered large — the splayed pincer claws as corner wedges
- *  (◤◣ left, ◥◢ right) and heavy brackets (❮ left, ❯ right), the JEO wordmark spaced
- *  across the body (J   E   O), and the DNA double-helix woven above and below as a wider
- *  row of crossing nodes (╳). gjc-forge aesthetic: generous negative space + geometric
- *  symmetry, with renderForgeMark's blue→violet→pink flow gradient supplying the neon glow.
- *  Width 29 (matches the welcome compact↔grand threshold) and width-1 glyphs only so
- *  padding/centering math stays exact. */
+ *  crayfish line-board emblem rendered large — the pincer claws and central eyeglass
+ *  bridge drawn as wider 3×-thick rounded outline tubes (╭╮╰╯ + ─│), no fill, no letters.
+ *  Width-1 glyphs only so padding/centering math stays exact, with renderForgeMark's
+ *  blue→violet→pink flow gradient supplying the neon glow. */
 export const FORGE_MARK_ART_GRAND: string[] = [
-  "◤        ╳ ╳ ╳ ╳ ╳ ╳        ◥",
-  "❮         J   E   O         ❯",
-  "◣        ╳ ╳ ╳ ╳ ╳ ╳        ◢"
+  "╭────────╮                    ╭────────╮",
+  "│        │                    │        │",
+  "│        │                    │        │",
+  "╰──╮     │  ╭──────────────╮  │     ╭──╯",
+  "   │     │  │              │  │     │   ",
+  "   │     │  │              │  │     │   ",
+  "╭──╯  ╭──╯  ╰──────────────╯  ╰──╮  ╰──╮",
+  "│     │                          │     │",
+  "│     │                          │     │",
+  "╰─────╯                          ╰─────╯"
 ];
 
 export const FORGE_MARK_ART_GRAND_ASCII: string[] = [
-  "/        x x x x x x        \\",
-  "<         J   E   O         >",
-  "\\        x x x x x x        /"
+  ".--------.                    .--------.",
+  "|        |                    |        |",
+  "|        |                    |        |",
+  "'--.     |  .--------------.  |     .--'",
+  "   |     |  |              |  |     |   ",
+  "   |     |  |              |  |     |   ",
+  ".--'  .--'  '--------------'  '--.  '--.",
+  "|     |                          |     |",
+  "|     |                          |     |",
+  "'-----'                          '-----'"
 ];
 
 // Bounded memo of fully-rendered forge-mark frames keyed by every input that affects

package/src/tui/components/forge.ts

@@ -479,6 +479,15 @@ export function fitForgeBoxes(lines: string[], budget: number): string[] {
   return out;
 }
 
+/** Forge cards render at a reduced scale: the available width is divided by this
+ *  factor so a box reads as a compact panel instead of spanning the full terminal. */
+export const FORGE_SCALE = 1.2;
+
+/** Scale a caller's available width down to the forge card's compact render width. */
+export function scaleForgeWidth(available: number): number {
+  return Math.max(24, Math.trunc(available / FORGE_SCALE));
+}
+
 export function formatForgeBox(summary: ForgeSummary, opts: ForgeBoxOptions = {}): string[] {
   const innerWidth = opts.width ?? 80;
   const floor = Math.min(24, innerWidth);

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,