@tiens.nguyen/gu-cli 1.0.775 → 1.0.777

package/agent-model-label.mjs

@@ -88,6 +88,11 @@ export function agentModelLabel({ configuredId = "", agentUrl = "", servers = []
   if (namesAModel(configuredId)) {
     return { name: String(configuredId).trim(), known: true, reason: "settings" };
   }
+  // NOTHING SET (#314): no name and no server — a first install that skipped model setup. Saying
+  // "(named by the remote server)" there claimed a server that does not exist.
+  if (!String(agentUrl ?? "").trim()) {
+    return { name: "", known: false, reason: "not-set" };
+  }
   // The sentinel means "ask the server". We can only do that for a server on THIS machine: a
   // client machine points at another Mac, and a local `ps` row is then somebody else's process.
   if (!servesFromThisMachine(agentUrl)) {
@@ -148,6 +153,7 @@ export function sameModelName(a, b) {
 /** Plain-text fallback for each reason we cannot name the model. Never a sentinel. */
 export const UNKNOWN_MODEL_TEXT = Object.freeze({
   remote: "(named by the remote server)",
+  "not-set": "not set — /agent-model",
   "no-server": "(no model server running)",
   ambiguous: "(the loaded model)",
 });

package/clear-state.mjs

@@ -33,7 +33,7 @@ export const STATE_ITEMS = [
   { path: "instance", group: "identity",
     what: "this machine's id", cost: "it gets a new one" },
   { path: "cli-token.json", group: "identity",
-    what: "the gu token (plan + computers)", cost: "a Client Expert machine needs it pasted again" },
+    what: "the gu token (plan + computers)", cost: "asked for again at the next start (a free trial comes back with the days it had left)" },
   { path: "prefs.json", group: "identity", what: "CLI preferences", cost: "defaults return" },
   { path: "wizard-state.json", group: "identity",
     what: "installer progress", cost: "the wizard starts over" },

package/cli-token.mjs

@@ -195,20 +195,24 @@ export function shortToken(token) {
 }
 
 /**
- * THE TOKEN QUESTION, WITH THE TRIAL AS ITS DEFAULT (#305, the user's correction: "gu should still
- * wait for the user to input a token, but show a default token and hint that it is a free trial
- * for 10 days — not silently").
+ * THE TOKEN QUESTION, WITH THE TRIAL AS ITS DEFAULT (#305/#76, placed by #314).
  *
  *     Input token: gu1.eyJ2IjoxLCJz…Xk9aQw          ← typed in: Enter takes it, or delete it
  *     This is a free trial token: 10 days on this computer, until 10 Oct 2026.     ← yellow, under
  *     For a free token for 1 computer, log in at gu.example/account and create one — or buy Pro …
  *
  * The trial is fetched first (it is the same one every time for this computer). Nothing is saved
- * without an answer: the shown default → the trial; anything else is checked as a pasted token;
- * nothing at all (the default deleted) → skipped. Asked at the end of first-time setup, and before
- * a private-mode turn whenever there is still no token.
+ * without an answer: the shown default → the trial; anything else is checked as a pasted token.
  *
- * `ask(label, { prefill, hint })` → the typed line. `log(line, kind)` prints: "title" | "ok" | "warn".
+ * REQUIRED (the user's rule, #314): "only allow Enter — there is already the default token; if
+ * not, the user can delete it and input another". There is no skip: an empty Enter re-offers the
+ * default (the person deleted it and changed their mind), and with no default at all (trial used,
+ * or offline) it tries the trial again — so the question ends only with a valid token.
+ * `required: false` keeps the old two-tries-then-give-up shape for callers that may skip.
+ *
+ * `ask(label, { prefill, hint, atomic, noCancel })` → the typed line. `atomic` = the default is one
+ * unit (one Backspace clears it all); `noCancel` = Esc does nothing. `log(line, kind)` prints:
+ * "title" | "ok" | "warn".
  * → { ok: true, kind: "trial" | "pasted" } | { ok: false, why: "skipped" | "refused" }
  */
 export async function promptForToken({
@@ -220,25 +224,36 @@ export async function promptForToken({
   device,
   claim = claimTrial,
   publicKeyB64 = publicKey(),
+  required = false,
+  maxRounds = 1000, // a bound for tests; a person answers long before this
 }) {
   const accountUrl = `${String(site).replace(/^https?:\/\//, "")}/account`;
   const dev = device === undefined ? await trialDevice().catch(() => null) : device;
-  const trial = dev ? await claim({ hostedBase, device: dev }) : { ok: false, why: "no-device" };
-  const trialOk = trial.ok && verifyCliToken(trial.token, publicKeyB64).ok;
-
-  const shown = trialOk ? shortToken(trial.token) : "";
   const getOne = `For a free token for 1 computer, log in at ${accountUrl} and create one — or buy Pro there for more computers.`;
-  const hint = trialOk
-    ? [`This is a free trial token: 10 days on this computer, until ${shortDate(trial.endsAt)}.`, getOne, "Enter uses it — or delete it and paste your own token."]
-    : [
-        ...(trial.why === "used" && trial.endedAt ? [`The free trial on this computer ended on ${shortDate(trial.endedAt)}.`] : []),
-        getOne,
-        "Paste it here — or Enter to skip for now.",
-      ];
+  let trial, trialOk, shown, hint;
+  const offer = async () => {
+    trial = dev ? await claim({ hostedBase, device: dev }) : { ok: false, why: "no-device" };
+    trialOk = Boolean(trial.ok && verifyCliToken(trial.token, publicKeyB64).ok);
+    shown = trialOk ? shortToken(trial.token) : "";
+    hint = trialOk
+      ? [`This is a free trial token: 10 days on this computer, until ${shortDate(trial.endsAt)}.`, getOne, "Enter uses it — or delete it (one Backspace) and paste your own token."]
+      : [
+          ...(trial.why === "used" && trial.endedAt ? [`The free trial on this computer ended on ${shortDate(trial.endedAt)}.`] : []),
+          ...(trial.why === "unreachable" ? ["The gu service can't be reached right now — Enter on an empty line tries again."] : []),
+          getOne,
+          required ? "Paste it here, then Enter." : "Paste it here — or Enter to skip for now.",
+        ];
+  };
+  await offer();
   log("This computer needs a gu token before the agent can start — one time only.", "title");
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const typed = String((await ask("Input token: ", { prefill: shown, hint })) ?? "").trim();
-    if (!typed) return { ok: false, why: "skipped" };
+  const ask1 = () => ask("Input token: ", { prefill: shown, hint, atomic: true, noCancel: required });
+  for (let round = 0; required ? round < maxRounds : round < 2; round++) {
+    const typed = String((await ask1()) ?? "").trim();
+    if (!typed) {
+      if (!required) return { ok: false, why: "skipped" };
+      if (!trialOk) await offer(); // no default: maybe the service is back, or the trial exists now
+      continue;
+    }
     if (trialOk && (typed === shown || typed === trial.token)) {
       await writeState(dir, { token: trial.token, lastAttemptAt: new Date().toISOString() });
       log(`✓ free trial token saved — 10 days on this computer, until ${shortDate(trial.endsAt)}.`, "ok");

package/client-expert-run.mjs

@@ -1153,26 +1153,6 @@ export async function runClientExpertSetup({
     await saveState(state);
   }
 
-  // THE gu TOKEN, AS THE LAST SETUP STEP (#305): private mode needs one before the first turn, so
-  // it is asked while the person is still answering setup questions — with this computer's free
-  // 10-day trial as the default (Enter), never taken silently. Skipped → asked at the first turn.
-  try {
-    const ct = await import("./cli-token.mjs");
-    const had = await ct.readState(join(homedir(), ".gonext"));
-    if (ct.publicKey() && !(had.token && ct.verifyCliToken(had.token, ct.publicKey()).ok)) {
-      const { DEFAULT_API_BASE } = await import("./device-login.mjs");
-      console.log("");
-      await ct.promptForToken({
-        ask: (label, opts) => ask("  " + label, opts),
-        dir: join(homedir(), ".gonext"),
-        hostedBase: String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE,
-        log: (l, kind) => console.log("  " + (kind === "ok" ? cyan(l) : kind === "title" ? bold(l) : kind === "warn" ? yellow(l) : dim(l))),
-      });
-    }
-  } catch (e) {
-    console.log(dim(`  (the gu token can be added later: gu token <paste> — ${e?.message ?? e})`));
-  }
-
   console.log(
     "\n  " + cyan(bold("Local mode is set up.")) +
     dim("\n  Everything — conversations, token counts, workspaces — stays in MongoDB on this") +

package/gu-cli.mjs

@@ -1160,7 +1160,10 @@ if (args[0] === "clear" || args[0] === "reset") {
   const status = await ctl.daemonStatus();
   console.log("");
   if (status.running) {
-    console.log(`This will first stop the running worker (pid ${status.pid ?? "?"}).`);
+    // daemonStatus() reports `pids` (there can be more than one); `pid` never existed, which is
+    // why this always read "(pid ?)" (#314).
+    const pids = status.pids?.length ? status.pids.join(", ") : "";
+    console.log(`This will first stop the running worker${pids ? ` (pid ${pids})` : ""}.`);
   }
   if (dbItem) {
     console.log(

package/gu-repl.mjs

@@ -658,11 +658,8 @@ if (!workerKey || !apiBase) {
         input: process.stdin,
         output: process.stdout,
       });
-      // #305: a question with a typed-in default or a hint under it goes through askOn, which draws both.
-      const ask0 = async (q, opts) =>
-        opts
-          ? String((await (await import("./setup-prompts.mjs")).askOn(rl0, q, { style: accent, ...opts })) || "")
-          : new Promise((res) => rl0.question(accent(q), (a) => res(String(a || ""))));
+      const ask0 = (q) =>
+        new Promise((res) => rl0.question(accent(q), (a) => res(String(a || ""))));
       let typed = "";
       // Set when Client Expert setup stops on something the user must do first: the run ends
       // after the instructions instead of continuing into questions that assume a paired,
@@ -973,6 +970,10 @@ function printCommands(prefix = "") {
 // bar, the live status block, the slash overlay, the pickers, mode-setting escapes — is
 // written through `ui()`, which marks it so it is neither recorded nor held back.
 const transcript = createTranscript();
+// Until the frozen zone first takes the screen, the transcript FOLLOWS THE CURSOR (#314): all of
+// setup's output — prompts that redraw their own line, hints walked back over — went through the
+// transcript, so its moves describe rows the transcript holds. See createTranscript.
+let zoneTookOver = false;
 let _uiDepth = 0;
 let scrollOffset = 0; // lines the view is scrolled BACK from the bottom; 0 = live
 const scrolledBack = () => scrollOffset > 0;
@@ -1046,7 +1047,7 @@ const contentWrite = (raw, chunk, enc, cb) => {
   // Any real output commits a held question first (see pendingEcho above).
   if (_uiDepth === 0 && pendingEcho !== null) flushPendingEcho();
   if (_uiDepth === 0 && (typeof chunk === "string" || Buffer.isBuffer(chunk))) {
-    transcript.append(String(chunk));
+    transcript.append(String(chunk), { followCursor: !zoneTookOver });
     // ALWAYS FOLLOW THE BOTTOM. New output means there is something newer to see, so a view
     // that was scrolled back comes home first and the line lands where the user is looking.
     // Scrolling up is therefore the ONLY way to leave the live tail — which is exactly when the
@@ -1154,7 +1155,12 @@ rl._ttyWrite = (str, key) => {
       ? makePasteToken(trimmed)
       : trimmed.replace(/\n/g, " "); // a short paste stays literal, on one line
     // A paste over a selection REPLACES it, exactly as typing over one does — this runs before
-    // the caret is read, so the insert lands where the removed text was.
+    // the caret is read, so the insert lands where the removed text was. So does a paste over an
+    // untouched default (#314: the trial token, replaced by the person's own).
+    if (untouchedDefault()) {
+      rl.line = "";
+      rl.cursor = 0;
+    }
     dropSelectedInputText();
     // Insert at the caret so a paste mid-sentence lands where the user put it.
     const before = rl.line.slice(0, rl.cursor);
@@ -1235,6 +1241,7 @@ rl._ttyWrite = (str, key) => {
   // ESC CANCELS A TYPED QUESTION. Below the CPR block deliberately: a probe reply also begins
   // with ESC, and testing first would read the terminal's own answer as the user pressing Esc.
   if (maybeCancelPrompt(str, key)) return;
+  if (atomicDefaultKey(str, key)) return;
   // --- a selection on the input line is EDITABLE, not just copyable (task #177) ----------
   // Selecting the line and pressing Backspace is how every text field on the machine clears
   // one, and without it the only way to drop a long question is to hold the key down. Handled
@@ -1956,11 +1963,49 @@ function renderSlashOverlay(sel) {
     slashNeutralizeHistory();
   }
   slashHintRows = menu.length;
+  if (barPinned()) {
+    paintSlashMenuOverConversation(menu);
+    return;
+  }
   regionUi(
     slashOverlaySeq(line, rl.cursor ?? line.length, menu, process.stdout.columns)
   );
 }
 
+/**
+ * WHILE THE ZONE IS PINNED the menu is painted over the conversation's BOTTOM ROWS, just above
+ * the zone, and those rows are put back from the transcript when it closes (#314). It used to be
+ * drawn at the OUTPUT position with an input row of its own (">> /…") — the unpinned layout —
+ * and closing repainted that row and left it there: every /command left an empty ">>" row above
+ * its echo, and /exit left ">>" / ">> /exit" in the shell. The typed line is already in the zone.
+ */
+let slashDrawn = null; // { from, to }: the absolute rows the menu covers
+const conversationRowsSeq = (from, to, width) => {
+  let seq = "";
+  for (let r = from; r <= to; r++) seq += `\x1b[${r};1H\x1b[2K` + clipVisible(viewportRowText(r), width - 1);
+  return seq;
+};
+function paintSlashMenuOverConversation(menu) {
+  const width = Math.max(20, process.stdout.columns || 80);
+  const zoneTop = viewportRows() - barReserved + 1;
+  const rows = menu.slice(0, Math.max(1, zoneTop - 2)).map((r) => GUTTER + clipVisible(r, width - 1 - GUTTER.length));
+  const from = zoneTop - rows.length;
+  let seq = "\x1b[?7l";
+  // a shorter menu than last time: the rows it no longer covers get the conversation back
+  if (slashDrawn && slashDrawn.from < from) seq += conversationRowsSeq(slashDrawn.from, from - 1, width);
+  rows.forEach((r, i) => (seq += `\x1b[${from + i};1H\x1b[2K` + r));
+  ui(seq + "\x1b[?7h");
+  slashDrawn = { from, to: zoneTop - 1 };
+  paintBar(); // the caret back on the input line
+}
+function clearSlashMenuOverConversation() {
+  if (!slashDrawn) return;
+  const width = Math.max(20, process.stdout.columns || 80);
+  ui("\x1b[?7l" + conversationRowsSeq(slashDrawn.from, slashDrawn.to, width) + "\x1b[?7h");
+  slashDrawn = null;
+  if (barPinned()) paintBar();
+}
+
 // Close the overlay: erase the menu below, keep the typed input line, hand drawing back
 // to readline. Callers that changed the line to a non-slash value should refresh after.
 // Relative moves only, for the same reason as above.
@@ -1969,9 +2014,12 @@ function closeSlashOverlay() {
     slashRestoreHistory();
     return;
   }
-  regionUi(
-    slashCloseSeq(rl.line, rl.cursor ?? rl.line.length, process.stdout.columns)
-  );
+  if (slashDrawn) clearSlashMenuOverConversation();
+  else {
+    regionUi(
+      slashCloseSeq(rl.line, rl.cursor ?? rl.line.length, process.stdout.columns)
+    );
+  }
   slashOverlayActive = false;
   slashHintRows = 0;
   slashSel = -1;
@@ -2535,6 +2583,7 @@ const barPinned = () => barReserved > 0;
 /** Reserve the rows (or re-cut them after a resize) and paint the bar into them. */
 function pinBar() {
   if (!canPinBar()) return;
+  zoneTookOver = true;
   const rows = frozenRowCount();
   // Re-cutting keeps the OUTPUT position that is already in the save slot (preserveCaret:false);
   // paintBar() below puts the caret back on the input line.
@@ -4267,12 +4316,35 @@ let askWaiting = false;
  */
 function maybeCancelPrompt(str, key) {
   if (!shouldCancelPrompt(askWaiting, key)) return false;
+  if (askNoCancel) return true; // a question with no way round it (#314): Esc does nothing
   rl.line = "";
   rl.cursor = 0;
   submitSyntheticLine(CANCEL_LINE);
   return true;
 }
-const ask = async (q, { prefill = "", hint = [] } = {}) => {
+// #314: the default typed into an ask() is ONE UNIT while untouched (atomicDefaultKey), and a
+// question may refuse Esc. Both last only for that question.
+let askAtomic = "";
+let askNoCancel = false;
+const untouchedDefault = () => Boolean(askAtomic) && rl.line === askAtomic;
+/**
+ * A key on an untouched default. Backspace / Delete / Ctrl+U / Ctrl+W clear ALL of it — it is a
+ * stand-in (a shortened token), not text to edit a character at a time — and a typed character
+ * replaces it. → true when the key was consumed.
+ */
+function atomicDefaultKey(str, key) {
+  if (!untouchedDefault()) return false;
+  const clears = key?.name === "backspace" || key?.name === "delete" || (key?.ctrl && (key.name === "u" || key.name === "w"));
+  const printable = typeof str === "string" && str.length === 1 && str >= " " && !key?.ctrl && !key?.meta;
+  if (!clears && !printable) return false;
+  rl.line = "";
+  rl.cursor = 0;
+  inputSelection = null;
+  if (!clears) return false; // the character itself is inserted by readline, into the empty line
+  rl._refreshLine();
+  return true;
+}
+const ask = async (q, { prefill = "", hint = [], atomic = false, noCancel = false } = {}) => {
   // Route the question through readline's own prompt so its redraw logic stays
   // consistent (a raw stdout write here would re-create the stale-cursor artifact
   // that terminal:true mode is designed to avoid). Restored to ">> " afterwards.
@@ -4340,6 +4412,8 @@ const ask = async (q, { prefill = "", hint = [] } = {}) => {
     // #305: a default typed in for the person to take (Enter) or delete, and a hint drawn under
     // the input (frozenZone) — both only for this question.
     askHint = hint;
+    askAtomic = atomic ? String(prefill) : "";
+    askNoCancel = noCancel;
     if (prefill) {
       rl.line = String(prefill);
       rl.cursor = rl.line.length;
@@ -4362,6 +4436,8 @@ const ask = async (q, { prefill = "", hint = [] } = {}) => {
     } finally {
       askWaiting = false;
       askHint = [];
+      askAtomic = "";
+      askNoCancel = false;
       inlinePrompt = "";
       inputVisible = wasVisible;
       paintBar(); // put ">> " back, or the next question wears this one's label
@@ -4372,12 +4448,16 @@ const ask = async (q, { prefill = "", hint = [] } = {}) => {
   rl.setPrompt(gutterLines(q));
   rl.prompt();
   if (prefill) rl.write(String(prefill));
+  askAtomic = atomic ? String(prefill) : "";
+  askNoCancel = noCancel;
   let a;
   try {
     askWaiting = true;
     a = await nextLine();
   } finally {
     askWaiting = false;
+    askAtomic = "";
+    askNoCancel = false;
   }
   rl.setPrompt(PROMPT);
   // Esc here too: the unpinned path is what a short window and a piped stdout get, and a cancel
@@ -9915,23 +9995,44 @@ async function ensureTokenForTurn() {
   const dir = join(homedir(), ".gonext");
   const state = await ct.readState(dir);
   if (!ct.turnNeedsToken({ privateMode: true, token: state.token })) return true;
+  // The FALLBACK (#314): the token is normally settled at the first ">>" (askTokenAtStart); this
+  // catches a token that went missing mid-session (removed, or `gu token` pasted a bad one).
+  if (await askForCliToken(ct, dir)) return true;
+  console.log(GUTTER + dim("Not sent. Run `gu token <paste>` any time, then send your message again.") + "\n");
+  return false;
+}
+
+/**
+ * THE TOKEN QUESTION, IN THE INPUT ROW (#305/#76 → #314). "Input token: <the trial token>" stands
+ * where ">> " would, so no question can be typed until there is a token; Enter is the only way on
+ * (Esc does nothing), one Backspace clears the default for a paste, and a valid token turns the
+ * row back into ">> ". → true once a token is saved.
+ */
+async function askForCliToken(ct, dir) {
   console.log("");
-  // #305: the question, with this computer's free trial as the default — offered, never taken
-  // silently (the user's rule). Enter takes the trial; a pasted token replaces it.
   const { DEFAULT_API_BASE } = await import("./device-login.mjs");
   const r = await ct.promptForToken({
-    ask: (label, opts) => ask("  " + label, opts),
+    ask: (label, opts) => ask(label, opts),
     dir,
+    required: true,
     hostedBase: String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE,
     log: (l, kind) =>
       console.log(GUTTER + (kind === "title" ? yellow(l) : kind === "ok" ? accent(l) : kind === "warn" ? yellow(l) : dim(l))),
   });
-  if (r.ok) {
-    console.log("");
-    return true;
-  }
-  console.log(GUTTER + dim("Not sent. Run `gu token <paste>` any time, then send your message again.") + "\n");
-  return false;
+  console.log("");
+  void refreshCliToken(); // the bar's trial line, now that there is a token to describe
+  return r.ok;
+}
+
+/** At the first ">>": private mode with no usable token asks for one first (#314). */
+async function askTokenAtStart() {
+  if (!isClientExpert() || !process.stdin.isTTY) return;
+  const ct = await import("./cli-token.mjs");
+  if (!ct.publicKey()) return;
+  const dir = join(homedir(), ".gonext");
+  const state = await ct.readState(dir);
+  if (!ct.turnNeedsToken({ privateMode: true, token: state.token })) return;
+  await askForCliToken(ct, dir);
 }
 
 async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {}) {
@@ -11454,7 +11555,12 @@ async function main() {
   // The folder's last RAG/context picture, so the bar is populated before the first turn rather
   // than reading `rag 0` — which is indistinguishable from "RAG contributed nothing".
   lastPromptBreakdown = await loadPromptBreakdown(resolve(process.cwd()));
-  await ensureWorkspace();
+  // Esc at "Register it…?" / "Do you trust this folder…?" means "not now" — it used to escape
+  // main() as an unhandled PromptCancelled and end gu on a first install (#314, seen live).
+  const wsCancelled = Symbol("cancelled");
+  if ((await askOr(wsCancelled, () => ensureWorkspace())) === wsCancelled) {
+    console.log(GUTTER + dim("Skipped — this folder is not registered; the agent will not touch files here. Run gu again to be asked."));
+  }
   // Restore this folder's remembered auto-test + deploy-target so the banner + agent-ask
   // reflect them (both survive a fresh terminal in the same project).
   sessionTestAuto = await loadSessionTestAuto(resolve(process.cwd()));
@@ -12135,6 +12241,13 @@ async function main() {
   // rows it pushes up are real output rather than half-drawn setup.
   syncBarPinning();
 
+  // #314: private mode with no token — the input row asks for one BEFORE the first ">> ".
+  try {
+    await askTokenAtStart();
+  } catch (e) {
+    console.log(GUTTER + dim(`(the gu token question failed: ${e?.message ?? e} — gu token <paste> adds one)`));
+  }
+
   // #301: setup's "Load a saved preset" — the picker opens now that the terminal exists. The whole
   // /load-presets flow (the list, the plan, the confirmation, the key) is that command's own.
   if (openPresetsAtStart) {
@@ -12767,9 +12880,23 @@ async function main() {
       });
     }
   }
-  unpinBar(); // give the reserved rows and the scrolling region back to the shell (#141)
+  releaseScreenAtExit();
   rl.close();
   process.exit(0);
 }
 
+/**
+ * Give the screen back to the shell with its prompt RIGHT UNDER the last output (#314). unpinBar()
+ * parks the caret at the zone's top row, which is where the shell then printed its prompt: seven
+ * blank rows below the conversation on an 80×24 window. The output position is in the save slot,
+ * so go there instead, and clear the zone's rows below it.
+ */
+function releaseScreenAtExit() {
+  if (!barPinned()) return;
+  barReserved = 0;
+  const lines = transcript.lines();
+  const midLine = (lines[lines.length - 1] ?? "") !== "";
+  ui("\x1b[r" + OUT_RESTORE + (midLine ? "\r\n" : "\r") + "\x1b[J");
+}
+
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.775",
+  "version": "1.0.777",
   "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/setup-prompts.mjs

@@ -16,39 +16,23 @@
  * the one stretch of the program that runs before it.
  */
 import { SKIP_ALL, isEscapeKey } from "./model-setup-ui.mjs";
-import { footerDrawSeq, visibleLen, hintRows } from "./terminal-layout.mjs";
 
 /**
  * One question on `rl`. Options: `secret` (mask + keep out of history), `esc` (Esc → SKIP_ALL).
- * `style` decorates the label (the accent colour). `prefill` is typed into the input for the
- * person to take with Enter or delete (#305); `hint` is lines drawn in yellow UNDER the input,
- * word-wrapped to one physical row each (terminal-layout hintRows), and wiped once answered.
- * Resolves with the answer string, or SKIP_ALL.
+ * `style` decorates the label (the accent colour). Resolves with the answer string, or SKIP_ALL.
  */
-export function askOn(rl, q, { secret = false, esc = false, style = (s) => s, prefill = "", hint = [], input = process.stdin, output = process.stdout } = {}) {
+export function askOn(rl, q, { secret = false, esc = false, style = (s) => s, input = process.stdin, output = process.stdout } = {}) {
   return new Promise((resolve) => {
     const shown = style(q);
     const ac = new AbortController();
     const origWrite = rl._writeToOutput;
     const origRefresh = rl._refreshLine;
     let done = false;
-    const showHint = !secret && hint.length > 0 && output.isTTY;
-    // Drawn below the input's LAST row with relative moves (footerDrawSeq), so it survives the
-    // terminal scrolling; redrawn after every key because readline clears below on a refresh.
-    const drawHint = () => {
-      const cols = Math.max(20, output.columns || 80);
-      const pos = rl.getCursorPos?.() ?? { rows: 0, cols: 0 };
-      const inputRows = Math.floor((visibleLen(shown) + String(rl.line ?? "").length) / cols) + 1;
-      const rows = hintRows(hint, { width: cols, gutter: "  ", paint: (t) => `\x1b[33m${t}\x1b[0m` });
-      output.write(footerDrawSeq({ rows, caretRows: pos.rows, caretCols: pos.cols, inputRows }));
-    };
 
     const finish = (value) => {
       if (done) return;
       done = true;
       input.removeListener?.("keypress", onKey);
-      // Enter left the caret on the first hint row: the hint goes with the question.
-      if (showHint && value !== SKIP_ALL) output.write("\r\x1b[J");
       if (secret) {
         rl._writeToOutput = origWrite;
         rl._refreshLine = origRefresh;
@@ -76,14 +60,11 @@ export function askOn(rl, q, { secret = false, esc = false, style = (s) => s, pr
       if (secret && output.isTTY) {
         output.write(`\r\x1b[2K${shown}${"•".repeat(String(rl.line ?? "").length)}`);
       }
-      if (showHint) drawHint();
     }
 
     input.on?.("keypress", onKey);
     // question() draws the label synchronously — mute only AFTER, or the label is muted too.
     rl.question(shown, { signal: ac.signal }, (a) => finish(String(a ?? "")));
-    if (prefill && !secret) rl.write(String(prefill));
-    if (showHint) drawHint();
     if (secret) {
       rl._writeToOutput = () => {};
       rl._refreshLine = () => {};

package/terminal-viewport.mjs

@@ -40,23 +40,94 @@ export function createTranscript({ max = 20000 } = {}) {
   /** @type {string[]} */
   let lines = [""];
   let total = 0; // lines that have scrolled out of the buffer, so line numbers stay meaningful
+  // The line being written, for FOLLOW-THE-CURSOR appends (below). Ordinary appends always write
+  // at the end and leave it there.
+  let cur = 0;
+  let saved = 0;
 
   const trim = () => {
     if (lines.length <= max) return;
     const drop = lines.length - max;
     lines = lines.slice(drop);
     total += drop;
+    cur = Math.max(0, cur - drop);
+    saved = Math.max(0, saved - drop);
+  };
+
+  /**
+   * FOLLOW THE CURSOR (#314). Before gu's frozen zone takes the screen, everything on it was
+   * printed through here — setup's readline prompts, which redraw their line (ESC[1G + the line
+   * again) on an edit; hints drawn under a prompt and walked back over (ESC[nA); progress rows.
+   * Stripping those moves recorded the same prompt twice and hint rows in the wrong place, so the
+   * first repaint from the transcript (the zone changing height) showed a DIFFERENT screen: lines
+   * gone from the setup output, the banner drawn twice. Line-level moves are followed instead:
+   * up/down, column 1 (= rewrite the line), erase line/below, save/restore. Not used once the
+   * zone is up: from then on in-place UI is drawn outside the transcript (ui()), and a relative
+   * move in later content refers to rows the transcript never saw.
+   */
+  const TOKEN = /\x1b\[([0-9;?]*)([A-Za-z])|\x1b([78])|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\r|\n|\x1b|[^\x1b\r\n]+/g;
+  // At column 0 (after \r, \n or ESC[1G): text written now REPLACES the line, the way it
+  // overwrites it on screen — but a \r alone erases nothing (readline's Enter is "\r\n").
+  let col0 = true;
+  const appendFollowing = (raw) => {
+    let m;
+    TOKEN.lastIndex = 0;
+    while ((m = TOKEN.exec(raw))) {
+      const [tok, params, final, decsc] = m;
+      if (final) {
+        const n = Math.max(1, parseInt(params, 10) || 1);
+        if (final === "m") lines[cur] += tok; // colour stays
+        else if (final === "A") cur = Math.max(0, cur - n);
+        else if (final === "B") {
+          cur += n;
+          while (cur >= lines.length) lines.push("");
+        } else if (final === "G" && n <= 1) col0 = true;
+        else if (final === "K" && (params === "2" || col0)) lines[cur] = "";
+        else if (final === "J" && (params === "" || params === "0")) {
+          lines.length = cur + 1;
+          if (col0) lines[cur] = "";
+        }
+        // anything else (column moves, show/hide cursor, modes) changes no line
+      } else if (decsc === "7") saved = cur;
+      else if (decsc === "8") cur = Math.min(saved, lines.length - 1);
+      else if (tok === "\n") {
+        cur += 1;
+        if (cur >= lines.length) lines.push("");
+        col0 = true;
+      } else if (tok === "\r") col0 = true;
+      else if (tok[0] !== "\x1b") {
+        if (col0) lines[cur] = "";
+        col0 = false;
+        lines[cur] += tok;
+      }
+    }
   };
 
   return {
-    append(text) {
+    /** `followCursor`: see appendFollowing — only for output printed before the zone is up. */
+    append(text, { followCursor = false } = {}) {
+      if (followCursor) {
+        appendFollowing(String(text ?? ""));
+        trim();
+        return;
+      }
       const s = sanitize(text ?? "");
       if (!s) return;
+      cur = lines.length - 1;
+      // A \r REWRITES the line only when text follows it: "\r\n" (CRLF output, readline's Enter)
+      // ends the line and keeps it — erasing on the \r itself blanked every such line.
       for (const ch of s) {
-        if (ch === "\n") lines.push("");
-        else if (ch === "\r") lines[lines.length - 1] = "";
-        else lines[lines.length - 1] += ch;
+        if (ch === "\n") {
+          lines.push("");
+          col0 = true;
+        } else if (ch === "\r") col0 = true;
+        else {
+          if (col0) lines[lines.length - 1] = "";
+          col0 = false;
+          lines[lines.length - 1] += ch;
+        }
       }
+      cur = lines.length - 1;
       trim();
     },
     /** All lines, oldest first. The last one may still be open (no newline yet). */
@@ -82,6 +153,8 @@ export function createTranscript({ max = 20000 } = {}) {
     clear() {
       lines = [""];
       total = 0;
+      cur = 0;
+      saved = 0;
     },
   };
 }