@tiens.nguyen/gu-cli 1.0.779 → 1.0.780

package/gu-repl.mjs

@@ -74,6 +74,7 @@ import {
   maskKey,
   otherAgentRows,
   updateRow,
+  noticeRow,
   updateNotice,
   answerBlock,
   updateRestartNote,
@@ -2604,6 +2605,28 @@ function syncBarPinning() {
   if (!canPinBar()) unpinBar();
   else pinBar();
 }
+/**
+ * THE NOTICE ROW ABOVE THE SEPARATOR (#318) — or null when there is nothing to say.
+ * Priority, highest first: where you are (jump to bottom), what you can act on with a click (an
+ * update), a standing fact about the licence (the gu token notice — yellow only when urgent), and
+ * other agents. Dropped whole, lowest first, when they do not all fit.
+ */
+function zoneNotice(width) {
+  const items = [];
+  if (scrolledBack()) {
+    const n = scrollOffset;
+    items.push({ key: "jump", clickable: true, paint: accent, text: `↓ jump to bottom (click) · ${n} line${n === 1 ? "" : "s"} below` });
+  }
+  if (availableUpdates.any) {
+    const up = updateRow({ ...availableUpdates, width: 400 });
+    if (up) items.push({ key: "update", clickable: true, paint: accent, text: up.text.slice(up.from) });
+  }
+  if (tokenNotice?.text) items.push({ key: "token", paint: tokenNotice.urgent ? yellow : dim, text: tokenNotice.text });
+  const agents = agentsIndicator(otherAgents);
+  if (agents) items.push({ key: "agents", clickable: true, paint: accent, text: `${agents} running (click)` });
+  return noticeRow(items, { width, gutter: GUTTER });
+}
+
 /**
  * The whole frozen zone, top to bottom: a separator, a blank row, the INPUT LINE, then the
  * bar's rule, token and mode rows. The blank is what lifts the separator — and the control it
@@ -2624,17 +2647,12 @@ function frozenZone() {
   // #307: a question held until its turn prints anything sits on top of the status block — where
   // it will land once committed, so nothing moves when it does.
   const status = footerActive ? [] : [...pendingEchoRows(), ...liveStatusRows];
-  // DECIDED BEFORE THE LAYOUT, because the head's height depends on it: the blank under the
-  // separator exists to lift a CONTROL off the typed line, so with no control there is nothing
-  // to lift. The same three conditions the rows[sep] writes below test — kept adjacent so they
-  // cannot drift into disagreeing about whether a control is showing.
-  // The token notice counts only when it FITS — the same test its write below uses. With
-  // Boolean(tokenNotice) alone, a narrow terminal lifted a blank row for a line it never drew.
-  const tokenFits = Boolean(tokenNotice) && visibleLen(tokenNotice.text) + 4 <= width - 1;
-  const headControl =
-    scrolledBack() || availableUpdates.any || tokenFits || Boolean(agentsIndicator(otherAgents));
+  // THE SEPARATOR CARRIES NOTHING (#318). What used to ride on it — jump-to-bottom, the update
+  // control, the gu token notice, the agents count — is on its own NOTICE ROW above it; the head
+  // is just the rule, with no blank to lift a control off the typed line.
+  const notice = zoneNotice(width);
   const zone = inputZoneRows({
-    headControl,
+    headControl: false,
     width,
     // #258: typing during a turn is not sent — the row says so (an ask() label still comes first).
     prompt: secretInput && secretPrompt
@@ -2679,61 +2697,14 @@ function frozenZone() {
     selection: secretInput ? null : inputSelection,
     highlight: highlightRow,
   });
-  const rows = status.concat(zone.rows, askHintRows(width), footerRows());
-  // THE SEPARATOR IS NO LONGER ROW 0. With the status block prepended it sits `status.length`
-  // rows down, and every affordance below writes to it by index — a bare rows[0] would paint
-  // the jump hint over the thought line and hit-test the wrong row.
-  const sep = status.length;
-  // THE SEPARATOR ROW carries at most one affordance, and the two contend for it:
-  //
-  //  · scrolled back → "↓ jump to bottom", which WINS. It is transient and about where you are
-  //    right now; an update is neither, and will still be there when you come back.
-  //  · otherwise, and only when something is genuinely newer → the update control (task #181).
-  //
-  // Both are stored with their COLUMN span, because the row is hit-tested by column now — one
-  // row, two possible targets, and "anywhere on this row" would make the wrong one fire.
-  updateRowTarget = null;
-  agentsRowTarget = null;
-  if (scrolledBack()) {
-    const hint = jumpToBottomRow({ below: scrollOffset, width });
-    rows[sep] = clipVisible(accent(hint.text), width - 1);
-  } else if (availableUpdates.any) {
-    const up = updateRow({ ...availableUpdates, width });
-    if (up) {
-      rows[sep] = clipVisible(dim(up.text.slice(0, up.from)) + accent(up.text.slice(up.from)), width - 1);
-      updateRowTarget = { from: up.from, to: up.to };
-    }
-  } else if (tokenFits) {
-    // The gu token's one line (#232), right-aligned like the controls around it. BELOW the update
-    // control, because an update is actionable with a click and this is a standing fact; ABOVE the
-    // agents count, because it needs the user and that does not. Not clickable. Too narrow to say
-    // it whole → the condition above lets the agents count (or nothing) have the row instead.
-    const len = visibleLen(tokenNotice.text);
-    const from = width - 1 - len;
-    // Yellow only when the user must act (plan ended, over the computer limit); an old token is
-    // routine and reads in the rule's own dim grey (#292 — the yellow line "seems so serious").
-    const paint = tokenNotice.urgent ? yellow : dim;
-    rows[sep] = clipVisible(dim("\u2500".repeat(Math.max(0, from - 1)) + " ") + paint(tokenNotice.text), width - 1);
-  } else if (agentsIndicator(otherAgents)) {
-    // …and when there is no update to offer, the same row carries the agents count (task #195).
-    // THREE THINGS CANNOT SHARE ONE ROW, so they are ranked by how time-critical they are:
-    // the jump hint is about where you are RIGHT NOW, an update is a standing fact, and other
-    // agents change on their own. Update wins over agents because it is rarer and actionable;
-    // agents are always one click away through the same row once it is free.
-    const label = `${agentsIndicator(otherAgents)} running (click)`;
-    const len = visibleLen(label);
-    if (len + 4 <= width - 1) {
-      const from = width - 1 - len;
-      rows[sep] = clipVisible(dim("\u2500".repeat(Math.max(0, from - 1)) + " ") + accent(label), width - 1);
-      agentsRowTarget = { from, to: from + len };
-    }
-  }
-  // Spread, not a hand-written pick: this used to list the fields it forwarded, and adding
-  // rowCount/caretRow to inputZoneRows left them silently undefined here — the caret would have
-  // parked on the first row of a wrapped input forever.
-  // statusRows so paintBar can offset the input row and the separator's absolute position;
-  // without it every click and caret park would be `status.length` rows out.
-  return { ...zone, rows, statusRows: sep };
+  const rows = status.concat(notice ? [notice.row] : [], zone.rows, askHintRows(width), footerRows());
+  // The separator is `status.length (+1 for the notice row)` rows down — everything that writes to
+  // or hit-tests a row by index counts from here.
+  const sep = status.length + (notice ? 1 : 0);
+  updateRowTarget = notice?.spans.update ?? null;
+  agentsRowTarget = notice?.spans.agents ?? null;
+  jumpSpan = notice?.spans.jump ?? null;
+  return { ...zone, rows, statusRows: sep, noticeRow: Boolean(notice) };
 }
 /**
  * Put the output position back at column 0 of its own row — without printing anything.
@@ -2773,8 +2744,10 @@ function paintBar() {
   // The rows exactly as painted, so a double-click reads the same characters the user is
   // looking at rather than re-deriving them from rl.line at a width this may not be.
   inputRowTexts = zone.rows.slice((zone.statusRows ?? 0) + head);
-  jumpRowTarget = scrolledBack() ? { row: sepAbs } : null; // the SEPARATOR row
-  updateRowAbs = updateRowTarget || agentsRowTarget ? sepAbs : 0; // …the same row, when showing
+  // THE NOTICE ROW is the one directly above the separator (#318) — never the separator itself.
+  const noticeAbs = zone.noticeRow ? sepAbs - 1 : 0;
+  jumpRowTarget = scrolledBack() && jumpSpan ? { row: noticeAbs, ...jumpSpan } : null;
+  updateRowAbs = updateRowTarget || agentsRowTarget ? noticeAbs : 0;
   // preserveCaret:false — the save slot holds the OUTPUT position (see regionUi), and the caret
   // is parked on the input line right after, so there is nothing to preserve here.
   ui(
@@ -2928,6 +2901,8 @@ let liveStatusRows = [];
 // Where the "jump to bottom" line currently is (1-based viewport row + column span), so a click
 // can hit it. Null while the view is live.
 let jumpRowTarget = null;
+/** The jump-to-bottom hint's column span on the notice row (#318), set by frozenZone. */
+let jumpSpan = null;
 // The update control's column span on the separator row, and that row's absolute position.
 // Column-scoped (task #181): the row is shared with the jump-to-bottom hint, so a click has to
 // land ON the label rather than anywhere along it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.779",
+  "version": "1.0.780",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",

package/terminal-layout.mjs

@@ -2814,3 +2814,41 @@ export function hintRows(lines, { width, gutter = "   ", paint = (s) => s } = {}
   }
   return out.map((r) => gutter + paint(r));
 }
+
+/**
+ * THE NOTICE ROW — its own row, directly ABOVE the separator (#318).
+ *
+ * The rule above ">>" is only a separator (the user, angrily: "the line is for separating the
+ * user's input, not for that"). Four things used to ride on it, one at a time — the jump-to-bottom
+ * hint, the update control, the gu token notice, the agents count — because the row looked free.
+ * Now they share this row instead, right-aligned, joined with " · ", in PRIORITY order (the first
+ * item is the most important). What does not fit is dropped WHOLE, lowest priority first — never
+ * cut mid-word. No items → null, and the zone simply has no such row.
+ *
+ * items: [{ key, text, paint?, clickable? }] → { row, spans: { [key]: { from, to } } } | null
+ * `spans` are 0-based columns of the CLICKABLE items, gutter included — what a click is tested on.
+ */
+export function noticeRow(items, { width = 80, gutter = "   ", sep = "  ·  " } = {}) {
+  const w = Math.max(20, width | 0);
+  const room = w - 1 - visibleLen(gutter);
+  const list = (Array.isArray(items) ? items : []).filter((i) => i && i.text);
+  let kept = list;
+  const joinedLen = (xs) => xs.reduce((n, x, i) => n + visibleLen(x.text) + (i ? sep.length : 0), 0);
+  while (kept.length && joinedLen(kept) > room) kept = kept.slice(0, -1);
+  if (!kept.length) return null;
+  const start = w - 1 - joinedLen(kept);
+  let row = " ".repeat(start);
+  let col = start;
+  const spans = {};
+  kept.forEach((x, i) => {
+    if (i) {
+      row += sep;
+      col += sep.length;
+    }
+    const len = visibleLen(x.text);
+    if (x.clickable) spans[x.key] = { from: col, to: col + len };
+    row += (x.paint ?? ((s) => s))(x.text);
+    col += len;
+  });
+  return { row, spans };
+}