acuvo-code 0.6.9 → 0.6.10

package/lib/banner.mjs

@@ -1,90 +1,128 @@
 /**
  * ── ⭐⭐⭐ WHAT YOU SEE WHEN YOU TYPE `acuvo` ────────────────────────────────
  *
- * Roman, 2026-08-22, having typed it: *"it's not opening as a typable terminal,
- * with acuvo logo top left and details up top etc, like how claude code opens.
- * have you actually designed the page?"* — and then: *"no we want OUR logo"*.
+ * ── ⚠️⚠️ REWRITTEN AGAINST A SCREENSHOT OF THE REFERENCE, NOT A DESCRIPTION ──
  *
- * So this is the real mark, not letters spelling the name. It is
- * `console/public/brand/acuvo-mark.png` — the angular A — resampled to
- * half-blocks at 14x14 and embedded as text.
+ * Roman, 2026-08-22, having put the two side by side: *"look at the sizing of
+ * logo and text near it, and what it says, the structure, the wording like
+ * theirs, the model version, the repo folder."*
  *
- * ── ⚠️ WHY IT IS EMBEDDED RATHER THAN DECODED AT RUNTIME ────────────────────
+ * The reference, read off the image rather than remembered:
  *
- * This package has ZERO dependencies, deliberately, and Node cannot decode a
- * PNG without one. Converting at build time and pasting the result keeps that
- * promise and costs nothing at startup. If the mark ever changes, re-run the
- * conversion — the logo is DERIVED from the brand asset, not drawn by hand, so
- * it stays honest to it.
+ *     [mark]  Claude Code v2.1.219
+ *             Opus 5 (1M context) with high effort · Claude Max
+ *             C:\Projects\claude-build
+ *
+ * Three things that were wrong here, each a decision made without looking:
+ *
+ *   1. **The mark was SEVEN rows.** Theirs is three. A logo taller than the
+ *      information beside it turns the opening screen into a title card for
+ *      something you run forty times a day.
+ *   2. **The facts were a LABELLED TABLE** — `workspace / model / billing /
+ *      can run` down a column. Theirs is three prose lines with no labels,
+ *      because the values are self-describing: a version looks like a version,
+ *      a path looks like a path. Labels are what you add when the reader cannot
+ *      tell what they are looking at.
+ *   3. **The model line said only the model.** Theirs carries model, effort AND
+ *      plan on one line separated by `·` — everything about "what am I talking
+ *      to and who is paying" in one glance.
  *
  * ── ⚠️ THE CONSTRAINTS, WHICH ARE NOT PREFERENCES ───────────────────────────
  *
- * · **Half-block glyphs only** (▀ ▄ █). Braille and box-drawing render as tofu
- *   in cmd.exe and in many CI log viewers, and a logo that renders as question
- *   marks is worse than no logo — on the exact platform this is developed on.
+ * · **Half-block glyphs only** (▀ ▄ █) for the art, and only when the terminal
+ *   measures them at ONE cell — see `lib/glyph-width.mjs`. They are East Asian
+ *   Ambiguous, so where they render double-width the padding spaces stay narrow
+ *   and the mark tears.
  * · **No colour escapes here.** The caller owns colour and honours NO_COLOR; a
  *   module that hard-codes them emits garbage the moment output is piped.
- * · **Every line under 80 columns.** The narrowest terminal in real use is 80,
- *   and a wrapped banner does not read as dense, it reads as broken.
- *
- * ⭐ A NOTE ON DOING BETTER: `lib/terminal-graphics.mjs` can send a real PNG
- * inline on Kitty and iTerm2. It is deliberately NOT used here — Windows
- * Terminal speaks neither protocol, so the block art is what most users would
- * see anyway, and one rendering that is the same everywhere beats two that
- * disagree.
+ * · **Never wider than the terminal.** Not 80 — the actual width, which a split
+ *   pane makes much smaller.
  */
 
 /**
- * The Acuvo mark, resampled from the brand PNG. Seven rows: tall enough to be
- * the mark rather than a smudge, short enough for something run forty times a
- * day rather than opened once.
+ * The Acuvo mark, in half-blocks. FOUR rows, down from seven.
+ *
+ * ⚠️ THE HEIGHT IS THE POINT. It has to sit beside three lines of text without
+ * dominating them — the proportion the reference uses, and the reason their
+ * opening screen reads as a status line rather than a splash.
  */
 const MARK = [
-  '      ▄█',
-  '     ▄███',
-  '    ▄█▀▀██',
-  '   ▄█▀  ▀██',
-  '  ▄█▀ ██ ▀██',
-  ' ▄████▀▀█████',
-  '█▀      █▀  ▀█',
+  '   ▄█▄',
+  '  ▄█▀█▄',
+  ' ▄█▄▄▄█▄',
+  '█▀     ▀█',
 ];
 
 /**
- * ── ⭐⭐⭐ THE SAME MARK, IN CHARACTERS NOTHING CAN STRETCH ─────────────────
- *
- * Every glyph here is ASCII, so it is width-1 by definition in every terminal,
- * every font, every locale. No ambiguity class, nothing to measure, nothing to
- * get wrong.
+ * The same mark in characters nothing can stretch.
  *
- * ⚠️ THIS IS NOT "NO LOGO" — that distinction matters. Roman asked for OUR
- * mark and then asked again when he got letters spelling the name. The fallback
- * for a terminal that cannot draw half-blocks must therefore still BE the
- * angular A, drawn a different way, rather than a wordmark standing in for it.
- * A degraded logo is a logo; a text substitute is a missing one.
+ * ⚠️ THIS IS NOT "NO LOGO" — the distinction matters. Roman asked for OUR mark
+ * and asked again when he got letters spelling the name. A terminal that cannot
+ * draw half-blocks must still get the angular A, drawn another way. A degraded
+ * logo is a logo; a wordmark standing in for one is a missing logo.
  */
 const MARK_ASCII = [
-  '     /\\',
-  '    /  \\',
-  '   / /\\ \\',
-  '  / /  \\ \\',
-  ' / /____\\ \\',
-  '/_/      \\_\\',
+  '   /\\',
+  '  /  \\',
+  ' /----\\',
+  '/      \\',
 ];
 
 const GUTTER = 2;
 
 /**
- * The widest the banner may ever be when the terminal will not say how wide it
- * is. Kept at 80 because that is the narrowest terminal in real use, so a
- * banner built to it fits everywhere.
+ * The widest the banner may be when the terminal will not say how wide it is.
+ * 80, because that is the narrowest terminal in real use.
  */
 export const MAX_BANNER_COLUMNS = 80;
 
-/** Below this the two-column layout stops being a layout and starts being a mess. */
+/** Below this the two-column layout stops being a layout. */
 const MIN_TEXT_COLUMNS = 30;
 
+/** Visible length, ignoring ANSI escapes — they occupy no cells. */
+function visibleLength(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
 /**
- * Build the opening screen: mark on the left, facts on the right.
+ * Cut a possibly-coloured string to `width` visible cells, keeping escapes
+ * balanced so a truncation cannot leak colour into the rest of the screen.
+ */
+function clampToWidth(s, width) {
+  if (visibleLength(s) <= width) return s;
+  let out = '';
+  let seen = 0;
+  const re = /(\x1b\[[0-9;]*m)|([\s\S])/g;
+  let m;
+  while ((m = re.exec(s)) !== null) {
+    if (m[1]) { out += m[1]; continue; }
+    if (seen >= width) break;
+    out += m[2];
+    seen += 1;
+  }
+  /**
+   * ⚠️ ONLY RE-CLOSE A STRING THAT WAS ACTUALLY COLOURED. Appending a reset
+   * unconditionally puts four bytes on the end of every truncated PLAIN line —
+   * harmless on a terminal, garbage the moment output is piped to a file.
+   */
+  return out.includes('\x1b') ? `${out}\x1b[0m` : out;
+}
+
+/**
+ * Elide in the MIDDLE, never the end.
+ *
+ * The informative parts of a path are the drive and the leaf; chopping the tail
+ * leaves `C:\Users\somebody\Projects\a-`, which identifies nothing.
+ */
+function fit(value, room) {
+  const s = String(value ?? '');
+  if (s.length <= room) return s;
+  const head = Math.ceil((room - 1) / 2);
+  return `${s.slice(0, head)}…${s.slice(s.length - (room - 1 - head))}`;
+}
+
+/**
+ * Build the opening screen.
  *
  * @param {object} o
  * @param {string} o.version
@@ -104,63 +142,39 @@ export function openingScreen({
   const brand = paint?.brand ?? ((s) => s);
 
   /**
-   * ── ⚠️⚠️ THE WIDTH IS THE TERMINAL'S, NOT A CONSTANT ──────────────────
-   *
-   * This used to build to a fixed 80 columns and never ask. Every line it
-   * produced was under 80 and it looked immaculate — in an 80-column terminal.
-   * In a narrower one, which is what a side panel or a split pane is, every
-   * single row wraps, and a wrapped banner does not read as dense. It reads as
-   * broken software, which is the first thing a new user sees.
-   *
-   * `- 1` because a line that exactly fills the width wraps on some terminals
-   * and not others, and the difference is not worth one column.
+   * ⚠️ THE WIDTH IS THE TERMINAL'S, NOT A CONSTANT. This built to a fixed 80 and
+   * never asked; every line was under 80 and it looked immaculate — in an
+   * 80-column terminal. In a split pane every row wrapped.
    */
   const width = Math.max(20, Math.min(MAX_BANNER_COLUMNS, (columns ?? MAX_BANNER_COLUMNS) - 1));
 
   const mark = style === 'text' ? MARK_ASCII : MARK;
   const markWidth = Math.max(...mark.map((l) => l.length));
 
-  /**
-   * ⭐ THREE LAYOUTS, CHOSEN BY WHAT ACTUALLY FITS — never by a platform guess.
-   * Side by side when there is room for both; mark above the facts when there
-   * is room for the mark alone; facts only when there is not. The last one is
-   * rare and it still has to be right, because a 24-column terminal is somebody
-   * on a phone over SSH and they deserve a legible screen, not a torn one.
-   */
   const sideBySide = width >= markWidth + GUTTER + MIN_TEXT_COLUMNS;
   const textColumns = sideBySide ? width - markWidth - GUTTER : width;
+  const room = Math.max(12, textColumns);
 
   /**
-   * ⚠️ ELIDED IN THE MIDDLE, NOT THE END. The informative parts of a path are
-   * the drive and the leaf; chopping the tail leaves `C:\Users\somebody\Projects\a-`,
-   * which identifies nothing. Same for a model id, where the family is at the
-   * front and the variant at the back.
+   * ── ⭐ THREE LINES, NO LABELS, IN THE REFERENCE'S ORDER ────────────────────
+   *
+   * Name and version · what you are talking to and who pays · where you are.
+   *
+   * ⚠️ `billing` JOINS THE MODEL LINE rather than taking a row of its own, which
+   * is how the reference does it ("… with high effort · Claude Max"). It matters
+   * more here than it does for them: our billing line is the one that says
+   * **"YOUR OWN OpenRouter key (not your Acuvo plan)"**, and somebody needs to
+   * see that beside the model, not three rows away from it.
    */
-  const room = Math.max(8, textColumns - 11);
-  const fit = (v) => {
-    const s = String(v ?? '');
-    if (s.length <= room) return s;
-    const head = Math.ceil((room - 1) / 2);
-    return `${s.slice(0, head)}…${s.slice(s.length - (room - 1 - head))}`;
-  };
-
   const right = [
-    `ACUVO CODE${version ? `  ${version}` : ''}`,
-    '',
-    `workspace  ${fit(workspace)}`,
-    `model      ${fit(model)}`,
-    `billing    ${fit(billing)}`,
-    `can run    ${fit(canRun)}`,
-    '',
+    `Acuvo Code${version ? ` v${version}` : ''}`,
+    fit([model, billing].filter(Boolean).join(' · '), room),
+    fit(workspace, room),
   ];
 
   const lines = [''];
 
   if (sideBySide) {
-    /**
-     * ⚠️ THE TWO COLUMNS ARE ZIPPED, NOT CONCATENATED, and the row counts are
-     * allowed to differ — whichever is shorter simply runs out.
-     */
     const rows = Math.max(mark.length, right.length);
     for (let i = 0; i < rows; i += 1) {
       const text = right[i] ?? '';
@@ -170,39 +184,42 @@ export function openingScreen({
        * right-hand column drifts.
        *
        * ⚠️⚠️ AND PADDED ONLY WHEN SOMETHING FOLLOWS. On a mark-only row the
-       * padding sits INSIDE the colour, before the reset, where `trimEnd`
-       * cannot reach it — so the coloured banner carried trailing whitespace the
-       * plain one did not. Invisible, but it means colour changed the layout.
+       * padding sits INSIDE the colour, before the reset, where `trimEnd` cannot
+       * reach it — so the coloured banner carried trailing whitespace the plain
+       * one did not, which means colour changed the layout.
        */
       const raw = mark[i] ?? '';
       const padded = text ? raw.padEnd(markWidth + GUTTER) : raw;
       lines.push(`${mark[i] ? brand(padded) : padded}${text}`.trimEnd());
     }
   } else {
-    const roomForMark = width >= markWidth;
-    if (roomForMark) {
+    if (width >= markWidth) {
       for (const row of mark) lines.push(brand(row));
       lines.push('');
     }
     for (const text of right) lines.push(text.trimEnd());
   }
 
-  lines.push('');
-
   /**
-   * ⚠️ ONLY WHEN A PROMPT ACTUALLY FOLLOWS. Printing "type what you want done"
-   * above a one-shot run that has already been given its task is an instruction
-   * for something the user cannot do.
+   * ── ⚠️ WHAT IT MAY RUN IS A SEPARATE, QUIETER LINE ─────────────────────────
    *
-   * ⭐ And it is SHORTENED rather than wrapped when the terminal is narrow. A
-   * hint that wraps onto a second line looks like an error message.
+   * The reference puts this at the very bottom of the screen ("bypass
+   * permissions on (shift+tab to cycle)"), away from the identity block, because
+   * it is a MODE rather than a fact about the session. Keeping it out of the
+   * three-line lockup is what stops that block growing back into the table it
+   * used to be.
    */
+  if (canRun) {
+    lines.push('', clampToWidth(fit(canRun, width), width));
+  }
+
+  lines.push('');
+
   if (interactive) {
     /**
      * ⭐ SHORTENED IN STAGES, NEVER TRUNCATED. A clamp would cut "leave" to
-     * "leav", and a hint with a word chopped in half does not read as a
-     * compact hint — it reads as a rendering bug, which is precisely the
-     * impression this screen keeps making.
+     * "leav", and a hint with a word chopped in half reads as a rendering bug —
+     * precisely the impression this screen keeps making.
      */
     const hints = [
       '  Type what you want done.   /help for commands  ·  exit to leave',
@@ -213,43 +230,11 @@ export function openingScreen({
   }
 
   /**
-   * ⚠️⚠️ THE LAST WORD ON WIDTH, AND IT IS NOT A BELT-AND-BRACES CHECK.
-   * Everything above reasons about `.length`, which counts CODE UNITS, while a
-   * terminal counts CELLS — and the whole reason this file was rewritten is that
-   * those two disagree. This clamp is measured on the painted string with the
-   * escapes discounted, so a mark that turns out wider than advertised is
-   * truncated rather than allowed to wrap and tear the layout.
+   * ⚠️⚠️ THE LAST WORD ON WIDTH. Everything above reasons about `.length`, which
+   * counts CODE UNITS, while a terminal counts CELLS — and the whole reason this
+   * file was rewritten is that those two disagree. Measured on the painted
+   * string with escapes discounted, so a mark wider than advertised is truncated
+   * rather than allowed to wrap and tear the layout.
    */
   return lines.map((l) => clampToWidth(l, width)).join('\n');
 }
-
-/** Visible length, ignoring ANSI escapes — they occupy no cells. */
-function visibleLength(s) {
-  return String(s).replace(/\[[0-9;]*m/g, '').length;
-}
-
-/**
- * Cut a possibly-coloured string to `width` visible cells, keeping the escapes
- * balanced so a truncation cannot leak colour into the rest of the screen.
- */
-function clampToWidth(s, width) {
-  if (visibleLength(s) <= width) return s;
-  let out = '';
-  let seen = 0;
-  const re = /(\[[0-9;]*m)|([\s\S])/g;
-  let m;
-  while ((m = re.exec(s)) !== null) {
-    if (m[1]) { out += m[1]; continue; }
-    if (seen >= width) break;
-    out += m[2];
-    seen += 1;
-  }
-  /**
-   * ⚠️ ONLY RE-CLOSE A STRING THAT WAS ACTUALLY COLOURED. Appending a reset
-   * unconditionally puts four bytes on the end of every truncated PLAIN line —
-   * harmless on a terminal, and garbage the moment output is piped to a file or
-   * a CI log, which is the one place this module has already been told never to
-   * write escapes.
-   */
-  return out.includes('') ? `${out}` : out;
-}

package/lib/input-box.mjs

@@ -557,7 +557,32 @@ export function pinRegion(output, { rows = 2, env = process.env } = {}) {
    * is a quieter version of the same defect this rewrite removes.
    */
   const makeRoom = '\n'.repeat(rows);
-  output.write(`${makeRoom}${CSI}${rows}A${CSI}1;${bottom}r${CSI}${bottom};1H`);
+  /**
+   * ── ⚠️⚠️ THE CURSOR GOES BACK WHERE THE CONTENT ENDED, NOT TO THE BOTTOM ──
+   *
+   * Roman, from a screenshot: the banner sat at the top, then forty blank
+   * rows, then the invitation alone near the bottom — "the prompt box is too
+   * low and you have to scroll down to see everything."
+   *
+   * The cause was the last move in the old sequence, `ESC[{bottom};1H`. It
+   * parked the cursor on the LAST row of the scrolling region, so the first
+   * thing printed after pinning landed at the bottom of the screen and the
+   * whole gap opened up behind it. A terminal fills DOWNWARD: after reserving
+   * rows, output has to carry on from exactly where the banner stopped.
+   *
+   * ⭐ DECSC/DECRC (`ESC7`/`ESC8`) rather than an absolute move, because the
+   * right row is "wherever the content happens to end" and only the terminal
+   * knows that. Setting a scroll region homes the cursor to (1,1) as a side
+   * effect — that is the reason a restore is needed at all, and the reason the
+   * old code moved the cursor somewhere explicit in the first place. It just
+   * moved it to the wrong somewhere.
+   *
+   * ⚠️ The save happens AFTER the newlines and the step back up, so the
+   * position being restored is already inside the region — a restore to a row
+   * below the region would put the cursor outside it, which is undefined
+   * across terminals.
+   */
+  output.write(`${makeRoom}${CSI}${rows}A\x1b7${CSI}1;${bottom}r\x1b8`);
 
   const release = () => {
     if (released) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acuvo-code",
-  "version": "0.6.9",
+  "version": "0.6.10",
   "description": "Acuvo Code — the terminal client for the Acuvo capability registry. Zero dependencies, by design.",
   "type": "module",
   "bin": {