@tiens.nguyen/gu-cli 1.0.774 → 1.0.776

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

@@ -185,6 +185,90 @@ export function trialStartedLine(endsAt, site = DEFAULT_SITE) {
     `Then get a free token for 1 computer at ${accountUrl} — gu token <paste> links it.`;
 }
 
+/**
+ * How the trial token is shown in the input: its ends, with "…" between (a whole token is ~520
+ * characters — five rows of input). Only ever compared, never saved: the real token is kept aside.
+ */
+export function shortToken(token) {
+  const t = String(token ?? "");
+  return t.length <= 24 ? t : `${t.slice(0, 16)}…${t.slice(-6)}`;
+}
+
+/**
+ * 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.
+ *
+ * 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({
+  ask,
+  dir,
+  log = (l) => console.log(l),
+  hostedBase,
+  site = siteUrl(),
+  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 getOne = `For a free token for 1 computer, log in at ${accountUrl} and create one — or buy Pro there for more computers.`;
+  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");
+  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");
+      return { ok: true, kind: "trial" };
+    }
+    const saved = await saveTokenFromPaste(dir, typed, publicKeyB64);
+    if (saved.ok) {
+      log("✓ token saved — it renews itself from now on.", "ok");
+      return { ok: true, kind: "pasted" };
+    }
+    log(`That token was not saved: ${saved.reason}.`, "warn");
+  }
+  return { ok: false, why: "refused" };
+}
+
 /** What renewals send about this computer. The raw OS id never leaves the machine — only a salted hash. */
 export async function thisDevice({ platform = process.platform, hostName = osHostname(), machineId, instanceId } = {}) {
   const raw = machineId ?? (await osMachineId({ platform }));

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

@@ -98,6 +98,7 @@ import {
   inputPhysicalRows,
   buildFooterRows,
   pasteHint,
+  hintRows as questionHintRows,
   footerDrawSeq,
   footerEraseSeq,
   clearBlockSeq,
@@ -879,8 +880,8 @@ const COMMANDS = [
   // object {apiUrl, apiKey, agentModel, codingModel, embedModel} and validates every field
   // before writing. A preset file HOLDS its API key (0600, home folder — the settings files'
   // location), so it is marked "gu": "preset" and the two commands never offer each other's files.
-  { name: "/save-preset", usage: '/save-preset <name> {"apiUrl":"…","apiKey":"…","agentModel":"…","codingModel":"…","embedModel":"…"}', desc: "save a named preset: server, API key and the agent/coding/embedding models, all validated — same home folder as settings files" },
-  { name: "/load-presets", usage: "/load-presets [name]", desc: "pick a saved preset (arrow keys) and put it back — server, both models, embedder and its key; asks before it replaces anything" },
+  { name: "/save-preset", usage: "/save-preset <name> [{json}]", desc: "save a named preset — server, API key and the agent/coding/embedding models — in your editor ($EDITOR, nano…), or as one line of JSON; all validated" },
+  { name: "/load-presets", usage: "/load-presets [name]", desc: "pick a saved preset: Enter applies it (asks first) · v view · c copy as a command · j copy JSON · e edit" },
   { name: "/doctor", desc: "check every configured model ANSWERS — especially the embedder, which a turn only reaches after several steps" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
   // ONE name, /new (user, #278). /reset and /clear still work (HIDDEN_COMMANDS) for habit and
@@ -969,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;
@@ -1042,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
@@ -1150,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);
@@ -1231,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
@@ -1477,6 +1488,7 @@ function applyClick({ row, col }) {
     // A click in the SCROLLING area is not aimed at the caret — it may be aimed at a thought
     // block asking to be opened (task #148). Checked before the input-row test so the two
     // never compete for the same event.
+    if (!onInputRow(row) && clickCopyButton(row, col)) return;
     if (!onInputRow(row) && toggleThoughtAtRow(row)) return;
     if (!onInputRow(row) || !clickOffsetAt) return;
     rl.cursor = clickOffsetAt(inputRowIndex(row), col);
@@ -1951,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.
@@ -1964,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;
@@ -2186,31 +2239,6 @@ let startupRenewDone = false;
 let licenceBlock = null;
 let licenceDecided = false;
 
-/**
- * THE FREE TRIAL (#305): a first install gets ten days on this computer instead of a "paste your
- * token" stop. Once per computer — the gu service decides, keyed on the OS machine id's hash. → true
- * when a trial token is now saved. Tried at most once per start by the startup refresh, and again
- * right before the token question (a first start may have been offline).
- */
-let trialTried = false;
-let trialEndedAt = ""; // this computer's trial has ended — the token question says so
-async function tryTrialToken(ct, dir, { announce = true } = {}) {
-  const device = await ct.trialDevice().catch(() => null);
-  if (!device) return false; // no stable machine id → no trial (see trialDevice)
-  const { DEFAULT_API_BASE } = await import("./device-login.mjs");
-  const hostedBase = String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE;
-  const r = await ct.claimTrial({ hostedBase, device });
-  if (r.ok && ct.verifyCliToken(r.token, ct.publicKey()).ok) {
-    await ct.writeState(dir, { token: r.token, lastAttemptAt: new Date().toISOString() });
-    if (announce) {
-      console.log(GUTTER + accent(r.created ? ct.trialStartedLine(r.endsAt, ct.siteUrl()) : `Free trial on this computer until ${ct.shortDate(r.endsAt)}.`));
-    }
-    return true;
-  }
-  if (r.why === "used" && r.endedAt) trialEndedAt = r.endedAt;
-  return false;
-}
-
 async function refreshCliToken() {
   if (tokenBusy) return;
   tokenBusy = true;
@@ -2225,11 +2253,6 @@ async function refreshCliToken() {
     const mode = isClientExpert() ? "expert" : "client";
     const site = ct.siteUrl();
     let state = await ct.readState(dir);
-    // #305: private mode with no usable token → this computer's free trial, before anything asks.
-    if (mode === "expert" && !trialTried && !(state.token && ct.verifyCliToken(state.token, pk).ok)) {
-      trialTried = true;
-      if (await tryTrialToken(ct, dir)) state = await ct.readState(dir);
-    }
     const now = new Date();
     const noticeNow = () =>
       ct.barNotice({ token: state.token, publicKeyB64: pk, mode, now: new Date(), attempted: Boolean(state.lastAttemptAt), site });
@@ -2511,6 +2534,9 @@ const footerRows = () =>
     // Task #14: the skipped-setup warning — persistent (not a timed notice), red, its own row.
     missing: missingNoticeText() ? red(missingNoticeText()) : "",
   });
+// An ask()'s hint lines (#305), drawn in yellow under its input while it waits. Plain text.
+let askHint = [];
+const askHintRows = (width) => questionHintRows(askHint, { width, gutter: GUTTER, paint: yellow });
 // True only while the MAIN loop's ">> " prompt is waiting for input. The bar belongs to that
 // prompt, so it must never appear under an ask()/askSecret() question or during a turn.
 let footerActive = false;
@@ -2557,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.
@@ -2652,7 +2679,7 @@ function frozenZone() {
     selection: secretInput ? null : inputSelection,
     highlight: highlightRow,
   });
-  const rows = status.concat(zone.rows, footerRows());
+  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.
@@ -2787,7 +2814,7 @@ let inputSelection = null;
  */
 const maxInputRows = () => {
   const MIN_VIEW = 4;
-  const spare = viewportRows() - footerRows().length - INPUT_HEAD_ROWS - MIN_VIEW;
+  const spare = viewportRows() - footerRows().length - askHintRows(process.stdout.columns || 80).length - INPUT_HEAD_ROWS - MIN_VIEW;
   return Math.max(1, Math.min(10, spare));
 };
 /**
@@ -3149,7 +3176,7 @@ async function copyAtRow(row) {
  * `trailingBlanks` is how many blank lines the write left BELOW the block — see
  * registeredRange, where getting it wrong silently shifts the whole range by one.
  */
-function registerCopyBlock(rowCount, text, trailingBlanks = 0) {
+function registerCopyBlock(rowCount, text, trailingBlanks = 0, extra = {}) {
   if (!rowCount || !String(text ?? "").trim()) return;
   const { from, to } = registeredRange({
     dropped: transcript.dropped(),
@@ -3157,7 +3184,9 @@ function registerCopyBlock(rowCount, text, trailingBlanks = 0) {
     rowCount,
     trailingBlanks,
   });
-  copyBlocks.push({ from, to, text: String(text) });
+  // `extra.button` = { from, to } columns on the block's FIRST row that copy on a single click
+  // (the preset block's "⧉ copy", #312); `extra.note` is the badge it shows.
+  copyBlocks.push({ from, to, text: String(text), ...extra });
   if (copyBlocks.length > 200) copyBlocks = copyBlocks.slice(-200);
 }
 
@@ -3397,6 +3426,30 @@ function paintCopyBadge(row, place, ok = true) {
   }, 2000);
 }
 
+/**
+ * A single click on a block's "⧉ copy" (#312) → copy its source text. → true when the click was
+ * on a button (handled), false to let the click do whatever else it does.
+ */
+function clickCopyButton(row, col) {
+  if (!barPinned() || !copyBlocks.length) return false;
+  const width = Math.max(20, process.stdout.columns || 80) - 1;
+  const owners = displayRowOwners(transcript.lines(), width);
+  const logical = lineAtViewportRow(owners, row, transcriptRows(), scrollOffset);
+  if (logical < 0) return false;
+  const abs = transcript.dropped() + logical;
+  const b = blockAt(copyBlocks, abs);
+  if (!b?.button || abs !== b.from || col - 1 < b.button.from || col - 1 >= b.button.to) return false;
+  void (async () => {
+    try {
+      const res = await writeClipboard(b.text);
+      showCopyBadge(row, res.ok ? b.note || "copied" : copyBadge({ ok: false, why: res.why }), res.ok);
+    } catch {
+      /* a failed copy must never take the session down */
+    }
+  })();
+  return true;
+}
+
 function copyTargetAtRow(row) {
   if (!barPinned()) return null;
   const width = Math.max(20, process.stdout.columns || 80) - 1;
@@ -4263,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) => {
+// #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.
@@ -4333,6 +4409,15 @@ const ask = async (q) => {
     // the turn's empty-prompt behaviour must come back.
     const wasVisible = inputVisible;
     inputVisible = true;
+    // #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;
+    }
     // ELLIPSIS, so a truncation is VISIBLE. Silently cutting "…[https://ollama2.gomarsic.cc/v1]:"
     // to "…[https:/" hides the default Enter would accept, which is worse than not showing it —
     // the reader cannot tell whether the value is short or the row lied. Callers should keep the
@@ -4350,19 +4435,29 @@ const ask = async (q) => {
       return (a ?? "").trim();
     } finally {
       askWaiting = false;
+      askHint = [];
+      askAtomic = "";
+      askNoCancel = false;
       inlinePrompt = "";
       inputVisible = wasVisible;
       paintBar(); // put ">> " back, or the next question wears this one's label
     }
   }
+  // Unpinned (piped output, a short window): no frozen zone to draw under, so the hint goes above.
+  for (const l of hint) console.log(GUTTER + yellow(l));
   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
@@ -6712,24 +6807,70 @@ function settingsArg(line, word) {
 }
 
 /**
- * /save-preset <name> <json> — the user TYPES the preset (#6): a name and a JSON object with
- * apiUrl, apiKey, agentModel, codingModel and embedModel, all validated before anything is
- * written. Unlike /save-settings (which snapshots the account and refuses secrets), a preset
- * SAVES the API key by design — it is the "this exact setup, one command" file, stored 0600 in
- * the same home-folder location as settings files, marked "gu": "preset" so the two commands
- * never offer each other's files.
+ * Give the terminal to a full-screen program (an editor, #312) and take it back afterwards.
+ *
+ * gu owns the screen while it runs: a pinned frozen zone (DECSTBM), raw mode, mouse reporting and
+ * bracketed paste. An editor started on top of that would get gu's scroll region and mouse bytes,
+ * and gu's readline would keep reading the keys meant for the editor. Everything is switched off
+ * first and switched back on — and the view repainted from the transcript — whatever happens.
+ */
+function withTerminalHandedOver(run) {
+  const wasPinned = barPinned();
+  const hadClick = _clickEnabled;
+  disableMouse();
+  disableClickToPosition();
+  ui(PASTE_MODE_OFF);
+  unpinBar();
+  const wasRaw = Boolean(process.stdin.isRaw);
+  try {
+    process.stdin.setRawMode?.(false);
+  } catch {
+    /* not a TTY — nothing to switch */
+  }
+  rl.pause();
+  try {
+    return run();
+  } finally {
+    try {
+      process.stdin.setRawMode?.(wasRaw);
+    } catch {
+      /* not a TTY */
+    }
+    rl.resume();
+    ui(PASTE_MODE_ON);
+    if (hadClick) enableClickToPosition();
+    if (wasPinned) {
+      ui("\x1b[2J");
+      pinBar();
+      paintLiveTail();
+    }
+  }
+}
+
+/**
+ * /save-preset <name> — THE PRESET IN AN EDITOR (#312). Opens $VISUAL / $EDITOR / nano / vi
+ * (Notepad on Windows) on a temp file filled in with the preset being edited or the current
+ * setup; save and quit stores it, quit without a change cancels. A wrong value is named and the
+ * editor reopens with the person's OWN text, never the template again.
+ *
+ * /save-preset <name> <json> — the one-line form (#6), kept for scripts and for pasting the
+ * command /load-presets copies. Both validate everything before a byte is written. A preset SAVES
+ * the API key by design (unlike /save-settings) — stored 0600 in the home folder, marked
+ * "gu": "preset" so the two commands never offer each other's files.
  */
 async function runSavePresetCommand(line) {
   const pr = await import("./presets-transfer.mjs");
   const home = homedir();
   console.log("");
-  const usage =
-    'usage: /save-preset <name> {"apiUrl":"https://…","apiKey":"…","agentModel":"…","codingModel":"…","embedModel":"…"}  (embedUrl optional)';
-  const rest = line.trim().slice("/save-preset".length).trim();
+  const usage = "usage: /save-preset <name>  (opens your editor)   or   /save-preset <name> {\"apiUrl\":\"…\",\"apiKey\":\"…\",\"agentModel\":\"…\",\"codingModel\":\"…\",\"embedModel\":\"…\"}";
+  let rest = line.trim().slice("/save-preset".length).trim().replace(/(^|\s)--edit(?=\s|$)/, " ").trim();
   if (!rest) {
-    console.log(GUTTER + usage);
-    console.log("");
-    return;
+    const typed = String((await ask("preset name: ")) ?? "").trim();
+    if (!typed) {
+      console.log(GUTTER + dim("cancelled — nothing saved.") + "\n");
+      return;
+    }
+    rest = typed;
   }
   const space = rest.search(/\s/);
   const name = space === -1 ? rest : rest.slice(0, space);
@@ -6739,22 +6880,68 @@ async function runSavePresetCommand(line) {
     console.log("");
     return;
   }
-  if (!json) {
-    console.log(GUTTER + "the JSON is missing — " + usage);
+  const file = pr.presetFilePath(name, home);
+  const store = (preset) => {
+    writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
+    console.log(GUTTER + `Preset "${name}" saved to ${file}`);
+    console.log(GUTTER + dim("server + api key + agent, coding and embedding models — the key is IN this file, keep it private."));
     console.log("");
+  };
+  if (json) {
+    const checked = pr.validatePreset(json);
+    if (!checked.ok) {
+      console.log(GUTTER + `Preset not saved — ${checked.problem}`);
+      console.log("");
+      return;
+    }
+    store(checked.preset);
     return;
   }
-  const checked = pr.validatePreset(json);
-  if (!checked.ok) {
-    console.log(GUTTER + `Preset not saved — ${checked.problem}`);
+
+  // THE EDITOR. Filled in from the preset being edited, else from what this account runs now.
+  const ed = await import("./preset-editor.mjs");
+  const editor = ed.pickEditor();
+  if (!editor || !process.stdin.isTTY) {
+    console.log(GUTTER + (editor ? "an editor needs a terminal — " : "no editor found (set $EDITOR, e.g. export EDITOR=nano) — ") + usage);
     console.log("");
     return;
   }
-  const file = pr.presetFilePath(name, home);
-  writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset: checked.preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
-  console.log(GUTTER + `Preset "${name}" saved to ${file}`);
-  console.log(GUTTER + dim("server + api key + agent, coding and embedding models — the key is IN this file, keep it private."));
-  console.log("");
+  let start = null;
+  if (existsSync(file)) {
+    try {
+      const doc = JSON.parse(readFileSync(file, "utf8"));
+      if (doc?.gu === "preset") start = doc;
+    } catch {
+      /* unreadable — start from the current setup instead */
+    }
+  }
+  if (!start) start = ed.presetFromSettings((await fetchWorkerSettings()) ?? {});
+  const initial = ed.editorText(name, start);
+  console.log(GUTTER + dim(`${start.gu ? "editing" : "new"} preset "${name}" in ${basename(editor.cmd)} — save and quit to store it, quit without changes to cancel.`));
+  let text = initial;
+  for (;;) {
+    const r = withTerminalHandedOver(() => ed.editText(text, { editor, fileName: `${name}.json` }));
+    if (!r.ok) {
+      console.log(GUTTER + `Preset not saved — ${r.why}.`);
+      console.log("");
+      return;
+    }
+    if (r.text === initial) {
+      console.log(GUTTER + dim("Not saved — nothing changed.") + "\n");
+      return;
+    }
+    const parsed = ed.parseEdited(r.text);
+    if (parsed.ok) {
+      store(parsed.preset);
+      return;
+    }
+    console.log(GUTTER + yellow(`Not saved yet — ${parsed.problem}`));
+    if (!(await askYesNo("Edit again?", true))) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
+      return;
+    }
+    text = r.text; // their text, with the mistake in it — not the template again
+  }
 }
 
 /**
@@ -6887,26 +7074,61 @@ async function runLoadPresetsCommand(line) {
       return;
     }
   } else {
+    // THE PICKER DOES MORE THAN APPLY (#312): v shows the whole preset (key masked) with a
+    // clickable "⧉ copy", c / j copy it as the /save-preset command or as JSON (key included), e
+    // opens it in the editor. Only Enter applies. Each of the others ENDS the command: the mouse
+    // is gu's only at the ">> " prompt (never while a picker is up), so a "⧉ copy" printed under a
+    // picker that stayed open could not be clicked until it closed.
+    const ed = await import("./preset-editor.mjs");
     const found = pr.presetFilesIn(listJsonFiles(home));
     if (found.length === 0) {
-      console.log(GUTTER + `no presets in ${home} — save one with /save-preset <name> {…}`);
+      console.log(GUTTER + `no presets in ${home} — save one with /save-preset <name>`);
       console.log("");
       return;
     }
-    let pick;
-    if (found.length === 1) {
-      pick = 0;
-      console.log(GUTTER + `one preset here: ${found[0]}`);
-    } else {
-      console.log(dim(`  Presets in ${home}  (${PICK_HINT}):`));
-      pick = await pickFromList(found.map((n) => ({ label: n })));
-    }
-    if (pick < 0) {
+    console.log(dim(`  Presets in ${home}  (${ed.PICKER_HINT}):`));
+    const pick = await pickFromList(found, 0, { keys: ed.PICKER_KEYS });
+    if (!pick || pick.index < 0) {
       console.log(GUTTER + "load cancelled.");
       console.log("");
       return;
     }
-    file = pr.presetFilePath(found[pick], home);
+    file = pr.presetFilePath(found[pick.index], home);
+    if (pick.action === "edit") {
+      await runSavePresetCommand(`/save-preset ${found[pick.index]}`);
+      return;
+    }
+    if (pick.action !== "select") {
+      const shown = pr.validatePresetFile(readFileSync(file, "utf8"));
+      if (!shown.ok) {
+        console.log(GUTTER + `Can't show it — ${shown.problem}`);
+        console.log("");
+        return;
+      }
+      const pname = shown.name || found[pick.index];
+      const command = ed.presetCopyCommand(pname, shown.preset);
+      if (pick.action === "view") {
+        const block = ed.presetBlock(pname, shown.preset, { width: process.stdout.columns || 80, gutter: GUTTER });
+        const [top, ...restRows] = block.rows;
+        const cut = block.button.from;
+        console.log(dim(top.slice(0, cut)) + accent(top.slice(cut, block.button.to)) + dim(top.slice(block.button.to)));
+        for (const r of restRows) console.log(r);
+        registerCopyBlock(block.rows.length, command, 0, { button: block.button, note: "✓ copied — includes the API key" });
+        console.log(GUTTER + dim("click ⧉ copy for a /save-preset command to paste anywhere — it includes the real key."));
+        console.log(GUTTER + dim(`/load-presets ${pname} applies it.`));
+        console.log("");
+        return;
+      }
+      const res = await writeClipboard(pick.action === "json" ? ed.presetCopyJson(shown.preset) : command);
+      console.log(
+        GUTTER +
+          (res.ok
+            ? accent(`✓ copied ${pick.action === "json" ? "the JSON" : "the /save-preset command"} for "${pname}" — includes the API key.`)
+            : yellow(`couldn't copy (${res.why}) — the preset is in ${file}.`))
+      );
+      console.log("");
+      return;
+    }
   }
   const checked = pr.validatePresetFile(readFileSync(file, "utf8"));
   if (!checked.ok) {
@@ -9148,6 +9370,10 @@ let listAllowDelete = false;
 // Set by the ctrl+d branch and read by finishList, so the resolved value can say WHICH action
 // happened rather than encoding it into the index and hoping every caller decodes it.
 let listDeleteRequested = false;
+// Single letters that finish a single-select picker with an ACTION on the highlighted row, e.g.
+// /load-presets' { v: "view", c: "copy" } (#312). Null unless a caller asks, like ctrl+d above.
+let listKeys = null;
+let listKeyAction = "";
 function drawList(redraw) {
   // Gutter (task #128 Phase 2): inset each row after its line-clear. Clipped to width-1 like
   // every other in-place block: a long item (a model id on a narrow terminal) that wrapped
@@ -9210,6 +9436,10 @@ function finishList(index) {
   const deleting = listDeleteRequested;
   listAllowDelete = false;
   listDeleteRequested = false;
+  const keyed = listKeys;
+  const keyAction = listKeyAction;
+  listKeys = null;
+  listKeyAction = "";
   // Multi-select resolves with the TICKED indices — and with null, not [], when cancelled: an
   // empty selection is a legitimate answer ("offer none of them"), so it must be distinguishable
   // from Escape, or cancelling would silently save "none".
@@ -9223,7 +9453,9 @@ function finishList(index) {
           : checked
         : allowDelete
           ? { index, action: index >= 0 && deleting ? "delete" : "select" }
-          : index
+          : keyed
+            ? { index, action: index >= 0 ? keyAction || "select" : "cancel" }
+            : index
     );
   }
 }
@@ -9278,6 +9510,9 @@ function onListKey(key) {
     // Enter still selects; nothing about the ordinary path changes.
     listDeleteRequested = true;
     finishList(listSel);
+  } else if (listKeys && !listMulti && !key.ctrl && !key.meta && key.name && Object.hasOwn(listKeys, key.name)) {
+    listKeyAction = listKeys[key.name];
+    finishList(listSel);
   } else if (key.name === "return" || key.name === "enter") {
     finishList(listSel);
   } else if (key.name === "escape" || (key.ctrl && key.name === "c")) {
@@ -9322,6 +9557,8 @@ function pickFromList(items, initialSel = 0, opts = {}) {
     listMulti = false; // explicit: a cancelled multi-select must not leak its mode into this one
     listAllowDelete = opts.allowDelete === true;
     listDeleteRequested = false;
+    listKeys = opts.keys && typeof opts.keys === "object" ? opts.keys : null;
+    listKeyAction = "";
     listChecked = new Set();
     listItems = items;
     listTop = 0;
@@ -9758,31 +9995,46 @@ async function ensureTokenForTurn() {
   const dir = join(homedir(), ".gonext");
   const state = await ct.readState(dir);
   if (!ct.turnNeedsToken({ privateMode: true, token: state.token })) return true;
-  console.log("");
-  // #305: the free trial first — a first start that was offline gets it here, with no question.
-  if (await tryTrialToken(ct, dir)) {
-    console.log("");
-    return true;
-  }
-  if (trialEndedAt) console.log(GUTTER + dim(`The free trial on this computer ended on ${ct.shortDate(trialEndedAt)}.`));
-  for (const l of ct.tokenAskLines()) console.log(GUTTER + (l.startsWith("  ") ? dim(l) : yellow(l)));
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const pasted = String((await ask("  gu token: ")) ?? "").trim();
-    if (!pasted) {
-      console.log(GUTTER + dim("Not sent. Run `gu token <paste>` any time, then send your message again.") + "\n");
-      return false;
-    }
-    const saved = await ct.saveTokenFromPaste(dir, pasted);
-    if (saved.ok) {
-      console.log(GUTTER + accent("✓ token saved") + dim(" — it renews itself from now on.") + "\n");
-      return true;
-    }
-    console.log(GUTTER + yellow(`That token was not saved: ${saved.reason}.`));
-  }
+  // 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("");
+  const { DEFAULT_API_BASE } = await import("./device-login.mjs");
+  const r = await ct.promptForToken({
+    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))),
+  });
+  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 } = {}) {
   // #238: when the licence is ENFORCED and this account is not entitled, no turn is sent. Decided at
   // startup (see licenceBlock) — never re-checked here, so a turn cannot die halfway through.
@@ -11303,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()));
@@ -11984,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) {
@@ -12616,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.774",
+  "version": "1.0.776",
   "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",
@@ -65,6 +65,7 @@
     "credential-recovery.mjs",
     "settings-transfer.mjs",
     "presets-transfer.mjs",
+    "preset-editor.mjs",
     "device-login.mjs",
     "daemon-control.mjs",
     "log-policy.mjs",

package/preset-editor.mjs

@@ -0,0 +1,187 @@
+/**
+ * PRESETS IN A REAL EDITOR, AND OUT AGAIN AS TEXT (#312).
+ *
+ * Asked for: "it doesn't allow to input the presets as a text editor, we need to allow with
+ * something like sudo nano … and for load-preset should load all as a long text somehow so that
+ * I can copy with a copy button or icon".
+ *
+ *   · /save-preset <name> opens the person's own editor ($VISUAL, $EDITOR, then nano, then vi;
+ *     Notepad on Windows) on a temp file already filled in — the current setup, or the preset
+ *     being edited — so it is edited rather than typed from nothing. NOT sudo: the preset is the
+ *     user's own 0600 file; root would make it root-owned and ask for a password for nothing.
+ *   · The temp file holds a live key: it is created 0600 inside a private 0700 directory and the
+ *     directory is removed on every path out, a Ctrl+C included.
+ *   · /load-presets can show a preset as one framed block — the key MASKED on screen (scrollback
+ *     and logs must not keep it, #248) — and copy it with the real key: as the ready-to-paste
+ *     `/save-preset <name> {…}` command (paste it into gu on another computer and it is there),
+ *     or as plain JSON.
+ *
+ * Pure helpers plus one spawn; the terminal hand-over (unpinning gu's frozen zone, raw mode, the
+ * mouse) is the REPL's job, because only the REPL knows what it switched on.
+ */
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { validatePreset } from "./presets-transfer.mjs";
+
+const clean = (v) => (typeof v === "string" ? v.trim() : "");
+
+/**
+ * Which editor to run → { cmd, args }. $VISUAL then $EDITOR (either may carry arguments, e.g.
+ * "code --wait"), then the first of nano / vi that exists; Notepad on Windows, which blocks until
+ * its window closes. `has(cmd)` says whether a program is on PATH (injected for tests).
+ */
+export function pickEditor({ env = process.env, platform = process.platform, has = onPath } = {}) {
+  for (const v of [env.VISUAL, env.EDITOR]) {
+    const words = splitCommand(v);
+    if (words.length) return { cmd: words[0], args: words.slice(1) };
+  }
+  if (platform === "win32") return { cmd: "notepad", args: [] };
+  for (const cmd of ["nano", "vi"]) if (has(cmd)) return { cmd, args: [] };
+  return null;
+}
+
+/** "code --wait" → ["code", "--wait"]; quotes group ("'/Applications/My Editor' -w"). */
+export function splitCommand(s) {
+  const out = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while ((m = re.exec(String(s ?? "")))) out.push(m[1] ?? m[2] ?? m[3]);
+  return out;
+}
+
+function onPath(cmd) {
+  const probe = process.platform === "win32" ? spawnSync("where", [cmd]) : spawnSync("/bin/sh", ["-c", `command -v ${cmd}`]);
+  return probe.status === 0;
+}
+
+/**
+ * The preset as it would be in a preset file, from whatever is set on this account now. The key
+ * is never known here (the API keeps it), so it is left empty for the person to fill in.
+ */
+export function presetFromSettings(settings = {}) {
+  const rows = Array.isArray(settings.agentCodingBackends) ? settings.agentCodingBackends : [];
+  const agentUrl = clean(settings.agentModelUrl);
+  const norm = (u) => clean(u).replace(/\/+$/, "").toLowerCase();
+  const row = rows.find((r) => agentUrl && norm(r?.url) === norm(agentUrl)) ?? rows.find((r) => r?.enabled !== false) ?? rows[0] ?? {};
+  const apiUrl = agentUrl || clean(row.url);
+  return {
+    apiUrl,
+    apiKey: "",
+    agentModel: clean(settings.agentModelName),
+    codingModel: clean(row.defaultModel),
+    embedModel: clean(settings.ragEmbedModel),
+    embedUrl: clean(settings.ragEmbedUrl) || apiUrl,
+  };
+}
+
+const FIELDS = ["apiUrl", "apiKey", "agentModel", "codingModel", "embedModel", "embedUrl"];
+
+/** The text the editor opens with: a few `//` lines saying what to do, then the JSON. */
+export function editorText(name, preset = {}) {
+  const body = {};
+  for (const f of FIELDS) body[f] = clean(preset[f]);
+  return (
+    [
+      `// gu preset "${name}" — edit the values, then save and quit to store it.`,
+      "// Every field is needed except embedUrl (it defaults to apiUrl). Lines starting with // are ignored.",
+      "// Quit without saving (or leave it unchanged) to cancel. The file you save CONTAINS your API key.",
+    ].join("\n") +
+    "\n" +
+    JSON.stringify(body, null, 2) +
+    "\n"
+  );
+}
+
+/**
+ * What came back from the editor → { ok, preset } | { ok: false, problem }. The // lines are
+ * blanked (not removed) so a JSON error's line number is the line the person sees in the editor.
+ */
+export function parseEdited(text) {
+  const src = String(text ?? "").replace(/^[ \t]*\/\/.*$/gm, "");
+  if (!src.trim()) return { ok: false, empty: true, problem: "the file is empty." };
+  try {
+    JSON.parse(src);
+  } catch (e) {
+    const at = /line (\d+) column (\d+)/.exec(String(e?.message ?? ""));
+    const where = at ? ` (line ${at[1]}, column ${at[2]})` : "";
+    return { ok: false, problem: `that is not valid JSON${where} — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$|\s*\(line \d+ column \d+\)/g, "")}.` };
+  }
+  return validatePreset(src);
+}
+
+/**
+ * Open `initial` in `editor` and return what was saved: { ok: true, text } | { ok: false, why }.
+ * The temp file is 0600 in a 0700 directory, and the directory is removed whatever happens.
+ * `run` is spawnSync with the terminal inherited (injected for tests).
+ */
+export function editText(initial, { editor, run = spawnSync, tmpRoot = tmpdir(), fileName = "gu-preset.json" } = {}) {
+  if (!editor) return { ok: false, why: "no editor found — set $EDITOR (e.g. export EDITOR=nano)" };
+  const dir = mkdtempSync(join(tmpRoot, "gu-preset-"));
+  try {
+    chmodSync(dir, 0o700);
+    const file = join(dir, fileName);
+    writeFileSync(file, initial, { mode: 0o600 });
+    const r = run(editor.cmd, [...editor.args, file], { stdio: "inherit" });
+    if (r?.error) return { ok: false, why: `${editor.cmd} could not start — ${r.error.message}` };
+    if (typeof r?.status === "number" && r.status !== 0) return { ok: false, why: `${editor.cmd} exited with status ${r.status} — nothing saved` };
+    return { ok: true, text: readFileSync(file, "utf8") };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** A key as it may appear on screen: its first few and last four characters. */
+export function maskKey(key) {
+  const k = clean(key);
+  if (!k) return "";
+  if (k.length <= 8) return "…" + k.slice(-2);
+  const head = k.startsWith("sk-") ? "sk-" : k.slice(0, 3);
+  return `${head}…${k.slice(-4)}`;
+}
+
+const presetBody = (preset) => {
+  const o = {};
+  for (const f of FIELDS) if (f !== "embedUrl" || clean(preset.embedUrl) !== clean(preset.apiUrl)) o[f] = clean(preset[f]);
+  return o;
+};
+
+/** What "copy" puts on the clipboard: the command that recreates the preset — WITH the key. */
+export function presetCopyCommand(name, preset) {
+  return `/save-preset ${clean(name)} ${JSON.stringify(presetBody(preset))}`;
+}
+
+/** …or just the JSON, pretty, WITH the key. */
+export function presetCopyJson(preset) {
+  return JSON.stringify(presetBody(preset), null, 2);
+}
+
+/**
+ * The framed block /load-presets prints for "view": the key masked, "⧉ copy" in the top border.
+ * Every row fits `width - 1` so none wraps (a wrapped row breaks the click arithmetic, #109).
+ * → { rows, button: { from, to } } — the button's column span on row 0, 0-based, gutter included.
+ */
+export function presetBlock(name, preset, { width = 80, gutter = "   " } = {}) {
+  const shown = { ...presetBody(preset), apiKey: maskKey(preset.apiKey) };
+  const inner = JSON.stringify(shown, null, 2).split("\n");
+  const room = Math.max(24, width - 1 - gutter.length);
+  const innerW = Math.min(room - 4, Math.max(...inner.map((l) => [...l].length), 30));
+  const fit = (l) => {
+    const cs = [...l];
+    return cs.length > innerW ? cs.slice(0, innerW - 1).join("") + "…" : l + " ".repeat(innerW - cs.length);
+  };
+  const title = `┌ preset "${clean(name)}" `;
+  const copy = " ⧉ copy ";
+  const dashes = Math.max(1, innerW + 4 - [...title].length - [...copy].length - 1);
+  const top = `${title}${"─".repeat(dashes)}${copy}┐`;
+  const buttonFrom = gutter.length + [...title].length + dashes;
+  return {
+    rows: [top, ...inner.map((l) => `│ ${fit(l)} │`), `└${"─".repeat(innerW + 2)}┘`].map((r) => gutter + r),
+    button: { from: buttonFrom, to: buttonFrom + [...copy].length },
+  };
+}
+
+/** The keys the /load-presets picker takes, in the order its hint line names them. */
+export const PICKER_KEYS = { v: "view", c: "copy", j: "json", e: "edit" };
+export const PICKER_HINT = "↑↓ · Enter apply · v view · c copy command · j copy JSON · e edit · Esc back";

package/terminal-layout.mjs

@@ -2788,3 +2788,27 @@ export function slashMenuWindow(total, sel, top, rows = SLASH_MENU_ROWS) {
   const w = listWindow(n, sel < 0 ? 0 : sel, sel < 0 ? 0 : top, rows + 2);
   return { from: w.from, to: w.to, above: w.above, below: w.below, top: w.top };
 }
+
+/**
+ * A QUESTION'S HINT, drawn UNDER the input (#305: the trial token's "this is a trial — get a free
+ * token for 1 computer, or Pro for more" sits under the token it describes). Word-wrapped so every
+ * row is ONE physical row — a wrapped row corrupts every redraw that counts rows (#109/#132/#138).
+ * A word longer than the row is hard-cut rather than allowed to wrap.
+ */
+export function hintRows(lines, { width, gutter = "   ", paint = (s) => s } = {}) {
+  const room = Math.max(10, Math.max(20, width || 80) - 1 - visibleLen(gutter));
+  const out = [];
+  for (const line of lines ?? []) {
+    let row = "";
+    for (const word of String(line).split(/\s+/).filter(Boolean)) {
+      const next = row ? `${row} ${word}` : word;
+      if (visibleLen(next) <= room) row = next;
+      else {
+        if (row) out.push(row);
+        row = visibleLen(word) > room ? clipVisible(word, room) : word;
+      }
+    }
+    if (row) out.push(row);
+  }
+  return out.map((r) => gutter + paint(r));
+}

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;
     },
   };
 }