jeo-code 0.6.2 → 0.6.4

package/src/tui/app.ts

@@ -119,6 +119,9 @@ export function tailForWrap(text: string, maxChars = FRAME_WRAP_TAIL_CHARS): str
  *  on the in-flight tool line). */
 export const STATUS_VERIFY_PALETTE = ["#ffd24a", "#ffb300"] as const;
 const DEFAULT_MAX_STEPS = 100;
+// Resize repaint cap (~30fps): the leading edge fires instantly, follow-ups during a
+// drag-resize are throttled to this interval, and a trailing repaint paints the final size.
+const RESIZE_THROTTLE_MS = 33;
 // Tools light enough that they never get a forge card (gjc parity): completion is a
 // single ✓/✗ ledger line; only failures surface a result card with the error body.
 const LIGHT_TOOLS = new Set(["read", "find", "search", "ls", "todo"]);
@@ -167,6 +170,15 @@ export class LaunchTui {
   private mutationGuarded = false;
   private finished = false;
   private timer: ReturnType<typeof setInterval> | undefined;
+  // Resize handling (gjc-style responsiveness): repaint IMMEDIATELY on the first event
+  // so a deliberate resize never lags, then cap follow-ups to ~30fps so a drag-resize
+  // tracks the cursor live (instead of staying stale until the drag pauses — the lag a
+  // pure trailing debounce caused). A trailing timer always fires once more so the FINAL
+  // geometry paints exactly. lastCols/lastRows drop spurious same-size resize events.
+  private resizeTimer: ReturnType<typeof setTimeout> | undefined;
+  private lastResizeAt = 0;
+  private lastCols = -1;
+  private lastRows = -1;
   private pendingIndex: number | null = null;
   private pendingTitle: string | null = null;
   private pendingForge: ForgeSummary | null = null;
@@ -209,14 +221,17 @@ export class LaunchTui {
   // the model responds, then flushed once into scrollback as a `jeo · …` ledger line.
   private streamingReasoning = "";
   /** Native model thinking text (separate reasoning channel), shown DIMMED while it
-   *  streams and cleared on commit — ephemeral, never flushed (the durable record is the
-   *  action/reply the thinking produced). */
+   *  streams, then persisted once into scrollback as a "Thinking" block on commit so the
+   *  model's reasoning stays visible above the answer (gjc "think → answer" parity). */
   private streamingThought = "";
   /** Uniform live-activity text for the live status field (reasoning OR derived fallback). */
   private streamingActivity = "";
   /** Last stream-driven draw (ms epoch) — throttles per-delta repaints to ≤10/s. */
   private lastStreamDraw = 0;
   private flushedReasoning = "";
+  // Native thinking text already persisted into scrollback this step (gjc parity: the
+  // model's reasoning stays VISIBLE above the answer instead of vanishing on commit).
+  private flushedThought = "";
   // Live streaming output of the currently-running tool (bash stdout via onToolProgress).
   // Shown as a DIMMED bounded block while the tool runs; cleared when the formatted
   // result card lands (onToolResult) — the gjc-style "shaded until complete" effect.
@@ -366,6 +381,7 @@ export class LaunchTui {
         this.streamingThought = "";
         this.streamingActivity = "";
         this.flushedReasoning = "";
+        this.flushedThought = "";
         this.liveToolOutput = ""; // fresh step: no tool output yet
         this.currentStepStartedAt = Date.now();
         this.spinner.updateStep(step, this.footer.maxSteps);
@@ -400,9 +416,9 @@ export class LaunchTui {
       },
       onReasoningStream: textSoFar => {
         if (this.finished) return;
-        // Native thinking deltas → the SAME transient dimmed block as the JSON-reasoning
-        // path (reuses the screen-safe tail renderer; no new frame structure). Ephemeral:
-        // cleared on commit, never flushed into scrollback.
+        // Native thinking deltas → the SAME live dimmed block as the JSON-reasoning path
+        // (reuses the screen-safe tail renderer; no new frame structure). On commit it is
+        // persisted into scrollback as a "Thinking" block (see onAssistant).
         if (textSoFar === this.streamingThought) return;
         this.streamingThought = textSoFar;
         if (Date.now() - this.lastStreamDraw >= 100) {
@@ -413,22 +429,28 @@ export class LaunchTui {
       onAssistant: (_raw, invocation) => {
         this.thinking = false; // model replied; now dispatching the tool
         this.retryNotice = null; // the call got through — clear any backoff notice
-        // Flush the streamed reasoning once into scrollback as a jeo-ref reasoning
-        // block — a muted "Reasoning" divider header, the prose below it (the durable
-        // record) — then stop showing the transient live reasoning row.
-        if (this.streamingReasoning && this.streamingReasoning !== this.flushedReasoning) {
-          this.flushedReasoning = this.streamingReasoning;
-          // A muted "Reasoning" card-header divider announces the reasoning block
-          // boundary (consistent with the section design tokens — Thinking/Reasoning/
-          // Output share one visual language); the prose below it is the durable record.
-          // A full-width divider ROW respects appendLedger's 1-line=1-row pre-wrap
-          // invariant (no per-line prefix), unlike a left-border enclosure which would
-          // push wrapped lines past `cols` and tear the frame.
-          const header = sectionLabel("Reasoning", Math.max(20, size().cols), {
-            color: this.theme.color,
-            unicode: this.unicode,
-          });
-          this.appendLedger(`${header}\n${this.streamingReasoning}\n`, "reasoning");
+        // Persist the model's pre-answer thought into scrollback (gjc parity: "think →
+        // answer" reads visibly instead of vanishing on commit). gjc layout: a single
+        // `jeo` agent-name label leads the segment, then the thought as ITALIC + dimmed
+        // prose (subordinate to the reply) — native reasoning first, then the JSON-protocol
+        // plan, both grouped under the one label (no per-block divider header).
+        const willFlushThought = !!this.streamingThought && this.streamingThought !== this.flushedThought;
+        const willFlushReasoning = !!this.streamingReasoning && this.streamingReasoning !== this.flushedReasoning;
+        if (willFlushThought || willFlushReasoning) {
+          const styleThought = this.theme.color
+            ? (s: string) => chalk.italic(mutedPaint(this.theme)(s))
+            : (s: string) => s;
+          const style = (prose: string) => prose.split("\n").map(styleThought).join("\n");
+          const parts: string[] = [this.agentLabel()];
+          if (willFlushThought) {
+            this.flushedThought = this.streamingThought;
+            parts.push(style(this.streamingThought));
+          }
+          if (willFlushReasoning) {
+            this.flushedReasoning = this.streamingReasoning;
+            parts.push(style(this.streamingReasoning));
+          }
+          this.appendLedger(`${parts.join("\n")}\n`, "reasoning");
         }
         this.streamingReasoning = "";
         this.streamingThought = "";
@@ -926,10 +948,41 @@ export class LaunchTui {
   }
 
   private readonly onResize = (): void => {
+    if (this.finished) return;
+    const now = Date.now();
+    // Leading edge: a deliberate resize reflows instantly (no perceived lag).
+    if (now - this.lastResizeAt >= RESIZE_THROTTLE_MS) {
+      this.lastResizeAt = now;
+      this.resizeRepaint();
+      return;
+    }
+    // Mid-throttle (continuous drag): coalesce, but ALWAYS schedule a trailing repaint
+    // so the final geometry paints exactly — never leave the frame stale at the old size.
+    if (this.resizeTimer) clearTimeout(this.resizeTimer);
+    this.resizeTimer = setTimeout(() => {
+      this.resizeTimer = undefined;
+      this.lastResizeAt = Date.now();
+      this.resizeRepaint();
+    }, RESIZE_THROTTLE_MS);
+  };
+
+  /** Repaint for a resize: re-measure, skip spurious same-geometry events, full repaint. */
+  private resizeRepaint(): void {
+    if (this.finished) return;
     try {
+      const { cols, rows } = size();
+      if (cols === this.lastCols && rows === this.lastRows) return;
+      this.lastCols = cols;
+      this.lastRows = rows;
       this.repaint();
     } catch { /* resize race — next tick repaints */ }
-  };
+  }
+
+  /** gjc-style agent identity: a bold accent `jeo` name label on its own line that leads
+   *  every assistant segment — thought blocks (onAssistant) and the final reply (finish). */
+  private agentLabel(): string {
+    return this.theme.color ? chalk.bold(accentPaint(this.theme)("jeo")) : "jeo";
+  }
 
   /** Collapse the live region to static final output. */
   finish(reply: string): void {
@@ -939,6 +992,10 @@ export class LaunchTui {
       clearInterval(this.timer);
       this.timer = undefined;
     }
+    if (this.resizeTimer) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = undefined;
+    }
     if (this.tty) {
       process.stdout.removeListener("resize", this.onResize);
     }
@@ -998,8 +1055,11 @@ export class LaunchTui {
     // color:false keeps the plain stripMarkdown text for pipes/tests.
     const tabled = renderMarkdownTables(reply, { unicode: this.unicode });
     const renderedReply = this.theme.color
-      ? renderMarkdownAnsi(tabled, { accent: s => chalk.bold(accentPaint(this.theme)(s)) })
+      ? renderMarkdownAnsi(tabled, { accent: s => chalk.bold(accentPaint(this.theme)(s)), muted: mutedPaint(this.theme) })
       : stripMarkdown(tabled);
+    // gjc-style agent identity: a bold accent `jeo` label on its OWN line leads the reply
+    // (mirrors gjc's `gajae` header), instead of an inline `jeo>` prompt prefix.
+    const nameLabel = this.agentLabel();
     const steps = this.footer.step || 0;
     const peak = this.progress.current();
     const usageSuffix = this.turnUsage ? ` · ${formatUsage(this.turnUsage)}` : "";
@@ -1009,7 +1069,8 @@ export class LaunchTui {
       // track). The live ledger above already recorded every step. A blank spacer
       // row separates the ledger from the answer (jeo-ref vertical rhythm).
       finalLines.push("");
-      finalLines.push(`jeo> ${renderedReply}`);
+      finalLines.push(nameLabel);
+      finalLines.push(renderedReply);
       if (planLines.length) {
         finalLines.push("");
         finalLines.push(...planLines);
@@ -1018,7 +1079,8 @@ export class LaunchTui {
       finalLines.push(this.theme.color ? chalk.dim(statusLine) : statusLine);
     } else {
       finalLines.push(`Evolved to: ${evolutionTrack(peak, { unicode: this.unicode, color: this.theme.color })} (took ${steps} steps in ${formatDuration(Date.now() - this.startedAt)}${usageSuffix})`);
-      finalLines.push(`jeo> ${renderedReply}`);
+      finalLines.push(nameLabel);
+      finalLines.push(renderedReply);
       if (planLines.length) {
         finalLines.push(...planLines);
       }

package/src/tui/components/autocomplete.ts

@@ -162,11 +162,13 @@ export function complete(line: string, ctx: CompletionContext): CompletionResult
     case "/fast":
       return argIndex === 0 ? finish(["on", "off", "status"], "subcommand") : { completions: [], token, kind: "none" };
     case "/provider": {
+      // /provider is onboarding-only (gjc parity): login + add. Model/provider
+      // switching completes under /model, not here.
       const cloud = ["anthropic", "openai", "gemini", "antigravity"];
-      if (argIndex === 0) return finish(["login", "auth", ...ctx.providers], "provider");
-      // `/provider login|auth <name>` → cloud provider names (OAuth-capable).
-      if (argIndex === 1 && (tokens[1]?.toLowerCase() === "login" || tokens[1]?.toLowerCase() === "auth")) return finish(cloud, "provider");
-      if (argIndex === 1) return finish(ctx.modelsForProvider(tokens[1] ?? ""), "model");
+      if (argIndex === 0) return finish(["login", "add", "help"], "subcommand");
+      const sub = tokens[1]?.toLowerCase();
+      if (sub === "login" || sub === "auth") return argIndex === 1 ? finish(cloud, "provider") : { completions: [], token, kind: "none" };
+      if (sub === "add") return finish(["--base-url", "--model", "--compat", "clear"], "subcommand");
       return { completions: [], token, kind: "none" };
     }
     case "/logout":

package/src/tui/components/config-panel.ts

@@ -173,7 +173,7 @@ export function formatPickList(entries: PickEntry[], opts: { current?: string; c
     const mark = opts.current && e.model === opts.current ? chalk.green(" ◀ current") : "";
     return `  ${chalk.yellow(tag)}  ${e.model} ${chalk.gray(`(${e.provider})`)}${mark}`;
   });
-  if (entries.length > cap) lines.push(chalk.gray(`  …(+${entries.length - cap} more — narrow with /provider <name> or /search)`));
+  if (entries.length > cap) lines.push(chalk.gray(`  …(+${entries.length - cap} more — narrow with /model or /search)`));
   return lines;
 }
 
@@ -202,7 +202,7 @@ export function formatPickListWithCapabilities(entries: PickEntry[], opts: { cur
       `  ${chalk.yellow(`#${e.index}`.padStart(iw))}  ${chalk.gray(e.provider.padEnd(pw))}  ${id}  ${ctx.padStart(5)}  ${out.padStart(5)}  ${chalk.cyan(think)}  ${img}${mark}`,
     );
   }
-  if (entries.length > cap) lines.push(chalk.gray(`  …(+${entries.length - cap} more — narrow with /provider <name>)`));
+  if (entries.length > cap) lines.push(chalk.gray(`  …(+${entries.length - cap} more — narrow with /model)`));
   return lines;
 }
 

package/src/tui/components/markdown-text.ts

@@ -23,6 +23,7 @@ export function stripMarkdown(text: string): string {
   out = out.replace(/___([^\_]+)___/g, "$1");
   out = out.replace(/__([^\_]+)__/g, "$1");
   out = out.replace(/_([^\_]+)_/g, "$1");
+  out = out.replace(/~~([^~\n]+)~~/g, "$1");
 
   // 5. Convert links [text](url) -> text (url)
   out = out.replace(/\[([^\]]+)\]\(([^\)]+)\)/g, "$1 ($2)");
@@ -42,6 +43,13 @@ export function stripMarkdown(text: string): string {
 export interface MarkdownAnsiOptions {
   /** Heading painter (theme accent + bold); default chalk.bold. */
   accent?: (s: string) => string;
+  /** Secondary-text painter for link URLs, the blockquote gutter, horizontal rules,
+   *  and ~~struck~~ text. jeo tone uses a REAL theme mid-tone hue here instead of ANSI
+   *  `dim`, which collapses to near-invisible on dark terminals (parity with the
+   *  todo/forge cards). Default chalk.dim when no theme painter is threaded. */
+  muted?: (s: string) => string;
+  /** Inline `code` painter; default chalk.cyan so code stays distinct from accent headings. */
+  code?: (s: string) => string;
 }
 
 /**
@@ -54,14 +62,16 @@ export interface MarkdownAnsiOptions {
 export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {}): string {
   if (!text) return "";
   const accent = opts.accent ?? ((s: string) => chalk.bold(s));
+  const muted = opts.muted ?? ((s: string) => chalk.dim(s));
+  const code = opts.code ?? ((s: string) => chalk.cyan(s));
 
   // Links/images FIRST: bold/code styling injects ANSI escapes whose `[` would
   // otherwise be swallowed by the `[label](url)` matcher (corrupting both).
   const styleInline = (line: string): string =>
     line
       .replace(/!\[([^\]]*)\]\(([^\)]+)\)/g, "$1")
-      .replace(/\[([^\]]+)\]\(([^\)]+)\)/g, (_m, label: string, url: string) => `${label} ${chalk.dim(`(${url})`)}`)
-      .replace(/`([^`]+)`/g, (_m, code: string) => chalk.cyan(code))
+      .replace(/\[([^\]]+)\]\(([^\)]+)\)/g, (_m, label: string, url: string) => `${label} ${muted(`(${url})`)}`)
+      .replace(/`([^`]+)`/g, (_m, c: string) => code(c))
       .replace(/\*\*\*([^\*]+)\*\*\*/g, (_m, t: string) => chalk.bold.italic(t))
       .replace(/\*\*([^\*]+)\*\*/g, (_m, t: string) => chalk.bold(t))
       .replace(/__([^\_]+)__/g, (_m, t: string) => chalk.bold(t))
@@ -70,7 +80,11 @@ export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {})
       // closing `*`); the `_` form is word-boundary guarded so snake_case
       // identifiers (foo_bar_baz) are never mistaken for emphasis.
       .replace(/\*([^\s*][^*\n]*?[^\s*]|[^\s*])\*/g, (_m, t: string) => chalk.italic(t))
-      .replace(/(?<![\p{L}\p{N}_])_(?=\S)([^_\n]*?)(?<=\S)_(?![\p{L}\p{N}_])/gu, (_m, t: string) => chalk.italic(t));
+      .replace(/(?<![\p{L}\p{N}_])_(?=\S)([^_\n]*?)(?<=\S)_(?![\p{L}\p{N}_])/gu, (_m, t: string) => chalk.italic(t))
+      // ~~strikethrough~~ → struck + muted: retracted/superseded text reads as
+      // de-emphasized (jeo tone parity with done-todo rows). Runs last so it never
+      // eats an earlier emphasis marker.
+      .replace(/~~([^~\n]+)~~/g, (_m, t: string) => chalk.strikethrough(muted(t)));
 
   const out: string[] = [];
   let inFence = false;
@@ -121,14 +135,14 @@ export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {})
       if (lastType !== "blockquote" && lastType !== "empty") {
         ensureBlankLine();
       }
-      out.push(chalk.dim(`▎ ${styleInline(quote[1]!)}`));
+      out.push(muted(`▎ ${styleInline(quote[1]!)}`));
       lastType = "blockquote";
       continue;
     }
 
     if (/^[-\*_]{3,}\s*$/.test(line)) {
       ensureBlankLine();
-      out.push(chalk.dim("─".repeat(24)));
+      out.push(muted("─".repeat(24)));
       ensureBlankLine();
       lastType = "empty";
       continue;

package/src/tui/components/slash.ts

@@ -1,5 +1,6 @@
 /** Slash-command palette/autocomplete for the interactive REPL (TUI M3). */
 import chalk from "chalk";
+import { editDistance } from "../../ai/model-catalog-compat";
 
 /** Order-preserving subsequence test: every char of `needle` appears in `hay`
  *  left-to-right (gjc-style fuzzy match, e.g. "expt" ⊑ "export"). */
@@ -33,9 +34,10 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/dump", usage: "/dump", description: "Copy the session transcript to the clipboard", group: "session" },
   { command: "/btw", usage: "/btw <question>", description: "Ask an ephemeral side question (history untouched)", group: "session" },
   { command: "/compact", usage: "/compact", description: "Summarize older turns to free context", group: "session" },
+  { command: "/goal", usage: "/goal <condition>", description: "Set a natural language stop condition for the session", group: "session" },
   { command: "/model", usage: "/model [id|#N|save|thinking <level>|subagent <role> <model|#N|thinking L>]", description: "Show/switch model; picker can apply to default or any subagent role and set thinking", group: "models" },
   { command: "/fast", usage: "/fast [on|off|status]", description: "Toggle fast thinking mode when the active model supports it", group: "models" },
-  { command: "/provider", usage: "/provider [name] [model|#N]", description: "Credentials, switch provider, set model; `login <name>` starts OAuth", group: "models" },
+  { command: "/provider", usage: "/provider [login [name] | add --base-url <url> [--model <m>]]", description: "Provider onboarding: `login [name]` starts OAuth; `add --base-url <url>` registers an OpenAI-compatible endpoint. Switch the active model/provider with /model", group: "models" },
   { command: "/login", usage: "/login [provider]", description: "OAuth login (alias of /provider login)", group: "models" },
   { command: "/logout", usage: "/logout <anthropic|openai|gemini|antigravity>", description: "Remove the stored OAuth token for a provider", group: "models" },
   { command: "/roles", usage: "/roles [tier model]", description: "Show or set model role tiers (smol/slow/plan)", group: "models" },
@@ -87,6 +89,23 @@ export function isSlashAttempt(input: string): boolean {
   return input.startsWith("/") && !input.slice(1).includes(" ");
 }
 
+/** Near-miss slash commands for a true typo — edit distance ≤ 2 on the command body,
+ *  excluding the prefix/fuzzy hits `matchSlash` already surfaces. gjc parity for the
+ *  `/provicer` → `/provider` correction. Ranked closest-first and capped. */
+export function suggestSlashCommands(input: string, commands: string[] = SLASH_COMMANDS, limit = 3): string[] {
+  if (!input.startsWith("/")) return [];
+  const body = input.slice(1).toLowerCase();
+  if (body === "") return [];
+  const already = new Set(matchSlash(input, commands));
+  return commands
+    .filter(c => !already.has(c))
+    .map(c => ({ c, d: editDistance(body, c.slice(1).toLowerCase()) }))
+    .filter(s => s.d <= 2)
+    .sort((a, b) => a.d - b.d || a.c.localeCompare(b.c))
+    .slice(0, limit)
+    .map(s => s.c);
+}
+
 const GROUP_LABELS: Record<SlashCommandInfo["group"], string> = {
   session: "Session",
   models: "Models / Providers",
@@ -103,7 +122,11 @@ export function formatSlashCommandList(input = "/", extra: readonly SlashCommand
   const commands = details.map(c => c.command);
   const query = input === "/?" ? "/" : input;
   const matches = matchSlash(query, commands);
-  if (matches.length === 0) return [`Unknown command '${input}'. Try /help.`];
+  if (matches.length === 0) {
+    const near = suggestSlashCommands(query, commands);
+    const tail = near.length ? `Did you mean ${near.join(", ")}?` : "Try /help.";
+    return [`Unknown command '${input}'. ${tail}`];
+  }
   const wanted = new Set(matches);
   const rows = details.filter(c => wanted.has(c.command));
   const usageWidth = Math.max(...rows.map(c => c.usage.length), 6);