jeo-code 0.6.22 → 0.6.24

package/src/tui/app.ts

@@ -16,7 +16,7 @@ import { Spinner } from "./components/spinner";
 import { ToolList } from "./components/tool-list";
 import { StreamRegion } from "./components/stream";
 import { renderFooter, type FooterData } from "./components/footer";
-import { renderDnaClaw, dnaClawHeight, dnaClawFrameCount, dnaClawBeat, DNA_FLOW_PALETTE } from "./components/ascii-art";
+import { renderForgeMark, forgeMarkHeight, forgeMarkFrameCount, forgeBeat, FORGE_FLOW_PALETTE } from "./components/ascii-art";
 import { evolutionTrack, createStageProgress, type StageProgress, transitionMessage } from "./components/evolution";
 import type { TaskSubEvent } from "../agent/task-tool";
 import { supportsUnicode } from "./components/capability";
@@ -30,7 +30,7 @@ import { costForUsage } from "../ai/pricing";
 import { renderMarkdownTables } from "./components/markdown-table";
  
 import { stripMarkdown, renderMarkdownAnsi } from "./components/markdown-text";
-import { visibleWidth, wrapTextWithAnsi, truncateToWidth, sanitizeForFrame } from "./components/width";
+import { visibleWidth, wrapTextWithAnsi, truncateToWidth, sanitizeForFrame, lastValueCache } from "./components/width";
 import { categoryBadge } from "./components/category-index";
 import { formatStepTimeline, stepsFromTools, formatStepHeader, formatStepTimelineCompact, formatDuration as formatToolMs, type StepState } from "./components/step-timeline";
 import { formatHintBar } from "./components/hints";
@@ -86,10 +86,9 @@ function extractStreamingReasoning(buf: string): string {
   catch { return m[1].replace(/\\\\/g, "\\").replace(/\\n/g, " ").replace(/\\"/g, '"'); }
 }
 
-/** Uniform live-activity fallback for models that stream no `reasoning` field: derive
- *  what the model is doing from the forming JSON (`"tool":"x"` → "calling x…") or, for
- *  prose-replying models, show the reply head — so the live status field behaves identically
- *  across providers/models instead of staying silent for some of them. */
+/** Derive a HUD STATUS (never content) from the forming stream: `"tool":"x"` → "calling
+ *  x…", bare JSON/fence → "forming the next tool call…", prose reply → "writing the
+ *  reply…". The reply/reasoning TEXT itself belongs in the Thinking block, not the HUD. */
 function extractStreamingActivity(buf: string): string {
   const head = buf.length > 512 ? buf.slice(0, 512) : buf;
   const tool = head.match(/"tool"\s*:\s*"([^"]+)"/)?.[1];
@@ -97,7 +96,7 @@ function extractStreamingActivity(buf: string): string {
   const t = head.trim();
   if (!t) return "";
   if (t.startsWith("{") || t.startsWith("```")) return "forming the next tool call…";
-  return t.replace(/\s+/g, " ").slice(0, 140);
+  return "writing the reply…";
 }
 
 /** Bound the input to a per-frame wrap to a fixed trailing window. The live thinking
@@ -265,6 +264,10 @@ export class LaunchTui {
   private cachedFrame = -1;
   private cachedArt: string[] = [];
   private cachedTrack = "";
+  // Per-label (Thinking / Output) single-slot wrap memo: the 120ms spinner tick
+  // re-renders the frame ~8×/s, but the streamed text changes only on a new delta —
+  // so the live block reuses its prior wrap instead of re-segmenting the 16KB tail.
+  private readonly liveBlockWrapCaches = new Map<string, (key: string, compute: () => string[]) => string[]>();
   // Monotonic stage progress so evolution only ever moves forward this turn.
   private readonly progress: StageProgress = createStageProgress();
   // Terminal unicode capability, detected once (drives spinner/track glyph set).
@@ -393,25 +396,20 @@ export class LaunchTui {
         this.draw();
       },
       onModelStream: textSoFar => {
-        // Surface the model's LIVE activity uniformly for every model/provider:
-        // the streamed `reasoning` field when the model emits one, else a derived
-        // fallback (tool being formed / reply prose head) — so no model leaves the
-        // live status field silent while it streams.
-        // Draws are THROTTLED to one per 100ms: the old per-delta draw() rendered
-        // the full frame hundreds of times per response (a real chunk of jeo's
-        // per-step latency); the 120ms timer tick covers the gaps anyway.
+        // The model's JSON-protocol `reasoning` field → the live Thinking block (alongside
+        // native reasoning). The HUD status row gets ONLY a derived STATUS — never the raw
+        // reasoning/reply text, so a JSON-streaming model shows "forming the next tool
+        // call…", not its JSON content. Draws throttled to ≤1/100ms (timer covers gaps).
         const r = extractStreamingReasoning(textSoFar);
         let changed = false;
-        if (r) {
-          changed = r !== this.streamingReasoning;
+        if (r && r !== this.streamingReasoning) {
           this.streamingReasoning = r;
-          this.streamingActivity = r;
-        } else {
-          const fallback = extractStreamingActivity(textSoFar);
-          if (fallback && fallback !== this.streamingActivity) {
-            this.streamingActivity = fallback;
-            changed = true;
-          }
+          changed = true;
+        }
+        const status = extractStreamingActivity(textSoFar);
+        if (status && status !== this.streamingActivity) {
+          this.streamingActivity = status;
+          changed = true;
         }
         if (changed && Date.now() - this.lastStreamDraw >= 100) {
           this.lastStreamDraw = Date.now();
@@ -624,10 +622,21 @@ export class LaunchTui {
     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). */
+  setLivePromptHint(lines: string[]): void {
+    if (this.finished) return;
+    const next = lines ?? [];
+    if (next.join("\n") === this.livePromptHint.join("\n")) return;
+    this.livePromptHint = next;
+    this.draw();
+  }
+
   private renderLiveInputBox(cols: number): string[] {
     const caret = this.unicode ? "▌" : "_";
     const display = this.livePromptInput ? `${this.livePromptInput}${caret}` : "";
-    return renderInputBox(display, {
+    const box = renderInputBox(display, {
       cols: Math.max(24, cols),
       color: this.theme.color,
       unicode: this.unicode,
@@ -636,6 +645,9 @@ export class LaunchTui {
       placeholder: "Type your next message...",
       maxBodyRows: 2,
     });
+    if (this.livePromptHint.length === 0) return box;
+    const dim = this.theme.color ? chalk.dim : (s: string) => s;
+    return [...this.livePromptHint.map(l => dim(l)), ...box];
   }
 
   /** Render a `user`-labeled query card (orange "user" header over a filled box).
@@ -884,6 +896,7 @@ export class LaunchTui {
     this.turnUsage = null;
     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.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);
@@ -1173,11 +1186,11 @@ export class LaunchTui {
         index: i + 1,
         color: this.theme.color,
         dim,
-        // DNA-flow identity on LIVE cards only: the flowing helix gradient rides
-        // the card border and the claw beat marks the title. Flushed/final cards
+        // Forge-flow identity on LIVE cards only: the flowing neon gradient rides
+        // the card border and the prompt beat marks the title. Flushed/final cards
         // stay static. Suppressed while `dim` (in-flight shading takes precedence).
         ...(anim && !dim
-          ? { flow: { palette: DNA_FLOW_PALETTE, phase: anim.phase, colorLevel: anim.colorLevel }, titleMark: anim.beat }
+          ? { flow: { palette: FORGE_FLOW_PALETTE, phase: anim.phase, colorLevel: anim.colorLevel }, titleMark: anim.beat }
           : {}),
       }));
     }
@@ -1197,10 +1210,17 @@ export class LaunchTui {
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
     if (!text.trim()) return [];
     const wrapW = Math.max(8, cols - 2);
-    const wrapped = tailForWrap(text)
-      .split("\n")
-      .flatMap(l => wrapTextWithAnsi(l, wrapW))
-      .filter(l => l.length > 0);
+    // Memoize the wrap: only the spinner/clock change on most 120ms ticks, so re-wrapping
+    // this (up to 16KB) tail every frame just re-segments graphemes for no visible change.
+    // Per-label slot (Thinking / Output) keyed by wrap width + text — a real delta misses
+    // once and recomputes; an idle tick hits the cache. `rows` only gates the post-slice.
+    let cache = this.liveBlockWrapCaches.get(label);
+    if (!cache) { cache = lastValueCache<string[]>(); this.liveBlockWrapCaches.set(label, cache); }
+    const wrapped = cache(`${wrapW}\u0000${text}`, () =>
+      tailForWrap(text)
+        .split("\n")
+        .flatMap(l => wrapTextWithAnsi(l, wrapW))
+        .filter(l => l.length > 0));
     if (wrapped.length === 0) return [];
     const cap = Math.max(3, Math.min(ceiling, Math.floor(rows * 0.3)));
     const out: string[] = [sectionLabel(label, Math.max(8, cols), { color: this.theme.color, unicode: this.unicode })];
@@ -1312,10 +1332,10 @@ export class LaunchTui {
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
     const colorLevel = detectColorLevel(process.env, isTTY());
     // One quantized animation clock for the whole frame: gradient phase cycles 20
-    // steps, the claw beat advances every 3 ticks. Quantization keeps repaints
+    // steps, the prompt beat advances every 3 ticks. Quantization keeps repaints
     // coherent (status field + forge border move together) and bounds per-tick work.
     const phase = (this.tickCount * 0.05) % 1;
-    const beat = dnaClawBeat(Math.trunc(this.tickCount / 3), this.unicode);
+    const beat = forgeBeat(Math.trunc(this.tickCount / 3), this.unicode);
 
     // Assemble the bottom-pinned tail FIRST (status line → todos → hud → model bar):
     // it is the live heartbeat and must always be visible; the in-flight card gets
@@ -1423,9 +1443,9 @@ export class LaunchTui {
     const innerWidth = !fit ? cols : this.inline ? cols - 1 : cols - 4;
 
     // Resolve the current (monotonic) stage for the track; announce a transition
-    // once when it first advances. The header art is the DNA Claw brand symbol —
-    // a twist-frame helix rotation combined with the flowing gradient phase.
-    // Both are quantized (3 twist frames × 20 gradient phases), so the cache
+    // once when it first advances. The header art is the jeo forge mark — a
+    // prompt-cursor blink combined with the flowing gradient phase. Both are
+    // quantized (2 blink frames × 20 gradient phases), so the cache
     // recomputes at most once per changed tick and stays a single slot (O(1)).
     const stepNow = this.footer.step || 0;
     const idx = this.progress.observe(stepNow, this.footer.maxSteps ?? DEFAULT_MAX_STEPS);
@@ -1435,16 +1455,16 @@ export class LaunchTui {
       this.appendLedger(`${arrow} ${transitionMessage(idx)}\n`, "notice");
     }
     const showArt = fit && !this.inline && rows >= 18 && cols >= 40;
-    // One int key folds both animation axes: twist frame advances every 3 ticks,
+    // One int key folds both animation axes: blink frame advances every 3 ticks,
     // gradient phase cycles 20 quantized steps (tickCount*0.05 % 1).
-    const twist = isThinking ? Math.trunc(this.tickCount / 3) % dnaClawFrameCount() : 0;
+    const twist = isThinking ? Math.trunc(this.tickCount / 3) % forgeMarkFrameCount() : 0;
     const qPhase = isThinking ? this.tickCount % 20 : 0;
     const effFrame = twist * 100 + qPhase;
     if (showArt && (idx !== this.cachedStageIndex || cols !== this.cachedCols || effFrame !== this.cachedFrame)) {
-      // Commit the cache keys only AFTER the render succeeds: if renderDnaClaw ever
+      // Commit the cache keys only AFTER the render succeeds: if renderForgeMark ever
       // throws (resize race, bad gradient level), pre-committed keys would mark the
       // STALE art as current and freeze the header at an old frame forever.
-      const art = renderDnaClaw({
+      const art = renderForgeMark({
         cols: innerWidth,
         phase: qPhase * 0.05,
         frame: twist,
@@ -1459,7 +1479,7 @@ export class LaunchTui {
       this.cachedCols = cols;
       this.cachedFrame = effFrame;
     }
-    const artLinesCount = showArt ? dnaClawHeight() : 0;
+    const artLinesCount = showArt ? forgeMarkHeight() : 0;
     const trackCount = showArt ? 1 : 0;
     const headerHeight = artLinesCount + trackCount + (showArt ? 1 : 0);
 

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

@@ -412,128 +412,90 @@ export async function animateFrames(stage: AsciiStage, opts: AnimateFramesOption
   }
   return total;
 }
-export const DNA_CLAW_ART: string[] = [
-  "  ╭╯   ◆  ◆   ╰╮  ",
-  " ╭╯   ╱╲  ╱╲   ╰╮ ",
-  " ║    ╲ ╳ ╱     ║ ",
-  " ╰╮    ╳ ╳     ╭╯ ",
-  "  ╰╮  ╱ ╳ ╲   ╭╯  ",
-  "   ╚══○   ○══╝    ",
-  "      ║   ║       ",
-  "   [ DNA Claw ]   "
+/** The compact jeo forge mark: a clean, wordless pictograph of the mascot neon
+ *  crayfish. Read top→bottom — antennae arc outward (╲ ╱) flanking the asymmetric
+ *  sunglasses face (◆ blue lens / ◇ pink lens on a ┃ nose-bridge); the front claws
+ *  (❮ ❯) on short arms (━┫ ┣━) hugging the rounded carapace (◉◉◉); tucked legs
+ *  (╲ ┃ ╱); the tail fan tipped by the blinking telson (◀▮▶). The mark is purely
+ *  symbolic — NO embedded lettering (the brand wordmark lives in the welcome
+ *  header, not under the emblem). Width-1 glyphs only (box drawing + geometrics)
+ *  so padding/centering math stays exact. Frame 0 is the static symbol. */
+export const FORGE_MARK_ART: string[] = [
+  "      ╲ ◆ ┃ ◇ ╱      ",
+  "     ❮━┫ ◉◉◉ ┣━❯     ",
+  "        ╲ ┃ ╱        ",
+  "         ◀▮▶         "
 ];
 
-export const DNA_CLAW_ART_ASCII: string[] = [
-  "  /{   *  *   }\\  ",
-  " /{   / \\ / \\  }\\ ",
-  " |    \\  X  /   | ",
-  " \\{    X X     }/ ",
-  "  \\{  / X \\   }/  ",
-  "   \\==o   o==/    ",
-  "      |   |       ",
-  "   [ DNA Claw ]   "
+export const FORGE_MARK_ART_ASCII: string[] = [
+  "      \\ * | o /      ",
+  "     <=[ @@@ ]=>     ",
+  "        \\ | /        ",
+  "         <#>         "
 ];
 
-/** Twist animation frames for the compact DNA Claw: the claw silhouette stays
- *  fixed while the inner helix lattice rotates. Frame 0 === DNA_CLAW_ART, so a
- *  frameless render is byte-identical to the static symbol. All lines are the
- *  same width (18) and every glyph is display-width 1. */
-export const DNA_CLAW_FRAMES: string[][] = [
-  DNA_CLAW_ART,
+/** Blink animation frames for the compact crayfish forge mark: the antennae,
+ *  carapace and legs stay fixed while the telson cursor blinks (▮ → ▯) and the
+ *  asymmetric sunglass lenses swap accent (◆ ◇ → ◇ ◆), so the crayfish "winks".
+ *  Frame 0 === FORGE_MARK_ART, so a frameless render is byte-identical to the
+ *  static symbol. All lines share the same width (21) and width-1 glyphs. */
+export const FORGE_MARK_FRAMES: string[][] = [
+  FORGE_MARK_ART,
   [
-    "  ╭╯   ◆  ◆   ╰╮  ",
-    " ╭╯   ╲╱  ╲╱   ╰╮ ",
-    " ║     ╳ ╳      ║ ",
-    " ╰╮   ╱ ╳ ╲    ╭╯ ",
-    "  ╰╮   ╳ ╳    ╭╯  ",
-    "   ╚══○   ○══╝    ",
-    "      ║   ║       ",
-    "   [ DNA Claw ]   "
-  ],
-  [
-    "  ╭╯   ◆  ◆   ╰╮  ",
-    " ╭╯   ╱╲  ╱╲   ╰╮ ",
-    " ║     ╳ ╳      ║ ",
-    " ╰╮   ╲ ╳ ╱    ╭╯ ",
-    "  ╰╮    ╳ ╳   ╭╯  ",
-    "   ╚══○   ○══╝    ",
-    "      ║   ║       ",
-    "   [ DNA Claw ]   "
+    "      ╲ ◇ ┃ ◆ ╱      ",
+    "     ❮━┫ ◉◉◉ ┣━❯     ",
+    "        ╲ ┃ ╱        ",
+    "         ◀▯▶         "
   ]
 ];
 
-export const DNA_CLAW_FRAMES_ASCII: string[][] = [
-  DNA_CLAW_ART_ASCII,
-  [
-    "  /{   *  *   }\\  ",
-    " /{   \\ / \\ /  }\\ ",
-    " |     X X      | ",
-    " \\{   / X \\    }/ ",
-    "  \\{   X X    }/  ",
-    "   \\==o   o==/    ",
-    "      |   |       ",
-    "   [ DNA Claw ]   "
-  ],
+export const FORGE_MARK_FRAMES_ASCII: string[][] = [
+  FORGE_MARK_ART_ASCII,
   [
-    "  /{   *  *   }\\  ",
-    " /{   / \\ / \\  }\\ ",
-    " |     X X      | ",
-    " \\{   \\ X /    }/ ",
-    "  \\{    X X   }/  ",
-    "   \\==o   o==/    ",
-    "      |   |       ",
-    "   [ DNA Claw ]   "
+    "      \\ o | * /      ",
+    "     <=[ @@@ ]=>     ",
+    "        \\ | /        ",
+    "         <_>         "
   ]
 ];
 
-/** Number of twist frames in the compact DNA Claw animation cycle. */
-export function dnaClawFrameCount(): number {
-  return DNA_CLAW_FRAMES.length;
+/** Number of blink frames in the compact forge-mark animation cycle. */
+export function forgeMarkFrameCount(): number {
+  return FORGE_MARK_FRAMES.length;
 }
 
-/** Grand hero variant for the welcome forge box (gjc-style spacious banner):
- *  a wide claw whose pincers frame a twisting DNA helix. Width-1 glyphs only
- *  (box drawing + diagonals + geometrics) so padding/centering math stays exact. */
-export const DNA_CLAW_ART_GRAND: string[] = [
-  "      ◆◆                    ◆◆      ",
-  "   ╭──╯╰──╮              ╭──╯╰──╮   ",
-  "  ╭╯      ╰╮   ╲╲  ╱╱   ╭╯      ╰╮  ",
-  " ╭╯        ║    ╲╳╳╱    ║        ╰╮ ",
-  " ║         ║     ╳╳     ║         ║ ",
-  " ║         ║    ╱╳╳╲    ║         ║ ",
-  " ╰╮        ║   ╱╱  ╲╲   ║        ╭╯ ",
-  "  ╰╮       ║   ╲╲  ╱╱   ║       ╭╯  ",
-  "   ╰──╮    ║    ╲╳╳╱    ║    ╭──╯   ",
-  "      ╰════○     ╳╳     ○════╯      ",
-  "           ║    ╱╳╳╲    ║           ",
-  "        [ D N A · C L A W ]         "
+/** Grand hero variant for the welcome forge box (gjc-style spacious banner): the
+ *  same mascot crayfish rendered large and wordless — antennae (╲ ╱) flanking the
+ *  asymmetric ◆/◇ sunglasses face on a ┃ nose-bridge, the big front pincers
+ *  (❮━━┫ ┣━━❯) hugging the segmented carapace (◉ ◉ ◉), tucked legs, and the broad
+ *  tail fan tipped by the telson (◀──▮──▶). Purely symbolic — NO embedded
+ *  lettering or caption. Width-1 glyphs only so padding/centering math stays
+ *  exact. */
+export const FORGE_MARK_ART_GRAND: string[] = [
+  "        ╲   ◆ ┃ ◇   ╱        ",
+  "       ❮━━┫ ◉ ◉ ◉ ┣━━❯       ",
+  "          ╲ ╲ ┃ ╱ ╱          ",
+  "           ◀──▮──▶           "
 ];
 
-export const DNA_CLAW_ART_GRAND_ASCII: string[] = [
-  "      **                    **      ",
-  "   /--'`--\\              /--'`--\\   ",
-  "  /'      `\\   \\\\  //   /'      `\\  ",
-  " /'        |    \\XX/    |        `\\ ",
-  " |         |     XX     |         | ",
-  " |         |    /XX\\    |         | ",
-  " \\,        |   //  \\\\   |        ,/ ",
-  "  \\,       |   \\\\  //   |       ,/  ",
-  "   \\--,    |    \\XX/    |    ,--/   ",
-  "      \\====o     XX     o====/      ",
-  "           |    /XX\\    |           ",
-  "        [ D N A . C L A W ]         "
+export const FORGE_MARK_ART_GRAND_ASCII: string[] = [
+  "        \\   * | o   /        ",
+  "       <==[ O O O ]==>       ",
+  "          \\ \\ | / /          ",
+  "           <--#-->           "
 ];
 
-// Bounded memo of fully-rendered DNA Claw frames keyed by every input that affects
+
+// Bounded memo of fully-rendered forge-mark frames keyed by every input that affects
 // output (grand/unicode/cols/color/colorLevel/phase/frame). The live HUD cycles a
-// FIXED ~60-frame set (3 twists × 20 gradient phases) at ~120ms; without this each
-// recurrence recomputed per-line animatedGradientText (ANSI gradient) from scratch.
-// The memo makes the 2nd+ cycle O(1) lookups, cutting steady-state HUD CPU. LRU-capped.
-const dnaClawMemo = new Map<string, string[]>();
-const DNA_CLAW_MEMO_CAP = 256;
-const EMPTY_DNA_FRAME: string[] = [];
+// FIXED frame set (blink × gradient phases) at ~120ms; without this each recurrence
+// recomputed per-line animatedGradientText (ANSI gradient) from scratch. The memo
+// makes the 2nd+ cycle O(1) lookups, cutting steady-state HUD CPU. LRU-capped.
+const forgeMarkMemo = new Map<string, string[]>();
+const FORGE_MARK_MEMO_CAP = 256;
+const EMPTY_FORGE_FRAME: string[] = [];
 
-export function renderDnaClaw(opts: {
+export function renderForgeMark(opts: {
   cols?: number;
   phase?: number;
   unicode?: boolean;
@@ -541,34 +503,35 @@ export function renderDnaClaw(opts: {
   colorLevel?: ColorLevel;
   /** Grand hero variant (welcome forge box); default is the compact in-turn symbol. */
   grand?: boolean;
-  /** Twist-animation frame (compact symbol only; wraps). The helix lattice rotates
-   *  while the claw silhouette stays fixed — combined with the flowing gradient
-   *  `phase` this animates the forge identity without any frame-count growth. */
+  /** Blink-animation frame (compact symbol only; wraps). The cursor blinks and the
+   *  status lamps swap while the window silhouette stays fixed — combined with the
+   *  flowing gradient `phase` this animates the forge identity without any
+   *  frame-count growth. */
   frame?: number;
 }): string[] {
   const memoKey = `${opts.grand ? "g" : "c"}|${opts.unicode !== false ? 1 : 0}|${opts.cols ?? -1}|${opts.color !== false ? 1 : 0}|${opts.colorLevel ?? ColorLevel.TrueColor}|${opts.phase ?? 0}|${opts.frame ?? 0}`;
-  const memoHit = dnaClawMemo.get(memoKey);
+  const memoHit = forgeMarkMemo.get(memoKey);
   if (memoHit) return memoHit;
   const useUnicode = opts.unicode !== false;
   let source: string[];
   if (opts.grand) {
-    source = useUnicode ? DNA_CLAW_ART_GRAND : DNA_CLAW_ART_GRAND_ASCII;
+    source = useUnicode ? FORGE_MARK_ART_GRAND : FORGE_MARK_ART_GRAND_ASCII;
   } else {
-    const frames = useUnicode ? DNA_CLAW_FRAMES : DNA_CLAW_FRAMES_ASCII;
+    const frames = useUnicode ? FORGE_MARK_FRAMES : FORGE_MARK_FRAMES_ASCII;
     const f = Math.abs(Math.trunc(opts.frame ?? 0)) % frames.length;
     source = frames[f]!;
   }
   const width = Math.max(0, ...source.map(l => l.length));
 
   if (opts.cols !== undefined && opts.cols < width) {
-    dnaClawMemo.set(memoKey, EMPTY_DNA_FRAME);
-    return EMPTY_DNA_FRAME;
+    forgeMarkMemo.set(memoKey, EMPTY_FORGE_FRAME);
+    return EMPTY_FORGE_FRAME;
   }
 
   const phase = opts.phase ?? 0;
   const useColor = opts.color !== false;
   const colorLevel = opts.colorLevel ?? ColorLevel.TrueColor;
-  const palette = DNA_FLOW_PALETTE;
+  const palette = FORGE_FLOW_PALETTE;
 
   const result = source.map((line, idx) => {
     const padded = line.length < width ? line + " ".repeat(width - line.length) : line;
@@ -578,25 +541,29 @@ export function renderDnaClaw(opts: {
     return animatedGradientText(padded, palette, phase + idx * 0.07, { colorLevel });
   });
 
-  if (dnaClawMemo.size >= DNA_CLAW_MEMO_CAP) {
-    const oldest = dnaClawMemo.keys().next().value;
-    if (oldest !== undefined) dnaClawMemo.delete(oldest);
+  if (forgeMarkMemo.size >= FORGE_MARK_MEMO_CAP) {
+    const oldest = forgeMarkMemo.keys().next().value;
+    if (oldest !== undefined) forgeMarkMemo.delete(oldest);
   }
-  dnaClawMemo.set(memoKey, result);
+  forgeMarkMemo.set(memoKey, result);
   return result;
 }
 
-/** The DNA Claw identity palette (emerald → cyan → violet helix flow). Shared by
- *  the claw art and the forge-card border flow so the brand gradient is uniform. */
-export const DNA_FLOW_PALETTE: readonly string[] = ["#10ac84", "#48dbfb", "#8e44ad"];
+/** The jeo identity palette — the mascot crayfish's synthwave neon read straight
+ *  off the character: blue antennae glow → violet carapace → pink claw tips.
+ *  Shared by the forge mark and the forge-card border flow so the whole brand
+ *  glows in the crayfish-wizard's signature blue→violet→pink shell sheen. */
+export const FORGE_FLOW_PALETTE: readonly string[] = ["#48dbfb", "#8e44ad", "#f368e0"];
 
-/** Width-1 "claw beat" glyph for an animation tick — the ◆/╳/○ motifs of the
- *  claw art cycling in place. Used as the live forge-card title mark. */
-export function dnaClawBeat(frame: number, unicode = true): string {
-  const beats = unicode ? ["◆", "╳", "○"] : ["*", "X", "o"];
+/** Width-1 forge title-mark glyph cycling the mascot's `jeo>` terminal prompt:
+ *  a prompt caret then a blinking block cursor (filled → hollow), echoing the
+ *  glowing terminal screen the character holds. Used as the live forge-card
+ *  title mark, so an in-flight card reads as a live coding-agent prompt. */
+export function forgeBeat(frame: number, unicode = true): string {
+  const beats = unicode ? ["❯", "▮", "▯"] : [">", "#", "_"];
   return beats[Math.abs(Math.trunc(frame)) % beats.length]!;
 }
 
-export function dnaClawHeight(): number {
-  return DNA_CLAW_ART.length;
+export function forgeMarkHeight(): number {
+  return FORGE_MARK_ART.length;
 }

package/src/tui/components/autocomplete.ts

@@ -50,6 +50,7 @@ export interface CompletionResult {
 
 const PREVIEW_LABEL: Record<string, string> = {
   command: "Commands",
+  skill: "Skills",
   model: "Models",
   provider: "Providers",
   role: "Subagent roles",
@@ -219,6 +220,21 @@ export function formatCompletionPreview(line: string, ctx: CompletionContext, ma
   return lines;
 }
 
+/** Compact mid-turn command/skill preview. Like formatCompletionPreview but ALSO
+ *  surfaces command-name and $skill-name matches (the kinds the argument-only preview
+ *  skips), so a /command or $skill typed WHILE a turn runs visibly reacts. */
+export function formatMidTurnHint(line: string, ctx: CompletionContext, max = 5): string[] {
+  if (max <= 0) return [];
+  const result = complete(line, ctx);
+  if (result.completions.length === 0) return [];
+  const label = PREVIEW_LABEL[result.kind] ?? "Matches";
+  const shown = result.completions.slice(0, max);
+  const hidden = result.completions.length - shown.length;
+  const lines = [`${label}:`, ...shown.map(c => `  ${c}`)];
+  if (hidden > 0) lines.push(`  …(+${hidden} more)`);
+  return lines;
+}
+
 /** Longest common prefix of a list (for tab "fill to ambiguity"). */
 export function commonPrefix(items: string[]): string {
   if (items.length === 0) return "";

package/src/tui/components/forge.ts

@@ -27,7 +27,7 @@ export interface ForgeBoxOptions {
    *  `phase` per tick, so nothing is retained between frames. Below TrueColor
    *  (`colorLevel < 3`) this degrades to the static `paint`/`paintShadow`. */
   flow?: { palette: readonly string[]; phase: number; colorLevel: number };
-  /** Width-1 mark prepended to the border title (e.g. the DNA claw beat glyph). */
+  /** Width-1 mark prepended to the border title (e.g. the jeo prompt beat glyph). */
   titleMark?: string;
   /** Themed +/- painters for `language: "patch"` cards (edit diffs): applied to
    *  the FULL padded row so added/removed lines read as background-tinted