jeo-code 0.6.26 → 0.6.28

package/src/commands/launch.ts

@@ -36,7 +36,7 @@ import { callLlm, type Message } from "../agent/loop";
 import { friendlyProviderError } from "../util/provider-error";
 import { readGlobalConfig, saveConfigPatch } from "../agent/state";
 import { rememberModelPatch, recentModelsForDisplay } from "../agent/model-recency";
-import { describeModel, describeAllProviders, thinkingMaxTokens, thinkingToReasoningEffort, discoverModels, flattenModels, resolveSelection, catalogMetadata, resolveRoleModel, CODEX_MODELS, qualifyModelId } from "../ai";
+import { describeModel, describeAllProviders, thinkingMaxTokens, thinkingToReasoningEffort, discoverModels, flattenModels, resolveSelection, catalogMetadata, catalogByProvider, resolveRoleModel, CODEX_MODELS, qualifyModelId } from "../ai";
 import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLevel } from "../ai";
 import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../agent/goal-verifier";
 
@@ -232,6 +232,42 @@ function providerDefaultModel(p: ProviderName): string {
   return openaiCompatDef(p)?.defaultModel ?? STATIC_PROVIDER_DEFAULT[p] ?? "";
 }
 
+/**
+ * Pick-list entries for ONE provider, with static fallbacks so the list is never
+ * empty.
+ *
+ * Live discovery yields ids only for a logged-in, reachable provider, and
+ * `catalogOr` backfills the static catalog ONLY for OAuth sources — so an
+ * API-key/keyless provider that isn't configured yet had an empty list and was
+ * silently pinned to a bare default. Prefer live ids; else the provider's
+ * capability catalog; else its single known default model (all 24 OpenAI-compat
+ * providers carry one) so the user always sees at least one pickable id.
+ */
+export function providerPickEntries(live: ProviderModelsResult[], want: ProviderName): PickEntry[] {
+  const fromLive = flattenModels(live.filter(r => r.provider === want));
+  if (fromLive.length) return fromLive;
+  const catalog = catalogByProvider(want);
+  if (catalog.length) {
+    return catalog.map((m, i) => ({ index: i + 1, provider: want, model: qualifyModelId(m.providerModel, want) }));
+  }
+  // Offline fallback for catalog-less (OpenAI-compatible) providers: the def's
+  // defaultModel first, then its knownModels list, so the per-role provider picker
+  // shows several pickable ids instead of one. De-duped + provider-qualified.
+  const def = openaiCompatDef(want);
+  if (def) {
+    const ids = [def.defaultModel, ...(def.knownModels ?? [])].map(m => qualifyModelId(m, want));
+    const seen = new Set<string>();
+    const entries: PickEntry[] = [];
+    for (const model of ids) {
+      if (seen.has(model)) continue;
+      seen.add(model);
+      entries.push({ index: entries.length + 1, provider: want, model });
+    }
+    if (entries.length) return entries;
+  }
+  const fallback = providerDefaultModel(want);
+  return fallback ? [{ index: 1, provider: want, model: qualifyModelId(fallback, want) }] : [];
+}
 
 export function formatResumeHint(sessionId: string): string {
   return `Resume with: jeo launch --resume ${sessionId}`;
@@ -487,6 +523,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // answer). Captured from the reasoning stream and persisted on the assistant message so
   // it survives /resume + export (gjc "think → answer" record). Reset at each turn start.
   let lastTurnReasoning = "";
+  // Native reasoning artifacts for the FINAL (done) step — the engine attaches intermediate
+  // steps' artifacts to their own pushed messages, but the done turn is built here. Reset on
+  // each step boundary so only the last step's artifacts ride the final reply (no duplication).
+  let lastTurnArtifacts: import("../ai/types").ReasoningArtifact[] = [];
   /** Wrap turn events so EVERY sink (TUI or plain stream) records the last full
    *  tool output for the Ctrl+O detail view. */
   const withToolDetailCapture = (base: ReturnType<LaunchTui["events"]>): ReturnType<LaunchTui["events"]> => ({
@@ -495,12 +535,22 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       lastToolDetail = { tool, output };
       base.onToolResult?.(tool, success, output);
     },
+    onStep: (step: number) => {
+      // New step: drop the prior step's final-reply artifacts so only the LAST step's ride
+      // the done reply (intermediate steps are persisted by the engine on their own turns).
+      lastTurnArtifacts = [];
+      base.onStep?.(step);
+    },
     onReasoningStream: (textSoFar: string) => {
       // textSoFar is the cumulative thought for the current step; keep the latest
       // non-empty value (the thought immediately preceding the turn's answer).
       if (textSoFar.trim()) lastTurnReasoning = textSoFar;
       base.onReasoningStream?.(textSoFar);
     },
+    onReasoningArtifactStream: (artifact) => {
+      lastTurnArtifacts.push(artifact);
+      base.onReasoningArtifactStream?.(artifact);
+    },
   });
   /** Compose a session-persistence flush into onStep so each completed step is
    *  written as it lands (durability across mid-turn interruption) without
@@ -603,6 +653,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // persistence block below.
     let beforeLen = history.length;
     lastTurnReasoning = ""; // fresh turn: capture this turn's thinking from scratch
+    lastTurnArtifacts = [];
     // Incremental session persistence (durability across mid-turn interruption):
     // persistTurnTail() flushes history messages added since the last flush — called
     // right after the user prompt, on every onStep boundary, and once post-turn — so
@@ -906,9 +957,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // this only covers the tail — net content is the full turn either way.
     try {
       await persistTurnTail();
-      const assistantMsg: Message = lastTurnReasoning.trim()
-        ? { role: "assistant", content: reply, reasoning: lastTurnReasoning }
-        : { role: "assistant", content: reply };
+      const assistantMsg: Message = { role: "assistant", content: reply };
+      if (lastTurnReasoning.trim()) assistantMsg.reasoning = lastTurnReasoning;
+      if (lastTurnArtifacts.length) assistantMsg.reasoningArtifacts = lastTurnArtifacts;
       history.push(assistantMsg);
       if (sessionId) await appendMessage(sessionId, assistantMsg, cwd);
       if (tui) tui.finish(reply);
@@ -1593,7 +1644,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     jeoEnv("NO_SLASH_PREVIEW") !== "1";
   // Footer height reserved by the CURRENTLY armed region; disarm/draw must use the
   // same value the arm computed, even if the terminal was resized in between.
+  // `footerRows` is the MAX reservation height (the budget previewLines/historyPreview
+  // may fill). The PHYSICAL reservation (`footerRendered`) is now dynamic: compact at
+  // idle (no dropdown) so a finished/idle prompt leaves NO reserved blank rows, and
+  // grown on demand when a slash/arg preview needs more. `footerWantRows` is the height
+  // the latest previewLines/historyPreview wants; drawFooter re-pins to it in place.
   let footerRows = MAX_PREVIEW_ROWS;
+  // Compact idle reservation: status bar (1) + spacer (1) + input box (3 rows).
+  const COMPACT_FOOTER_ROWS = 5;
+  let footerWantRows = COMPACT_FOOTER_ROWS;
   const out = process.stdout;
   // Arrow-key selection over the slash preview list.
   let navMatches: string[] = []; // command names matching the typed keyword (display order)
@@ -1643,24 +1702,42 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // line painted at an older, wider geometry reflows onto extra rows after a width shrink.
   let lastDrawnLines: string[] = [];
   const padToFooter = (lines: string[]): string[] => {
-    if (lines.length >= footerRows) return lines.slice(0, footerRows);
-    return [...lines, ...new Array(footerRows - lines.length).fill("")];
+    if (lines.length >= footerRendered) return lines.slice(0, footerRendered);
+    return [...lines, ...new Array(footerRendered - lines.length).fill("")];
   };
   const armPreview = () => {
     if (!previewEnabled || previewArmed) return;
     footerRows = previewRowsFor(process.stdout.rows ?? 24);
-    // Reserve `footerRows` bottom rows: write blank newlines (the terminal scrolls
-    // ONCE here, not on every keystroke), then park the cursor at the top of the
-    // reservation. Every subsequent drawFooter call stays inside this region.
-    if (footerRows > 1) {
-      out.write("\n".repeat(footerRows - 1) + cursorUp(footerRows - 1));
+    // Reserve a COMPACT region (idle prompt height) right after the current output —
+    // not the full `footerRows` budget — so a finished/idle prompt leaves no blank rows
+    // below it. drawFooter grows the reservation in place when a dropdown needs more.
+    const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+    if (initial > 1) {
+      out.write("\n".repeat(initial - 1) + cursorUp(initial - 1));
     }
     out.write(toColumn(1));
-    footerRendered = footerRows;
+    footerRendered = initial;
+    footerWantRows = initial;
     footerParkedRow = 0;
     previewArmed = true;
     lastFooterKey = "";
   };
+  // Re-pin the reservation to `n` rows IN PLACE (right after the existing output, never
+  // bottom-pinned): clear the old region from its top, then reserve `n` rows there. Used
+  // by drawFooter to grow for a dropdown and shrink back to the compact idle height, so
+  // the prompt never carries a trailing/floating blank block.
+  const setFooterRows = (n: number) => {
+    n = Math.max(1, Math.min(n, footerRows));
+    if (!previewArmed || n === footerRendered) return;
+    let s = footerParkedRow > 0 ? cursorUp(footerParkedRow) : "";
+    s += toColumn(1) + clearToEnd(); // wipe old region; cursor now at its top (after output)
+    if (n > 1) s += "\n".repeat(n - 1) + cursorUp(n - 1);
+    s += toColumn(1);
+    out.write(s);
+    footerRendered = n;
+    footerParkedRow = 0;
+    lastFooterKey = ""; // force a full repaint into the resized region
+  };
   // Clear the reserved region and park the cursor at its top row so subsequent
   // command output starts where the box was (and inherits the existing scrollback).
   const disarmPreview = () => {
@@ -1777,7 +1854,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const slash = budget > 0 ? formatSlashPreview(line, budget, selected, skillSlashDetails, resolvedSkills) : [];
     const args = !slash.length && budget > 0 ? formatCompletionPreview(line, completionContext(), budget) : [];
     const preview = (slash.length ? slash : args).map(l => chalk.gray(truncateAnsi(l, cols)));
-    return [statusBarLine(cols), "", ...input, ...preview].slice(0, footerRows);
+    const result = [statusBarLine(cols), "", ...input, ...preview].slice(0, footerRows);
+    // Want only the input box + status bar at idle (no dropdown) → compact reservation;
+    // grow to fit the dropdown when a preview is present.
+    footerWantRows = preview.length > 0 ? result.length : Math.min(footerRows, 2 + input.length);
+    return result;
   };
   // Render the reversible Ctrl+O detail panel into the footer reservation: a status
   // bar, a title (with scroll hint when needed), then a windowed slice of the detail
@@ -1815,10 +1896,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       if (below > 0) body.push(chalk.dim(`↓ ${below} more below`));
     }
     footerCursor = { row: Math.min(1, footerRows - 1), col: 1 };
-    return [statusBarLine(cols), title, ...body].slice(0, footerRows);
+    const result = [statusBarLine(cols), title, ...body].slice(0, footerRows);
+    footerWantRows = result.length; // the Ctrl+O panel sizes the reservation to its content
+    return result;
   };
   const drawFooter = (lines: string[]) => {
     if (!previewArmed || footerRendered === 0) return;
+    // Re-pin the reservation to the height the latest preview/panel wants (compact at
+    // idle, grown for a dropdown) BEFORE painting, so no reserved blank trails the prompt.
+    setFooterRows(footerWantRows);
     // ALWAYS paint exactly footerRendered rows so the reservation is fully covered
     // and no row can spill past it — the bug fix that kept `@folder<more text>`
     // typing from scrolling the input box (and prior output) off the top.
@@ -2535,9 +2621,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           out.write(clearScreen());
           out.write(renderWelcome({ ...welcomeData, cols }).join("\n") + "\n");
           footerRows = previewRowsFor(rows);
-          if (footerRows > 1) out.write("\n".repeat(footerRows - 1) + cursorUp(footerRows - 1));
+          const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+          if (initial > 1) out.write("\n".repeat(initial - 1) + cursorUp(initial - 1));
           out.write(toColumn(1));
-          footerRendered = footerRows;
+          footerRendered = initial;
+          footerWantRows = initial;
           drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
           return;
         }
@@ -2568,14 +2656,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const caretSubRow = Math.floor(Math.max(0, footerCursor.col - 1) / c);
         const hopUp = abovePhysical + caretSubRow;
         let s = (hopUp > 0 ? cursorUp(hopUp) : "") + toColumn(1) + clearToEnd();
-        // Re-pin a clean reservation to the screen bottom and repaint. ED already blanked
-        // from the frame top down to the bottom, so just position at the bottom region.
+        // Re-pin a COMPACT reservation right where the frame top was (just below the
+        // static content) — NOT bottom-pinned. ED already blanked from the frame top
+        // down, so reserve the idle height here; drawFooter grows it for a dropdown.
+        // Bottom-pinning left a tall blank gap above the bar when the content was short.
         footerRows = previewRowsFor(rows);
-        s += `\x1b[${Math.max(1, rows)};1H`;
-        if (footerRows > 1) s += cursorUp(footerRows - 1);
+        const initial = Math.max(1, Math.min(footerRows, COMPACT_FOOTER_ROWS));
+        if (initial > 1) s += "\n".repeat(initial - 1) + cursorUp(initial - 1);
         s += toColumn(1);
         out.write(s);
-        footerRendered = footerRows;
+        footerRendered = initial;
+        footerWantRows = initial;
         footerParkedRow = 0;
         lastFooterKey = "";
         drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
@@ -3462,7 +3553,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         if (modelArg?.toLowerCase() === "provider") {
           const want = (tokens[2] ?? "").toLowerCase();
           if (!isProviderName(want)) {
-            console.log(`Usage: /agents ${role.id} provider <anthropic|openai|gemini|antigravity|ollama> [model|#N]`);
+            console.log(`Usage: /agents ${role.id} provider <name> [model|#N] — e.g. anthropic, openai, gemini, groq, deepseek, openrouter (any configured provider)`);
             continue;
           }
           const st = (await describeAllProviders()).find(s => s.name === want);
@@ -3475,7 +3566,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             }
           }
           const live = await getLiveModels();
-          const forProvider = flattenModels(live.filter(r => r.provider === want));
+          const forProvider = providerPickEntries(live, want);
+          const liveForProvider = live.some(r => r.ok && r.provider === want && r.models.length > 0);
           const explicit = tokens[3];
           let chosenModel: string;
           if (explicit && forProvider.length) {
@@ -3494,7 +3586,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           } else if (explicit) {
             chosenModel = qualifyModelId(explicit, want);
           } else if (forProvider.length) {
-            // No model given → the provider's first live model, provider-qualified.
+            // No model given → the provider's first known model, provider-qualified.
             chosenModel = qualifyModelId(forProvider[0]!.model, want);
           } else {
             chosenModel = providerDefaultModel(want);
@@ -3503,7 +3595,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           console.log(`${role.title} pinned to ${want} via model ${chosenModel} — saved to ~/.jeo/config.json`);
           if (forProvider.length) {
             lastPickIndex = forProvider;
-            console.log(`Live ${want} models — refine with /agents ${role.id} #N:`);
+            const sourceNote = liveForProvider ? "Live" : "Catalog";
+            const tail = liveForProvider ? "" : " (log in to list live models)";
+            console.log(`${sourceNote} ${want} models — refine with /agents ${role.id} #N:${tail}`);
             for (const line of formatPickListWithCapabilities(lastPickIndex, { current: chosenModel, cap: 12 })) console.log(line);
           }
           continue;

package/src/tui/app.ts

@@ -68,6 +68,9 @@ export interface AgentEventsLike {
   onUsage?(usage: { inputTokens: number; outputTokens: number }): void;
   onModelStream?(textSoFar: string): void;
   onReasoningStream?(textSoFar: string): void;
+  /** Per-artifact native reasoning replay records (signature / thoughtSignature / reasoning
+   *  item). The TUI ignores these; launch.ts uses them to persist the final reply's artifacts. */
+  onReasoningArtifactStream?(artifact: import("../ai/types").ReasoningArtifact): void;
   onBudget?(limit: number, reason: string): void;
 
 }
@@ -112,6 +115,27 @@ export function tailForWrap(text: string, maxChars = FRAME_WRAP_TAIL_CHARS): str
   return text.length > maxChars ? text.slice(text.length - maxChars) : text;
 }
 
+/** Max lines of a committed reasoning block kept in scrollback (gjc-style collapse): a
+ *  long chain-of-thought is clipped with a "+N more" hint so it never floods the ledger. */
+export const THINKING_COMMIT_MAX_LINES = 12;
+
+/** Collapse a committed reasoning block to a line cap, appending a "… (+N more lines)"
+ *  hint when clipped (gjc collapsed-by-default parity). Returns the input verbatim when
+ *  it already fits. */
+export function clipReasoningLines(text: string, cap = THINKING_COMMIT_MAX_LINES): string {
+  const rows = text.replace(/\r/g, "").split("\n");
+  if (rows.length <= cap) return rows.join("\n");
+  return [...rows.slice(0, cap), `… (+${rows.length - cap} more lines)`].join("\n");
+}
+
+/** gjc-style "thought for Ns" header for a committed/streaming Thinking block. Omits the
+ *  duration when no step start is known (e.g. resumed/exported records). */
+export function thinkingHeader(elapsedMs: number | undefined, unicode: boolean): string {
+  const diamond = unicode ? "◇" : "*";
+  const secs = elapsedMs !== undefined && elapsedMs >= 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : null;
+  return `${diamond} thinking${secs ? ` · ${secs}` : ""}`;
+}
+
 /** Status animation palette while a tool/process runs (background verification): an
  *  amber→yellow gradient, distinct from the cool thinking gradient, so "the agent is
  *  running a process / verifying" reads at a glance (gjc parity: `theme.fg("warning")`
@@ -444,13 +468,17 @@ export class LaunchTui {
             : (s: string) => s;
           const style = (prose: string) => prose.split("\n").map(styleThought).join("\n");
           const parts: string[] = [this.agentLabel()];
+          // gjc "thought for Ns" header: step-start → commit ≈ the model's think+gen time.
+          const elapsedMs = this.currentStepStartedAt ? Date.now() - this.currentStepStartedAt : undefined;
+          const header = thinkingHeader(elapsedMs, this.unicode);
+          parts.push(this.theme.color ? chalk.dim(header) : header);
           if (willFlushThought) {
             this.flushedThought = this.streamingThought;
-            parts.push(style(this.streamingThought));
+            parts.push(style(clipReasoningLines(this.streamingThought)));
           }
           if (willFlushReasoning) {
             this.flushedReasoning = this.streamingReasoning;
-            parts.push(style(this.streamingReasoning));
+            parts.push(style(clipReasoningLines(this.streamingReasoning)));
           }
           this.appendLedger(`${parts.join("\n")}\n`, "reasoning");
         }
@@ -1206,7 +1234,7 @@ export class LaunchTui {
    *  block shows only the most-recent lines, capped at ~30% of the screen height (a
    *  ceiling guards a tall terminal), so it grows with the stream and shrinks with the
    *  viewport. Returns [] when there is nothing to show. */
-  private renderLiveBlock(label: string, text: string, cols: number, rows: number, ceiling: number): string[] {
+  private renderLiveBlock(label: string, text: string, cols: number, rows: number, ceiling: number, cacheKey = label): string[] {
     const dim = this.theme.color ? chalk.dim : (s: string) => s;
     if (!text.trim()) return [];
     const wrapW = Math.max(8, cols - 2);
@@ -1214,8 +1242,8 @@ export class LaunchTui {
     // 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); }
+    let cache = this.liveBlockWrapCaches.get(cacheKey);
+    if (!cache) { cache = lastValueCache<string[]>(); this.liveBlockWrapCaches.set(cacheKey, cache); }
     const wrapped = cache(`${wrapW}\u0000${text}`, () =>
       tailForWrap(text)
         .split("\n")
@@ -1349,7 +1377,11 @@ export class LaunchTui {
     // rectangle, so a short trace leaves no padded "hole" and a short terminal is spared.
     const liveThink = this.streamingThought.trim() || this.streamingReasoning.trim();
     if (isThinking && liveThink) {
-      tail.push(...this.renderLiveBlock("Thinking", liveThink, cols, rows, 6));
+      // gjc-parity: the Thinking block label carries a running timer ("Thinking · Ns").
+      // Cache key stays the constant "Thinking" so the per-frame wrap memo is unaffected.
+      const liveMs = this.currentStepStartedAt ? Date.now() - this.currentStepStartedAt : undefined;
+      const liveLabel = liveMs !== undefined ? `Thinking · ${(liveMs / 1000).toFixed(1)}s` : "Thinking";
+      tail.push(...this.renderLiveBlock(liveLabel, liveThink, cols, rows, 6, "Thinking"));
     }
 
     // Live tool output (gjc-style streaming bash stdout): while a tool runs, its

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

@@ -412,52 +412,46 @@ export async function animateFrames(stage: AsciiStage, opts: AnimateFramesOption
   }
   return total;
 }
-/** The compact jeo forge mark: a clean, wordless pictograph of the mascot — the
- *  neon crayfish (가재) from assets/character.png, read for its signature feature:
- *  the two raised pincer CLAWS (집게). Read top→bottom: the open pincer jaws
- *  (◣◣ / ◢◢) reaching up, the claw arms (◆══╲ ╱══◆) angling into the body where
- *  the blue ◆ knuckles meet, the head with its glowing eye/terminal cluster
- *  (◉◉◉), then the rounded carapace/tail (╲▔▔╱). The mark is purely symbolic —
- *  NO embedded lettering (the brand wordmark lives in the welcome header, not
- *  under the emblem); the JEO identity is carried by the crayfish-claw silhouette
- *  alone. 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 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. */
 export const FORGE_MARK_ART: string[] = [
-  "    ◣◣     ◢◢       ",
-  "   ◆══╲   ╱══◆      ",
-  "      ╲◉◉◉╱         ",
-  "       ╲▔▔╱         "
+  "◤   ╳ ╳ ╳ ╳   ◥",
+  "❮    J E O    ❯",
+  "◣   ╳ ╳ ╳ ╳   ◢"
 ];
 
 export const FORGE_MARK_ART_ASCII: string[] = [
-  "    //     \\\\       ",
-  "   o==\\   /==o      ",
-  "      \\ooo/         ",
-  "       \\__/         "
+  "/   x x x x   \\",
+  "<    J E O    >",
+  "\\   x x x x   /"
 ];
 
-/** Claw-snap blink frames for the compact crayfish forge mark: the arms, head and
- *  carapace stay fixed while the two pincer jaws SNAP shut (◣◣/◢◢ open → ◢◣/◢◣
- *  closed), so the crayfish "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. */
+/** 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
+ *  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,
   [
-    "     ><   ><        ",
-    "   o==\\   /==o      ",
-    "      \\ooo/         ",
-    "       \\__/         "
+    "\\   x x x x   /",
+    "<    J E O    >",
+    "/   x x x x   \\"
   ]
 ];
 
@@ -466,27 +460,26 @@ export function forgeMarkFrameCount(): number {
   return FORGE_MARK_FRAMES.length;
 }
 
-/** Grand hero variant for the welcome forge box (gjc-style spacious banner): the
- *  same mascot crayfish rendered large and wordless — the two raised pincer claws
- *  (◣◣ / ◢◢, the 집게 feature) on wide arms (◆══╲ ╱══◆), the head with its glowing
- *  eye/terminal cluster (◉ ◉ ◉), and the broad rounded carapace/tail (╲▔▔▔▔▔╱).
- *  Purely symbolic — NO embedded lettering or caption. Width-1 glyphs only so
+/** 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. */
 export const FORGE_MARK_ART_GRAND: string[] = [
-  "      ◣◣            ◢◢        ",
-  "    ◆══╲            ╱══◆      ",
-  "        ╲  ◉ ◉ ◉  ╱           ",
-  "         ╲▔▔▔▔▔▔▔▔▔╱          "
+  "◤        ╳ ╳ ╳ ╳ ╳ ╳        ◥",
+  "❮         J   E   O         ❯",
+  "◣        ╳ ╳ ╳ ╳ ╳ ╳        ◢"
 ];
 
 export const FORGE_MARK_ART_GRAND_ASCII: string[] = [
-  "      //            \\\\        ",
-  "    o==\\            /==o      ",
-  "        \\  o o o  /           ",
-  "         \\_________/          "
+  "/        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
 // output (grand/unicode/cols/color/colorLevel/phase/frame). The live HUD cycles a
 // FIXED frame set (blink × gradient phases) at ~120ms; without this each recurrence