jeo-code 0.1.0 → 0.4.4

package/src/tui/components/hud.ts

@@ -0,0 +1,73 @@
+import chalk from "chalk";
+
+export type JeoPhase = "thinking" | "planning" | "executing" | "reporting" | "done";
+
+export interface HudOptions {
+  unicode?: boolean;
+  color?: boolean;
+}
+
+export function renderHud(phase: JeoPhase, opts: HudOptions = {}): string {
+  const unicode = opts.unicode !== false;
+  const color = opts.color !== false;
+
+  const phases: JeoPhase[] = ["thinking", "planning", "executing", "reporting", "done"];
+  const activeIndex = phases.indexOf(phase);
+
+  const arrow = unicode ? " → " : " -> ";
+  const renderedArrow = color ? chalk.dim(arrow) : arrow;
+
+  const parts = phases.map((p, i) => {
+    let glyph = "";
+    let formatted = "";
+
+    if (i < activeIndex) {
+      // Completed
+      glyph = unicode ? "✔" : "v";
+      formatted = `${glyph} ${p}`;
+      if (color) {
+        formatted = chalk.green(formatted);
+      }
+    } else if (i === activeIndex) {
+      // Active
+      glyph = unicode ? "●" : "*";
+      formatted = `${glyph} ${p}`;
+      if (color) {
+        formatted = chalk.cyan.bold(formatted);
+      }
+    } else {
+      // Future
+      glyph = unicode ? "○" : "o";
+      formatted = `${glyph} ${p}`;
+      if (color) {
+        formatted = chalk.dim(formatted);
+      }
+    }
+    return formatted;
+  });
+
+  return parts.join(renderedArrow);
+}
+
+export interface DerivePhaseInput {
+  thinking: boolean;
+  runningTool: boolean;
+  todosActive: boolean;
+  finished: boolean;
+}
+
+export function derivePhase(input: DerivePhaseInput): JeoPhase {
+  if (input.finished) {
+    return "done";
+  }
+  if (input.runningTool) {
+    return "executing";
+  }
+  if (input.thinking) {
+    return "thinking";
+  }
+  if (input.todosActive) {
+    return "planning";
+  }
+  return "reporting";
+}

package/src/tui/components/index.ts

@@ -5,3 +5,7 @@ export * from "./footer";
 export * from "./ascii-art";
 export * from "./forge";
 export * from "./status";
+export * from "./category-index";
+export * from "./input-box";
+export * from "./hud";
+export * from "./autopilot-status";

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

@@ -0,0 +1,150 @@
+import chalk from "chalk";
+import { BOX_ASCII, BOX_UNICODE, boxBlock } from "./layout";
+import { visibleWidth } from "./width";
+
+export interface InputBoxOptions {
+  cols?: number;
+  color?: boolean;
+  unicode?: boolean;
+  cwdLabel?: string;
+  /** Pending clipboard-image attachments hint (e.g. "⧉ 1 image attached — ctrl+v"). */
+  attachmentLabel?: string;
+  placeholder?: string;
+  maxBodyRows?: number;
+  /** Caret offset in CHARACTERS into `line` (readline's rl.cursor). Defaults to end. */
+  cursor?: number;
+  /** Accent painter for the border + `>` prompt mark (theme accent); default red/blue. */
+  accent?: (s: string) => string;
+  /** 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;
+}
+
+export interface InputFrame {
+  lines: string[];
+  /** Caret row relative to the box's FIRST line (0 = top border, 1 = first body row). */
+  cursorRow: number;
+  /** 1-based terminal column of the caret cell. */
+  cursorCol: number;
+}
+
+/**
+ * Wrap plain input text (readline lines carry no ANSI) by DISPLAY width and map the
+ * caret's character offset to its (row, columnWidth) cell in the same pass — so the
+ * box prompt can place the real terminal cursor exactly where the next glyph lands,
+ * and arrow-key movement (readline updates rl.cursor) repositions it visibly.
+ */
+function wrapWithCursor(
+  text: string,
+  cursor: number,
+  width: number,
+): { rows: string[]; row: number; col: number } {
+  const rows: string[] = [];
+  let cur = "";
+  let curW = 0;
+  let row = 0;
+  let col = 0;
+  const chars = Array.from(text.replace(/\r/g, ""));
+  const pos = Math.max(0, Math.min(cursor, chars.length));
+  for (let i = 0; i <= chars.length; i++) {
+    const ch = i < chars.length ? chars[i]! : "";
+    const rendered = ch === "\t" ? "  " : ch;
+    const w = ch === "" || ch === "\n" ? 0 : ch === "\t" ? 2 : visibleWidth(ch);
+    // Wrap BEFORE recording the caret so a caret on a wrapping char follows it down.
+    if (w > 0 && curW + w > width && curW > 0) {
+      rows.push(cur);
+      cur = "";
+      curW = 0;
+    }
+    if (i === pos) {
+      row = rows.length;
+      col = curW;
+    }
+    if (ch === "\n") {
+      rows.push(cur);
+      cur = "";
+      curW = 0;
+      continue;
+    }
+    if (ch !== "") {
+      cur += rendered;
+      curW += w;
+    }
+  }
+  rows.push(cur);
+  return { rows, row, col };
+}
+
+/**
+ * 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
+ * can park the REAL terminal cursor right after `>` — moving with the arrow keys.
+ */
+export function renderInputFrame(line: string, opts: InputBoxOptions = {}): InputFrame {
+  const cols = Math.max(24, Math.trunc(opts.cols ?? 80));
+  const useColor = opts.color !== false;
+  const placeholder = opts.placeholder ?? "Type your message...";
+  const bodyWidth = Math.max(1, cols - 4);
+  const textWidth = Math.max(1, bodyWidth - 2); // "> " / "  " prefix columns
+
+  let rows: string[];
+  let crow = 0;
+  let ccol = 0;
+  let placeholderRow = false;
+  if (line.length === 0) {
+    rows = [placeholder];
+    placeholderRow = true;
+  } else {
+    const wrapped = wrapWithCursor(line, opts.cursor ?? line.length, textWidth);
+    rows = wrapped.rows;
+    crow = wrapped.row;
+    ccol = wrapped.col;
+  }
+
+  // Tail-truncate to maxBodyRows (caret usually edits near the end); the first
+  // visible row carries an `…` marker when earlier rows are hidden.
+  const maxBodyRows = Math.max(1, Math.trunc(opts.maxBodyRows ?? rows.length));
+  let hidden = 0;
+  if (rows.length > maxBodyRows) {
+    hidden = rows.length - maxBodyRows;
+    rows = rows.slice(hidden);
+    rows[0] = `…${rows[0] ?? ""}`.slice(0, textWidth);
+  }
+  let visRow = Math.max(0, Math.min(crow - hidden, rows.length - 1));
+  if (hidden > 0 && crow - hidden === 0) ccol += 1; // shifted by the `…` marker
+  if (crow - hidden < 0) { visRow = 0; ccol = 0; }
+
+  const promptMark = "> ";
+  const paintPrompt = useColor ? (opts.accent ?? chalk.red) : (s: string) => s;
+  const paintGhost = useColor ? chalk.dim : (s: string) => s;
+  const body = rows.map((r, i) => {
+    const content = placeholderRow ? paintGhost(r) : r;
+    return i === 0 ? paintPrompt(promptMark) + content : "  " + r;
+  });
+
+  const content = [...body];
+  if (opts.attachmentLabel) {
+    content.push(useColor ? chalk.cyan(opts.attachmentLabel) : opts.attachmentLabel);
+  }
+  if (opts.cwdLabel) {
+    content.push(useColor ? chalk.gray(opts.cwdLabel) : opts.cwdLabel);
+  }
+  const glyphs = opts.unicode === false ? BOX_ASCII : BOX_UNICODE;
+  // Depth cue: lit top/left edge (bright accent) vs shaded bottom/right edge (dim).
+  const paint = useColor ? (opts.accent ?? chalk.blueBright) : (s: string) => s;
+  const paintShadow = useColor ? (opts.accentShadow ?? ((s: string) => chalk.blue.dim(s))) : (s: string) => s;
+  const lines = boxBlock(content, cols, { glyphs, paint, paintShadow, align: "left" });
+
+  // Terminal columns: border at col 1, content starts col 2, text after "> " at col 4.
+  const cursorRow = 1 + visRow;
+  const cursorCol = 4 + (placeholderRow ? 0 : ccol);
+  return { lines, cursorRow, cursorCol };
+}
+
+/**
+ * Renders a boxed input box enclosing either the current typed text or a placeholder.
+ * If opts.cwdLabel is provided, a dim gray label line is appended after the text inside the box.
+ */
+export function renderInputBox(line: string, opts: InputBoxOptions = {}): string[] {
+  return renderInputFrame(line, opts).lines;
+}

package/src/tui/components/layout.ts

@@ -6,6 +6,7 @@
  * pure functions over `string[]` blocks, injectable `cols`/`rows` for tests.
  */
 import { visibleWidth } from "./color";
+import { truncate } from "../terminal";
 
 export type HAlign = "left" | "center" | "right";
 export type VAlign = "top" | "center" | "bottom";
@@ -82,24 +83,31 @@ export interface BoxGlyphs {
 export const BOX_UNICODE: BoxGlyphs = { tl: "\u256d", tr: "\u256e", bl: "\u2570", br: "\u256f", h: "\u2500", v: "\u2502" };
 export const BOX_ASCII: BoxGlyphs = { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
 
+/**
+ * `paintShadow` (optional) paints the bottom border and right vertical edge —
+ * the "shaded" edges — while `paint` keeps the top border and left vertical
+ * "lit". The two-tone contrast gives flat boxes a pseudo-3D depth cue.
+ */
 export function boxBlock(
   lines: string[],
   width: number,
-  opts: { glyphs?: BoxGlyphs; paint?: (s: string) => string; align?: HAlign } = {},
+  opts: { glyphs?: BoxGlyphs; paint?: (s: string) => string; paintShadow?: (s: string) => string; align?: HAlign } = {},
 ): string[] {
   const g = opts.glyphs ?? BOX_UNICODE;
   const paint = opts.paint ?? ((s: string) => s);
+  const shadow = opts.paintShadow ?? paint;
   const inner = Math.max(0, width - 2);
   const top = paint(g.tl + g.h.repeat(inner) + g.tr);
-  const bottom = paint(g.bl + g.h.repeat(inner) + g.br);
+  const bottom = shadow(g.bl + g.h.repeat(inner) + g.br);
   const mid = lines.map(l => {
     if (l === "DIVIDER") {
       const leftChar = g.tl === "+" ? "+" : "├";
       const rightChar = g.tr === "+" ? "+" : "┤";
       return paint(leftChar + g.h.repeat(inner) + rightChar);
     }
+    const truncated = truncate(l, inner);
     const align = opts.align ?? "left";
-    return paint(g.v) + padLineTo(l, inner, align) + paint(g.v);
+    return paint(g.v) + padLineTo(truncated, inner, align) + shadow(g.v);
   });
   return [top, ...mid, bottom];
 }

package/src/tui/components/live-model-picker.ts

@@ -0,0 +1,108 @@
+import chalk from "chalk";
+import type { PickEntry } from "../../ai/model-picker";
+import type { ProviderName } from "../../ai/types";
+import { catalogMetadata, formatTokens } from "../../ai/model-catalog";
+import { SelectList, renderSelectList, type RenderSelectOptions, type SelectItem } from "./select-list";
+
+function liveModelHint(model: string, current?: string): string {
+  const meta = catalogMetadata(model);
+  const parts: string[] = [];
+  if (meta) {
+    parts.push(`${formatTokens(meta.contextTokens)} ctx`);
+    parts.push(`${formatTokens(meta.maxOutputTokens)} out`);
+    parts.push(meta.thinking.length ? meta.thinking.join(",") : "-");
+    parts.push(meta.images ? "img" : "text");
+  } else {
+    parts.push("unknown caps");
+  }
+  if (current === model) parts.push("current");
+  return parts.join(" · ");
+}
+
+export interface ModelAssignmentBadge {
+  /** Stable target id: "default" or a subagent role id. */
+  role: string;
+  /** Short badge text shown beside a matching model (DEFAULT, EXECUTOR, ...). */
+  label: string;
+  /** Configured model id for this target, qualified (`provider/model`) when possible. */
+  model: string;
+  /** Reasoning budget shown after the badge. Omit for no suffix; use "inherit" for inherited role thinking. */
+  thinking?: string;
+  /** Visual role color. Unknown values fall back to a neutral badge. */
+  color?: "default" | "executor" | "architect" | "planner" | "critic" | string;
+}
+
+export interface LiveModelPickerOptions {
+  current?: string;
+  /** Role/default assignments to render as badges on matching models. */
+  assignments?: readonly ModelAssignmentBadge[];
+  /** Disable ANSI badge styling for deterministic tests or plain terminals. */
+  color?: boolean;
+  /** Providers visible for context but not selectable because they cannot serve a turn. */
+  disabledProviders?: readonly ProviderName[];
+  disabledHint?: string;
+}
+function qualifiedModelId(entry: PickEntry): string {
+  return entry.model.includes("/") ? entry.model : `${entry.provider}/${entry.model}`;
+}
+
+function modelMatchesAssignment(entry: PickEntry, model: string): boolean {
+  const assigned = model.trim().toLowerCase();
+  if (!assigned) return false;
+  const bare = entry.model.toLowerCase();
+  const qualified = qualifiedModelId(entry).toLowerCase();
+  return assigned === bare || assigned === qualified;
+}
+
+function roleBadgeColor(label: string, color: ModelAssignmentBadge["color"]): string {
+  switch (color) {
+    case "default":
+      return chalk.bgGreen.black(` ${label} `);
+    case "executor":
+      return chalk.bgRedBright.black(` ${label} `);
+    case "architect":
+      return chalk.bgHex("#e7c7bd").black(` ${label} `);
+    case "planner":
+      return chalk.bgYellow.black(` ${label} `);
+    case "critic":
+      return chalk.bgMagenta.black(` ${label} `);
+    default:
+      return chalk.bgGray.black(` ${label} `);
+  }
+}
+
+function assignmentBadges(entry: PickEntry, opts: LiveModelPickerOptions): string[] {
+  return (opts.assignments ?? [])
+    .filter(a => modelMatchesAssignment(entry, a.model))
+    .map(a => {
+      const label = a.label.trim().toUpperCase();
+      const think = a.thinking ? ` (${a.thinking})` : "";
+      return opts.color === false ? `${label}${think}` : `${roleBadgeColor(label, a.color)}${chalk.dim(think)}`;
+    });
+}
+
+
+export function buildLiveModelChoices(entries: PickEntry[], opts: LiveModelPickerOptions = {}): SelectItem<PickEntry>[] {
+  const disabled = new Set(opts.disabledProviders ?? []);
+  return entries.map(entry => {
+    const blocked = disabled.has(entry.provider);
+    const badges = assignmentBadges(entry, opts);
+    const caps = blocked ? `${liveModelHint(entry.model, opts.current)} · ${opts.disabledHint ?? "provider not ready"}` : liveModelHint(entry.model, opts.current);
+    return {
+      value: entry,
+      label: `#${entry.index} ${qualifiedModelId(entry)}`,
+      group: blocked ? `${entry.provider} (not ready)` : entry.provider,
+      hint: badges.length ? `${badges.join(" ")}  ${opts.color === false ? "· " : chalk.dim("· ")}${caps}` : caps,
+      hintRaw: badges.length > 0 && opts.color !== false,
+      disabled: blocked,
+    };
+  });
+}
+
+export function liveModelPicker(entries: PickEntry[], opts: LiveModelPickerOptions = {}): SelectList<PickEntry> {
+  return new SelectList(buildLiveModelChoices(entries, opts));
+}
+
+export function renderLiveModelPicker(list: SelectList<PickEntry>, opts: RenderSelectOptions = {}): string[] {
+  return renderSelectList(list, { title: "Select a live model", rows: 12, ...opts });
+}

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

@@ -0,0 +1,140 @@
+/**
+ * Render GFM markdown tables in assistant text as box-drawn tables (consensus-seed
+ * P2.B8). Pure-TS, width-aware (uses ./width so CJK/emoji columns align). Non-table
+ * text passes through untouched; a block is only treated as a table when it has a
+ * header row, a `|---|---|` delimiter row, and at least one body row.
+ */
+import { visibleWidth, truncateToWidth } from "./width";
+
+export interface TableRenderOptions {
+  unicode?: boolean;
+  /** Hard cap on a column's display width before truncation; keeps wide tables on screen. */
+  maxColWidth?: number;
+}
+
+/** A line is a table row when it has at least one unescaped `|` and trims to start/contain cells. */
+function isTableRow(line: string): boolean {
+  const t = line.trim();
+  return t.includes("|") && /\|/.test(t);
+}
+
+/** A line is the GFM delimiter row, e.g. `| --- | :--: | ---: |`. */
+function isDelimiterRow(line: string): boolean {
+  const t = line.trim().replace(/^\||\|$/g, "");
+  if (!t.includes("-")) return false;
+  return t.split("|").every(cell => /^\s*:?-{1,}:?\s*$/.test(cell));
+}
+
+/** Split a markdown table row into trimmed cell strings (drop the outer pipes). */
+function splitCells(line: string): string[] {
+  let t = line.trim();
+  if (t.startsWith("|")) t = t.slice(1);
+  if (t.endsWith("|")) t = t.slice(0, -1);
+  return t.split("|").map(c => c.trim());
+}
+
+type Align = "left" | "center" | "right";
+
+function alignmentsFrom(delim: string): Align[] {
+  return splitCells(delim).map(cell => {
+    const c = cell.trim();
+    const left = c.startsWith(":");
+    const right = c.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    return "left";
+  });
+}
+
+function padCell(text: string, width: number, align: Align): string {
+  const w = visibleWidth(text);
+  const pad = Math.max(0, width - w);
+  if (align === "right") return " ".repeat(pad) + text;
+  if (align === "center") {
+    const l = Math.floor(pad / 2);
+    return " ".repeat(l) + text + " ".repeat(pad - l);
+  }
+  return text + " ".repeat(pad);
+}
+
+/** Full box glyph set incl. T-junctions for grid rules (layout.BoxGlyphs has corners only). */
+interface TableGlyphs {
+  h: string; v: string;
+  tl: string; tt: string; tr: string;
+  ml: string; mm: string; mr: string;
+  bl: string; bt: string; br: string;
+}
+const TABLE_UNICODE: TableGlyphs = {
+  h: "─", v: "│",
+  tl: "┌", tt: "┬", tr: "┐",
+  ml: "├", mm: "┼", mr: "┤",
+  bl: "└", bt: "┴", br: "┘",
+};
+const TABLE_ASCII: TableGlyphs = {
+  h: "-", v: "|",
+  tl: "+", tt: "+", tr: "+",
+  ml: "+", mm: "+", mr: "+",
+  bl: "+", bt: "+", br: "+",
+};
+
+/** Render one parsed table (header + rows) to box-drawn lines. */
+function drawTable(header: string[], rows: string[][], aligns: Align[], opts: TableRenderOptions): string[] {
+  const g = opts.unicode === false ? TABLE_ASCII : TABLE_UNICODE;
+  const cap = Math.max(4, opts.maxColWidth ?? 40);
+  const cols = Math.max(header.length, ...rows.map(r => r.length));
+  const norm = (r: string[]): string[] => Array.from({ length: cols }, (_, i) => truncateToWidth(r[i] ?? "", cap));
+  const h = norm(header);
+  const body = rows.map(norm);
+  const aligned = Array.from({ length: cols }, (_, i) => aligns[i] ?? "left");
+  // Column width = max display width of header + body cells in that column.
+  const widths = Array.from({ length: cols }, (_, i) =>
+    Math.max(visibleWidth(h[i]!), ...body.map(r => visibleWidth(r[i]!)), 1),
+  );
+  const rule = (l: string, mid: string, r: string): string =>
+    l + widths.map(w => g.h.repeat(w + 2)).join(mid) + r;
+  const rowLine = (cells: string[]): string =>
+    g.v + cells.map((c, i) => " " + padCell(c, widths[i]!, aligned[i]!) + " ").join(g.v) + g.v;
+  return [
+    rule(g.tl, g.tt, g.tr),
+    rowLine(h),
+    rule(g.ml, g.mm, g.mr),
+    ...body.map(rowLine),
+    rule(g.bl, g.bt, g.br),
+  ];
+}
+
+/**
+ * Replace every GFM table block in `text` with a box-drawn table. Returns the text
+ * with tables rendered; all non-table lines are preserved verbatim.
+ */
+export function renderMarkdownTables(text: string, opts: TableRenderOptions = {}): string {
+  if (!text.includes("|")) return text;
+  const lines = text.split("\n");
+  const out: string[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    // A table needs: header row, delimiter row, ≥1 body row.
+    if (
+      i + 1 < lines.length &&
+      isTableRow(lines[i]!) &&
+      isDelimiterRow(lines[i + 1]!) &&
+      i + 2 < lines.length &&
+      isTableRow(lines[i + 2]!)
+    ) {
+      const header = splitCells(lines[i]!);
+      const aligns = alignmentsFrom(lines[i + 1]!);
+      const rows: string[][] = [];
+      let j = i + 2;
+      while (j < lines.length && isTableRow(lines[j]!) && !isDelimiterRow(lines[j]!)) {
+        rows.push(splitCells(lines[j]!));
+        j++;
+      }
+      for (const line of drawTable(header, rows, aligns, opts)) out.push(line);
+      i = j;
+      continue;
+    }
+    out.push(lines[i]!);
+    i++;
+  }
+  return out.join("\n");
+}

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

@@ -0,0 +1,97 @@
+import chalk from "chalk";
+/**
+ * Strip markdown formatting from text, returning plain text.
+ */
+export function stripMarkdown(text: string): string {
+  if (!text) return "";
+
+  let out = text;
+
+  // 1. Remove code block fences (e.g. ```ts or ```)
+  out = out.replace(/^```[a-zA-Z0-9_-]*\s*$/gm, "");
+
+  // 2. Remove inline code backticks
+  out = out.replace(/`([^`]+)`/g, "$1");
+
+  // 3. Remove headers (e.g. # Header -> Header)
+  out = out.replace(/^#+\s+(.+)$/gm, "$1");
+
+  // 4. Remove bold/italic markers
+  out = out.replace(/\*\*\*([^\*]+)\*\*\*/g, "$1");
+  out = out.replace(/\*\*([^\*]+)\*\*/g, "$1");
+  out = out.replace(/\*([^\*]+)\*/g, "$1");
+  out = out.replace(/___([^\_]+)___/g, "$1");
+  out = out.replace(/__([^\_]+)__/g, "$1");
+  out = out.replace(/_([^\_]+)_/g, "$1");
+
+  // 5. Convert links [text](url) -> text (url)
+  out = out.replace(/\[([^\]]+)\]\(([^\)]+)\)/g, "$1 ($2)");
+
+  // 6. Convert images ![alt](url) -> alt
+  out = out.replace(/!\[([^\]]*)\]\(([^\)]+)\)/g, "$1");
+
+  // 7. Remove blockquote markers (> text -> text)
+  out = out.replace(/^>\s+(.+)$/gm, "$1");
+
+  // 8. Remove horizontal rules
+  out = out.replace(/^[-\*_]{3,}\s*$/gm, "");
+
+  return out.trim();
+}
+
+export interface MarkdownAnsiOptions {
+  /** Heading painter (theme accent + bold); default chalk.bold. */
+  accent?: (s: string) => string;
+}
+
+/**
+ * Render markdown as styled ANSI text (jeo-ref final-report format): headings
+ * become painted section titles, **bold** / `inline code` keep visual weight,
+ * fences/links/quotes degrade exactly like stripMarkdown. Fenced code BODIES are
+ * passed through untouched (only the ``` fence rows are dropped) so code samples
+ * are never reformatted. Pure + stateless — safe for the one-shot finish path.
+ */
+export function renderMarkdownAnsi(text: string, opts: MarkdownAnsiOptions = {}): string {
+  if (!text) return "";
+  const accent = opts.accent ?? ((s: string) => chalk.bold(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, t: string) => chalk.bold.italic(t))
+      .replace(/\*\*([^\*]+)\*\*/g, (_m, t: string) => chalk.bold(t))
+      .replace(/__([^\_]+)__/g, (_m, t: string) => chalk.bold(t));
+
+  const out: string[] = [];
+  let inFence = false;
+  for (const line of text.split("\n")) {
+    if (/^```/.test(line.trim())) {
+      inFence = !inFence;
+      continue; // drop the fence row itself (stripMarkdown parity)
+    }
+    if (inFence) {
+      out.push(line); // code bodies verbatim — never styled or reflowed
+      continue;
+    }
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      out.push(accent(styleInline(heading[2]!)));
+      continue;
+    }
+    const quote = line.match(/^>\s+(.+)$/);
+    if (quote) {
+      out.push(chalk.dim(`▎ ${styleInline(quote[1]!)}`));
+      continue;
+    }
+    if (/^[-\*_]{3,}\s*$/.test(line)) {
+      out.push(chalk.dim("─".repeat(24)));
+      continue;
+    }
+    out.push(styleInline(line));
+  }
+  return out.join("\n").trim();
+}

package/src/tui/components/meter.ts

@@ -4,6 +4,8 @@ import { size } from "../terminal";
 export interface MeterOptions {
   /** Use ASCII-only glyphs for terminals without unicode (default true = unicode). */
   unicode?: boolean;
+  /** Whether to render color (default true). */
+  color?: boolean;
 }
 
 /** Horizontal evolutionary percent/progress meter for pipeline + doctor TUI views. */
@@ -19,7 +21,8 @@ export function meter(value: number, max = 1, width?: number, opts: MeterOptions
   const cells = width !== undefined ? Math.max(0, Math.trunc(width)) : Math.max(10, Math.min(40, size().cols - 30));
   const filledCount = Math.round(ratio * cells);
   const { fill, empty, color } = meterGlyphsFor(stageIndexForRatio(ratio), opts.unicode !== false);
-  const bar = color(fill.repeat(filledCount)) + empty.repeat(cells - filledCount);
+  const paint = opts.color !== false ? color : (s: string) => s;
+  const bar = paint(fill.repeat(filledCount)) + empty.repeat(cells - filledCount);
   return `[${bar}] ${Math.round(ratio * 100)}%`;
 }
 

package/src/tui/components/model-picker.ts

@@ -6,6 +6,7 @@
  */
 import { SelectList, renderSelectList, type SelectItem, type RenderSelectOptions } from "./select-list";
 import { catalogForProvider, type ModelCatalogEntry } from "../../ai/model-catalog-compat";
+import { companyLabel } from "../../ai/model-catalog";
 import { PROVIDER_NAMES, type ProviderStatus } from "../../ai/provider-status";
 import type { ProviderName } from "../../ai/types";
 
@@ -58,11 +59,11 @@ export function buildModelChoices(statuses: ProviderStatus[], opts: ModelPickerO
   for (const provider of providers) {
     const ready = !!readyOf.get(provider);
     if (!ready && !includeUnready) continue;
-    const group = `${provider}${ready ? "" : " (no credential)"}`;
+    const group = `${provider} — ${companyLabel(provider)}${ready ? "" : " (no credential)"}`;
     for (const entry of catalogForProvider(provider)) {
       items.push({
         value: entry.id,
-        label: entry.id,
+        label: `${entry.id} (${companyLabel(provider, entry)})`,
         group,
         hint: modelHint(entry, ready, unicode),
       });