@tiens.nguyen/gu-cli 1.0.782 → 1.0.784

package/gu-repl.mjs

@@ -23,9 +23,11 @@
  * Requires the worker daemon to be running (it claims the job).
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
+import { appendFileSync as __afs } from "node:fs";
+const __dbg = (...a) => { try { __afs("/private/tmp/claude-501/-Users-joseph-Projects-gonext/bf6ac2f6-435f-4150-a01e-cea31d8ff4d2/scratchpad/r321/dbg.log", a.map((x) => JSON.stringify(x)).join(" ") + "\n"); } catch {} };
 import { readFile, mkdir, writeFile, unlink, rename } from "node:fs/promises";
-import { readStepTokens } from "./step-tokens.mjs";
-import { snapshotInput, restoreInput, replaceStoppedQuestion, stopNoteLines } from "./turn-stop.mjs";
+import { readStepTokens, readTurnCache } from "./step-tokens.mjs";
+import { snapshotInput, restoreInput, replaceStoppedQuestion, restoredQuestionLetGo, stopNoteLines } from "./turn-stop.mjs";
 import { existsSync, statSync, readFileSync, writeFileSync, readdirSync, openSync, readSync, closeSync, mkdirSync } from "node:fs";
 import { spawn } from "node:child_process";
 // FIRST, before anything that could itself fail on an old runtime: npm only WARNS about
@@ -66,6 +68,7 @@ import {
   formatThinkTime,
   plainAnswer,
   summarizeError,
+  tokenRowWithPrice,
   visibleLen,
   createProbeReplyReader,
   agentPickerItems,
@@ -179,6 +182,8 @@ import {
   viewportSlice,
   paintViewportSeq,
   jumpToBottomRow,
+  zoneResizePlan,
+  blockClosedPad,
 } from "./terminal-viewport.mjs";
 
 const DIR = dirname(fileURLToPath(import.meta.url));
@@ -636,7 +641,7 @@ function reloadWorkerEnv() {
 // first-run branch also runs one — without this the same walkthrough printed twice in a single
 // run, MongoDB instructions and all. Reported live on Windows 11.
 let clientExpertRanThisProcess = false;
-// #301: setup chose "Load a saved preset" — main() opens /load-presets before the first prompt.
+// #301: setup chose "Load a saved preset" — main() opens /use-presets before the first prompt.
 // Declared HERE, above the first-run block: that block runs at module top level, before any
 // declaration further down exists.
 let openPresetsAtStart = false;
@@ -881,10 +886,12 @@ 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> [{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: "/open-presets", aliases: ["/load-presets"], usage: "/open-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: "/save-preset", usage: "/save-preset [name]", desc: "paste a preset (from another computer's /open-presets) into your editor and save it under a name — nothing is applied" },
+  { name: "/open-presets", usage: "/open-presets [name]", desc: "your whole setup now, keys included, read-only in your editor — to copy to another computer; with a name, edit that preset" },
+  { name: "/use-presets", usage: "/use-presets [name]", desc: "pick a saved preset and apply it — shows what changes, backs up your setup, asks first" },
   { 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" },
+  { name: "/prices", usage: "/prices [update]", desc: "the price table and the cache table, and what the last turn and this session cost — \"update\" applies gu's newest published tables" },
   // ONE name, /new (user, #278). /reset and /clear still work (HIDDEN_COMMANDS) for habit and
   // for Claude Code users — not to be confused with `gu clear` in a shell, which wipes gu's state.
   { name: "/new", desc: "start a new conversation in this folder — the old one is kept (archived); the folder's settings stay" },
@@ -997,6 +1004,7 @@ const OUT_RESTORE = "\x1b8";
 const OUT_SAVE = "\x1b7";
 /** Draw in-place UI that lives in the SCROLLING area (status block, pickers, menus). */
 const regionUi = (seq) => {
+  if (/\n/.test(seq)) __dbg("regionUi with newline", { nl: (seq.match(/\n/g) || []).length, head: seq.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").slice(0, 60), at: new Error().stack.split("\n").slice(2, 5).map((x) => x.trim().slice(0, 80)) });
   if (!barPinned()) {
     ui(seq);
     return;
@@ -1449,6 +1457,11 @@ function applyClick({ row, col }) {
     void runUpdate();
     return;
   }
+  if (pricesRowTarget && row === updateRowAbs &&
+      col - 1 >= pricesRowTarget.from && col - 1 < pricesRowTarget.to) {
+    void runPricesUpdate();
+    return;
+  }
   if (agentsRowTarget && row === updateRowAbs &&
       col - 1 >= agentsRowTarget.from && col - 1 < agentsRowTarget.to) {
     void showOtherAgents(); // async now — it offers stop / switch-to (task #211)
@@ -1560,7 +1573,8 @@ const pasteStore = new Map(); // token -> the real text
 // model, so a turn stopped with Ctrl+C can give the question back for editing.
 let lastSubmittedInput = null;
 // Task #302: set while the input holds a stopped turn's question; the next line sent from it
-// REPLACES that question in history when it was edited. Cleared by "never mind" (Ctrl+C).
+// REPLACES that question in history when it was edited. Cleared by "never mind": Ctrl+C, or the
+// line emptied any other way (restoredQuestionLetGo) — what is typed next is a new message.
 let prefillFor = null;
 // Task #302: the backup run of the last stopped turn — what /undo reverts by default.
 let lastStoppedRun = null;
@@ -2453,6 +2467,12 @@ const identityLineText = () =>
     { orange, cyan: accent, dim, red },
   );
 
+/** "$0.334" / "~$0.334" (same rules as model-prices.mjs formatUsd, kept sync for the bar). */
+const fmtCost = (c) => {
+  const v = Math.max(0, c.usd);
+  return `${c.estimated ? "~" : ""}$${v >= 1 ? v.toFixed(2) : v >= 0.01 ? v.toFixed(3) : v > 0 ? v.toFixed(4) : "0"}`;
+};
+
 const tokenLineText = () => {
   // TWO different numbers, each labelled, because they are routinely off by 6×:
   //   ctx  = the NEWEST request — what the model is holding right now, the one to compare
@@ -2467,7 +2487,7 @@ const tokenLineText = () => {
   // a terminal — it was inline here, unasserted, and wrong for months. Both figures are TRUE
   // measurements: nothing is netted against a floor any more (see that function's comment).
   const { ctx, turn: sent } = tokenRowFigures({ ctxTrue, turnTrue: lastTurnInputTokens });
-  return (
+  const head = (
     // IDENTITY IS NOT ON THIS ROW ANY MORE — it has its own (identityLineText), because five
     // measurements plus a coder and a folder name was ~110 columns and the clip falls on the
     // RIGHT, so the totals were the part being cut on any normal window.
@@ -2487,11 +2507,18 @@ const tokenLineText = () => {
     // `ctx` and `sent`, which do drive decisions, need more.
     ragSegmentText() +
     dim(" · ") +
-    accent(`↓ out ${fmtTokens(lastTurnOutputTokens)}`) +
-    dim(" · ") +
-    dim("total ") +
-    accent(`↓ ${fmtTokens(Math.max(globalOutputTokens, lastTurnTotalOutput))}`)
+    accent(`↓ out ${fmtTokens(lastTurnOutputTokens)}`)
   );
+  const total = dim(" · ") + dim("total ") + accent(`↓ ${fmtTokens(Math.max(globalOutputTokens, lastTurnTotalOutput))}`);
+  // #323: what the last turn's prompt cost, LAST on the row after a "|" — "~" when the cached share
+  // was assumed; nothing when the model has no price (never a misleading "| $0"). It survives a
+  // narrow window: "total ↓" is dropped before it is (tokenRowWithPrice).
+  return tokenRowWithPrice({
+    withTotal: head + total,
+    withoutTotal: head,
+    price: lastTurnCost?.usd != null ? dim(" | ") + accent(fmtCost(lastTurnCost)) : "",
+    room: (process.stdout.columns || 80) - 1 - visibleLen(GUTTER),
+  });
 };
 // The newest RAG index file the agent reported writing (task #136), and where it lives.
 // Empty until something is written; only rendered under --verbose.
@@ -2612,6 +2639,14 @@ function syncBarPinning() {
  * 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.
  */
+/** The notice's text (sync — zoneNotice runs on every paint): "new prices updated 1 Oct 2026". */
+function priceUpdateText() {
+  const d = new Date(priceUpdate?.publishedAt ?? "");
+  if (Number.isNaN(d.getTime())) return "new prices updated";
+  const m = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][d.getUTCMonth()];
+  return `new prices updated ${d.getUTCDate()} ${m} ${d.getUTCFullYear()}`;
+}
+
 function zoneNotice(width) {
   const items = [];
   if (scrolledBack()) {
@@ -2622,6 +2657,7 @@ function zoneNotice(width) {
     const up = updateRow({ ...availableUpdates, width: 400 });
     if (up) items.push({ key: "update", clickable: true, paint: accent, text: up.text.slice(up.from) });
   }
+  if (priceUpdate) items.push({ key: "prices", clickable: true, paint: accent, text: `${priceUpdateText()} (click)` });
   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)` });
@@ -2704,6 +2740,7 @@ function frozenZone() {
   const sep = status.length + (notice ? 1 : 0);
   updateRowTarget = notice?.spans.update ?? null;
   agentsRowTarget = notice?.spans.agents ?? null;
+  pricesRowTarget = notice?.spans.prices ?? null;
   jumpSpan = notice?.spans.jump ?? null;
   return { ...zone, rows, statusRows: sep, noticeRow: Boolean(notice) };
 }
@@ -2724,11 +2761,39 @@ function alignOutputToLineStart() {
 function paintBar() {
   if (!barPinned()) return;
   const zone = frozenZone();
-  // The zone grew or shrank (the --verbose RAG row appearing) → re-cut the region before
-  // painting, or its top rows would land inside the scrolling area.
-  const regrew = zone.rows.length !== barReserved;
+  // The zone grew or shrank (a picker, the notice row, the status block, a wrapped input) →
+  // re-cut the region before painting, or its top rows would land inside the scrolling area.
+  const prev = barReserved;
+  const regrew = zone.rows.length !== prev;
+  if (regrew) { const v = viewportSlice(screenRows(), 0, viewportHeight()).rows; __dbg("MODEL AT REGROW", v.map((r) => r.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 50))); }
+  if (regrew) __dbg("ANY regrow", { prev, now: zone.rows.length, scrolledBack: scrolledBack(), rows: displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length, pad: padRows, vp: viewportRows() });
   if (regrew) {
+    // #321: MOVE THE SCREEN LIKE A TERMINAL, never repaint it from the transcript — a repaint put
+    // lines the terminal had already scrolled away back on screen, and the next output scrolled
+    // them into the scrollback AGAIN (the banner and the update notice repeated after an update;
+    // "auto-test off" doubled). See zoneResizePlan.
+    const live = prev > 0 && !scrolledBack();
+    let plan = null;
+    let rows = 0;
+    if (live) {
+      rows = displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length;
+      plan = zoneResizePlan({ contentRows: rows, pad: currentPad(rows), oldHeight: viewportRows() - prev, newHeight: viewportRows() - zone.rows.length });
+      // The rows the zone takes that still hold text: scroll them up and out — real newlines at
+      // the OLD region's bottom, so the terminal files them in its scrollback once — and move the
+      // saved output position up with the text it belongs to.
+      if (plan.scrollUp > 0) {
+        ui(`\x1b[${viewportRows() - prev};1H` + "\n".repeat(plan.scrollUp) + OUT_RESTORE + `\x1b[${plan.scrollUp}A` + OUT_SAVE);
+      }
+    }
     ui(scrollRegionSeq(viewportRows(), zone.rows.length, { preserveCaret: false }));
+    if (live && plan.clearRows > 0) {
+      // The rows the zone handed back still show its old rows — blank them, and remember them.
+      let clear = "";
+      for (let i = 0; i < plan.clearRows; i++) clear += `\x1b[${viewportRows() - prev + 1 + i};1H\x1b[2K`;
+      ui(clear);
+    }
+    if (live) setPad(plan.pad, rows);
+    __dbg("regrow", { prev, now: zone.rows.length, rows, plan, live });
     barReserved = zone.rows.length;
   }
   const top = viewportRows() - zone.rows.length + 1;
@@ -2748,19 +2813,17 @@ function paintBar() {
   // 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;
+  updateRowAbs = updateRowTarget || agentsRowTarget || pricesRowTarget ? 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(
     paintFrozenRowsSeq(zone.rows, viewportRows(), { preserveCaret: false }) +
       parkCaretSeq(zone.caretRow, zone.caretCol)
   );
-  // THE ZONE CHANGED HEIGHT — the line wrapped onto a new row, or unwrapped off one. Re-cutting
-  // the region does not move what is already on screen: growing freezes a row that still holds
-  // transcript text (and we have just painted over it), shrinking hands back a row that is
-  // blank. Repaint the view from the transcript so neither shows. Recurses exactly once —
-  // paintLiveTail ends in paintBar, by which point the count matches and this is skipped.
-  if (regrew && !scrolledBack()) paintLiveTail();
+  // THE FIRST PIN only: before it, the screen is whatever setup printed, and one repaint puts the
+  // view in gu's hands. Every later height change moved the screen above (#321) — a repaint here
+  // is what filled the scrollback with copies. Recurses at most once (paintLiveTail → paintBar).
+  if (regrew && !scrolledBack() && prev === 0) paintLiveTail();
 }
 /** Bytes that put the caret back on text row `row` (0-based) at 1-based `col`. */
 const parkCaretSeq = (row, col) => `\x1b[${inputRowAbs + Math.max(0, row | 0)};${col}H`;
@@ -2911,6 +2974,8 @@ let updateRowTarget = null;
 let updateRowAbs = 0;
 // …and the agents indicator, which shares that row when no update is pending (task #195).
 let agentsRowTarget = null;
+// …and "new prices updated <date>" (#323).
+let pricesRowTarget = null;
 // A terminal left with a scrolling region is a broken shell — a hard guarantee, like the
 // bracketed-paste and mouse-reporting teardowns.
 process.on("exit", () => {
@@ -2927,11 +2992,25 @@ process.on("exit", () => {
 // the same space displayRows produces, so the highlight stays on the text it was drawn over
 // when the view scrolls rather than on whatever moved under that screen row.
 let liveSelection = null;
-const screenRows = () =>
-  applySelectionHighlight(
-    displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1),
-    liveSelection
-  );
+/**
+ * BLANK ROWS BELOW THE CONTENT at the live tail (#321): when the frozen zone shrinks, the rows it
+ * hands back stay blank (nothing older is repainted into the view — those lines are already in the
+ * terminal's scrollback), and new output fills them first. Kept as a count + the transcript's row
+ * count when it was set, so the per-write path costs nothing: the pad left is what output since has
+ * not consumed.
+ */
+let padRows = 0;
+let padAnchor = 0;
+const currentPad = (rowCount) => (padRows > 0 ? Math.max(0, padRows - Math.max(0, rowCount - padAnchor)) : 0);
+function setPad(n, rowCount) {
+  padRows = Math.max(0, n | 0);
+  padAnchor = rowCount;
+}
+const screenRows = () => {
+  const rows = displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1);
+  const pad = currentPad(rows.length);
+  return applySelectionHighlight(pad ? [...rows, ...Array(pad).fill("")] : rows, liveSelection);
+};
 /**
  * Abandon any drag in progress and take its highlight off screen (task #177).
  *
@@ -3769,6 +3848,9 @@ function stopPendingStatus() {
 // Already-printed scrollback (bullets, answers, wrapBlock output) is deliberately NOT touched:
 // it belongs to the terminal now, and the terminal reflows it.
 function onWindowResize() {
+  // #321: the blank rows below the content were counted in rows of the OLD width; the resize
+  // repaint lays the view out afresh.
+  padRows = 0;
   // Whatever owns the screen, readline's next refresh must not walk up a stale row count —
   // at the prompt this is the fix itself; elsewhere it stops a later rl.prompt() from erasing
   // rows above the input.
@@ -3981,6 +4063,9 @@ if (process.stdin.isTTY) {
     // re-rendered the slash overlay (the line still starts with "/" from before the paste) and
     // re-walked the paste store. Same for a mouse report's characters, which are not keys.
     if (pasteBuffer !== null || inMouseKeyWindow()) return;
+    // #247: the restored question was erased (Backspace, Ctrl+U, a picker taking the line) — it
+    // is let go, exactly as with Ctrl+C, so the next message does not REPLACE it in history.
+    if (prefillFor && (listPickerActive || restoredQuestionLetGo(rl.line, key))) prefillFor = null;
     // An arrow-key list picker (/server) is up → ↑/↓ move the highlight, Enter chooses.
     if (listPickerActive) {
       onListKey(key);
@@ -6823,17 +6908,6 @@ function withTerminalHandedOver(run) {
   }
 }
 
-/**
- * /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.
- */
 /**
  * THIS ACCOUNT'S WHOLE SETUP as a version-2 preset (#320): every coding server and its models, the
  * default coder, the agent, the embedder — and each server's API key, read through the local API the
@@ -6876,129 +6950,163 @@ async function fetchKeyForBackend(backendId) {
   }
 }
 
+/**
+ * /save-preset [name] (#322) — PASTE A PRESET AND NAME IT. Opens an empty editor (the // header says
+ * how to save in THAT editor); the person pastes the JSON another computer's /open-presets showed,
+ * saves and quits. Checked in full, then stored 0600 under the name — NOTHING is applied (that is
+ * /use-presets). `/save-preset <name> {json}` is the one-line form, for scripts.
+ */
 async function runSavePresetCommand(line) {
   const pr = await import("./presets-transfer.mjs");
-  const home = homedir();
+  const ed = await import("./preset-editor.mjs");
   console.log("");
-  const usage = "usage: /save-preset <name>  (saves your whole setup)  ·  /save-preset <name> --edit  (in your editor)  ·  /save-preset <name> {json}";
   const raw = line.trim().slice("/save-preset".length).trim();
-  const wantsEdit = /(^|\s)--edit(?=\s|$)/.test(raw);
-  let rest = raw.replace(/(^|\s)--edit(?=\s|$)/, " ").trim();
-  if (!rest) {
-    const typed = String((await ask("preset name: ")) ?? "").trim();
-    if (!typed) {
-      console.log(GUTTER + dim("cancelled — nothing saved.") + "\n");
+  const space = raw.search(/\s/);
+  const given = space === -1 ? raw : raw.slice(0, space);
+  const json = space === -1 ? "" : raw.slice(space + 1).trim();
+  if (given && !pr.isPresetName(given)) {
+    console.log(GUTTER + `"${given}" is not a preset name — one word, no slashes. usage: /save-preset [name]` + "\n");
+    return;
+  }
+  try {
+    let parsed = null;
+    if (json) {
+      parsed = ed.parsePastedPreset(json);
+      if (!parsed.ok) {
+        console.log(GUTTER + `Preset not saved — ${parsed.problem}` + "\n");
+        return;
+      }
+    } else {
+      parsed = await pastePresetInEditor(ed);
+      if (!parsed) {
+        console.log(GUTTER + dim("Not saved.") + "\n");
+        return;
+      }
+    }
+    const name = given || (await askPresetName(pr, parsed.name || ""));
+    if (!name) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
       return;
     }
-    rest = typed;
-  }
-  const space = rest.search(/\s/);
-  const name = space === -1 ? rest : rest.slice(0, space);
-  const json = space === -1 ? "" : rest.slice(space + 1).trim();
-  if (!pr.isPresetName(name)) {
-    console.log(GUTTER + `"${name}" is not a preset name — one word, no slashes. ` + usage);
-    console.log("");
-    return;
+    const file = pr.presetFilePath(name, homedir());
+    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it?`, false))) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
+      return;
+    }
+    writePresetFile(pr, file, name, parsed);
+    console.log(GUTTER + dim(`/use-presets → ${name} applies it.`) + "\n");
+  } catch (e) {
+    if (wasPromptCancelled(e)) {
+      console.log(GUTTER + dim("Not saved.") + "\n");
+      return;
+    }
+    throw e;
   }
-  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("");
-  };
-  // A WHOLE-SETUP preset (#320): written as given (dated, named), then summarised — keys masked.
-  const storeFull = (doc) => {
-    const out = { ...doc, gu: "preset", version: pr.FULL_PRESET_VERSION, name, savedAt: new Date().toISOString(), savedOn: hostname(),
-      note: "The whole setup: every coding server and its models, the default coder, the agent and the embedder — and each server's API key. This file CONTAINS live API keys." };
+}
+
+/** Store a checked preset (`parsed` from parsePastedPreset/parseEdited) — 0600, named, dated. */
+function writePresetFile(pr, file, name, parsed) {
+  if (parsed.full) {
+    const { note: _n, savedAt: _a, savedOn: _o, ...body } = parsed.doc;
+    const out = { ...body, gu: "preset", version: pr.FULL_PRESET_VERSION, name, savedAt: new Date().toISOString(), savedOn: hostname() };
     writeFileSync(file, JSON.stringify(out, null, 2) + "\n", { mode: 0o600 });
     const v = pr.validatePresetFile(JSON.stringify(out));
-    console.log(GUTTER + `Preset "${name}" saved to ${file} — your whole setup:`);
+    console.log(GUTTER + `Preset "${name}" saved to ${file}:`);
     if (v.ok && v.full) for (const l of pr.fullPresetSummary(v.value, v.codingDefault)) console.log(GUTTER + dim(l));
-    console.log(GUTTER + dim("It CONTAINS your API keys — keep it private. /open-presets → v to view it, c to copy it for another machine."));
-    console.log("");
-  };
-  const ed = await import("./preset-editor.mjs");
-  if (json) {
-    const checked = ed.parseEdited(json);
-    if (!checked.ok) {
-      console.log(GUTTER + `Preset not saved — ${checked.problem}`);
-      console.log("");
-      return;
-    }
-    if (checked.full) storeFull(checked.doc);
-    else store(checked.preset);
-    return;
+  } else {
+    writeFileSync(file, JSON.stringify(pr.buildPreset({ name, preset: parsed.preset, host: hostname() }), null, 2) + "\n", { mode: 0o600 });
+    console.log(GUTTER + `Preset "${name}" saved to ${file}`);
   }
+  console.log(GUTTER + dim("It CONTAINS API keys — the file is readable only by you."));
+}
 
-  // THE WHOLE SETUP, NOW (#320): every server, its models and key, the defaults — saved without an
-  // editor, because "as it is now" is what a person saving their setup means. --edit opens it first.
-  if (!wantsEdit) {
-    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it with the setup you have now?`, false))) {
-      console.log(GUTTER + dim("Not saved.") + "\n");
-      return;
-    }
-    const doc = await withPendingStatus("reading your servers, models and keys", () => buildFullPresetNow(name));
+/**
+ * /open-presets [name] (#322).
+ *   · no name — YOUR SETUP NOW (every server, model, key, the default coder, agent, embedder),
+ *     READ-ONLY in the editor, to copy to another computer. Then it offers the clipboard too (OSC 52
+ *     reaches the person's own machine over SSH): a long setup scrolls past one screen of nano, and
+ *     selecting across a scroll with the mouse does not work.
+ *   · a name — that preset in the editor; a saved change is checked in full first and a broken one is
+ *     never stored ("Edit again?" reopens the person's own text).
+ */
+async function runOpenPresetsCommand(line) {
+  const pr = await import("./presets-transfer.mjs");
+  const ed = await import("./preset-editor.mjs");
+  console.log("");
+  const name = line.trim().slice("/open-presets".length).trim();
+  if (!name) {
+    const doc = await withPendingStatus("reading your servers, models and keys", () => buildFullPresetNow("my-setup"));
     if (!doc) {
-      console.log(GUTTER + red(`couldn't read your settings from ${apiBase} — nothing was saved.`) + "\n");
+      console.log(GUTTER + red(`couldn't read your settings from ${apiBase}.`) + "\n");
       return;
     }
-    storeFull(doc);
+    const text = ed.currentSetupText(doc);
+    const editor = ed.pickEditor({ readOnly: true });
+    if (editor && process.stdin.isTTY) {
+      console.log(GUTTER + dim(`Opening ${basename(editor.cmd)} read-only (${editor.saveHint}).`));
+      const r = withTerminalHandedOver(() => ed.editText(text, { editor, fileName: "gu-setup.json" }));
+      if (!r.ok) console.log(GUTTER + yellow(`couldn't show it — ${r.why}.`));
+    } else {
+      console.log(GUTTER + yellow(editor ? "an editor needs a terminal." : ed.NO_EDITOR_HINT + "."));
+    }
+    const v = pr.validatePresetFile(JSON.stringify(doc));
+    if (v.ok && v.full) for (const l of pr.fullPresetSummary(v.value, v.codingDefault)) console.log(GUTTER + dim(l));
+    if (await askYesNo("Copy it to the clipboard (keys included)?", true)) {
+      const res = await writeClipboard(text.split("\n").filter((l) => !l.startsWith("//")).join("\n"));
+      console.log(GUTTER + (res.ok ? accent("✓ copied — on the other computer: /save-preset, paste, save and quit.") : yellow(`couldn't copy (${res.why}).`)));
+    }
+    console.log("");
+    return;
+  }
+  const file = pr.presetFilePath(name, homedir());
+  if (!file) return; // a cancel word
+  if (!existsSync(file)) {
+    console.log(GUTTER + `no preset called "${name}" — /use-presets lists them.` + "\n");
+    return;
+  }
+  let doc = null;
+  try {
+    doc = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    /* named below */
+  }
+  if (doc?.gu !== "preset") {
+    console.log(GUTTER + `${file} is not a gu preset.` + "\n");
     return;
   }
-
-  // THE EDITOR. Filled in from the preset being edited, else from the whole setup this account has now.
   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("");
+    console.log(GUTTER + yellow(editor ? "an editor needs a terminal." : ed.NO_EDITOR_HINT + ".") + "\n");
     return;
   }
-  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 = (await buildFullPresetNow(name)) ?? 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.`));
+  const initial = ed.editorText(name, doc);
+  console.log(GUTTER + dim(`Opening "${name}" in ${basename(editor.cmd)} — save a change, or just quit.`));
   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("");
+      console.log(GUTTER + `Not changed — ${r.why}.` + "\n");
       return;
     }
     if (r.text === initial) {
-      console.log(GUTTER + dim("Not saved — nothing changed.") + "\n");
+      console.log(GUTTER + dim("Not changed.") + "\n");
       return;
     }
     const parsed = ed.parseEdited(r.text);
     if (parsed.ok) {
-      if (parsed.full) storeFull(parsed.doc);
-      else store(parsed.preset);
+      writePresetFile(pr, file, name, parsed);
+      console.log("");
       return;
     }
-    console.log(GUTTER + yellow(`Not saved yet — ${parsed.problem}`));
+    console.log(GUTTER + yellow(`Not saved — ${parsed.problem}`));
     if (!(await askYesNo("Edit again?", true))) {
-      console.log(GUTTER + dim("Not saved.") + "\n");
+      console.log(GUTTER + dim("Not changed.") + "\n");
       return;
     }
-    text = r.text; // their text, with the mistake in it — not the template again
+    text = r.text; // their text, with the mistake in it — not the saved preset again
   }
 }
 
-/**
- * /load-presets — list the preset files /save-preset wrote (newest first, the arrow-key picker)
- * and apply the chosen one: the server + both models land as one coding-backend row, the preset's
- * key is saved under the preset's name and made that row's default, and the embedder is set. The
- * user reconfirms before anything changes, like /load-settings.
- */
 /**
  * After Ctrl+C stopped THIS terminal's turn (task #302): say what it left behind, and give the
  * question back.
@@ -7109,55 +7217,27 @@ async function runUndoCommand(line) {
 }
 
 /**
- * #317: a preset the person ALREADY HAS, brought in by pasting — its JSON, a whole preset file, or
- * the `/save-preset <name> {…}` command copied from another computer (#312). A multi-line paste
- * arrives as "[Pasted text #N +M lines]" and is expanded before it is read, so the key is never
- * echoed. A mistake is named; Enter then opens it IN THE EDITOR with the pasted text (not a blank
- * template), and Enter on nothing opens the editor on the current setup. Esc cancels.
- * Saved 0600 like /save-preset. → the file, or "" when cancelled.
+ * The pasting half of /save-preset (#317, #322): an EMPTY editor with the // header (the person's
+ * terminal editor over SSH — nano on a fresh Ubuntu server), or, with no editor or no terminal, a
+ * one-line prompt. → the parsed preset, or null when cancelled.
  */
-async function presetFromPaste(pr, home) {
-  const ed = await import("./preset-editor.mjs");
+async function pastePresetInEditor(ed) {
   const editor = ed.pickEditor();
-  let parsed = null;
-  try {
-    // AN EDITOR FIRST (#322): a preset is many lines — on an Ubuntu server over SSH, nano is the
-    // natural place to paste it. The one-line prompt is only the fallback with no editor/terminal.
-    if (editor && process.stdin.isTTY) {
-      // One short line (#322): the save keys are in the file's own header, where they are needed.
-      console.log(GUTTER + dim(`Opening ${basename(editor.cmd)} — paste your preset there, then save and quit.`));
-      parsed = await fixPresetInEditor(ed, ed.pasteTemplate(editor.saveHint), { editor });
-      if (!parsed) return "";
-    } else {
-      if (!editor) console.log(GUTTER + yellow(ed.NO_EDITOR_HINT) + dim(" — or paste it here, on one line."));
-      console.log(GUTTER + "Paste a preset you already have — its JSON, a preset file, or a /save-preset command.");
-      console.log(GUTTER + dim("Esc cancels."));
-      while (!parsed) {
-        const text = String((await ask("preset: ")) ?? "");
-        if (!text.trim()) return "";
-        const p = ed.parsePastedPreset(text);
-        if (p.ok) {
-          parsed = p;
-          break;
-        }
-        console.log(GUTTER + yellow(`Not a preset yet — ${p.problem}`));
-        console.log(GUTTER + dim("Paste it again, or Esc to cancel."));
-      }
-    }
-    const name = await askPresetName(pr, parsed.name || "preset");
-    if (!name) return "";
-    const file = pr.presetFilePath(name, home);
-    if (existsSync(file) && !(await askYesNo(`A preset called "${name}" exists — replace it?`, false))) return "";
-    // A whole-setup preset (#320) is kept as it is — every server, key and default — named and dated.
-    const out = parsed.full
-      ? { ...parsed.doc, gu: "preset", version: pr.FULL_PRESET_VERSION, name, savedAt: new Date().toISOString(), savedOn: hostname() }
-      : pr.buildPreset({ name, preset: parsed.preset, host: hostname() });
-    writeFileSync(file, JSON.stringify(out, null, 2) + "\n", { mode: 0o600 });
-    console.log(GUTTER + `Preset "${name}" saved to ${file}`);
-    return file;
-  } catch (e) {
-    if (wasPromptCancelled(e)) return "";
-    throw e;
+  if (editor && process.stdin.isTTY) {
+    // One short line: the save keys are in the file's own header, where they are needed.
+    console.log(GUTTER + dim(`Opening ${basename(editor.cmd)} — paste your preset there, then save and quit.`));
+    return fixPresetInEditor(ed, ed.pasteTemplate(editor.saveHint), { editor });
+  }
+  if (!editor) console.log(GUTTER + yellow(ed.NO_EDITOR_HINT) + dim(" — or paste it here, on one line."));
+  console.log(GUTTER + "Paste the preset — its JSON, a preset file, or a /save-preset line.");
+  console.log(GUTTER + dim("Esc cancels."));
+  for (;;) {
+    const text = String((await ask("preset: ")) ?? "");
+    if (!text.trim()) return null;
+    const p = ed.parsePastedPreset(text);
+    if (p.ok) return p;
+    console.log(GUTTER + yellow(`Not a preset yet — ${p.problem}`));
+    console.log(GUTTER + dim("Paste it again, or Esc to cancel."));
   }
 }
 
@@ -7197,98 +7277,43 @@ async function askPresetName(pr, dflt) {
   }
 }
 
-async function runLoadPresetsCommand(line) {
+/**
+ * /use-presets [name] (#322) — the saved presets, newest first: Enter APPLIES the chosen one (the plan
+ * with keys masked, a backup of the current setup, then "apply? [y/N]" — preset-apply.mjs), o opens it
+ * in the editor (/open-presets <name>). Presets come in through /save-preset.
+ */
+async function runUsePresetsCommand(line) {
   const pr = await import("./presets-transfer.mjs");
   const home = homedir();
   console.log("");
   let file = "";
-  // /open-presets (#322), or its old name /load-presets — the printed undo lines of older backups use it.
-  const typed = line.trim().replace(/^\/(open|load)-presets\b/, "").trim();
+  const typed = line.trim().slice("/use-presets".length).trim();
   if (typed) {
     file = pr.presetFilePath(typed, home);
     if (!file) return; // a cancel word
     if (!existsSync(file)) {
-      console.log(GUTTER + `no preset file at ${file}`);
-      console.log("");
+      console.log(GUTTER + `no preset called "${typed}" — /use-presets lists them.` + "\n");
       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));
-    // NO DEAD END (#317: "I need a place to input a preset I have already"): with nothing saved,
-    // the command asks for one right here; with presets saved, the picker's LAST row does (last, so
-    // Enter still applies the newest preset, as it always has).
     if (found.length === 0) {
       console.log(GUTTER + "No presets saved yet.");
-      file = await presetFromPaste(pr, home);
-      if (!file) {
-        console.log(GUTTER + "load cancelled.");
-        console.log("");
-        return;
-      }
-    } else {
-      console.log(dim(`  Presets in ${home === homedir() ? "~" : home}  (${ed.PICKER_HINT}):`));
-      const PASTE_ROW = "+ Paste a preset I already have…";
-      const pick = await pickFromList([...found, PASTE_ROW], 0, { keys: ed.PICKER_KEYS });
-      if (!pick || pick.index < 0) {
-        console.log(GUTTER + "load cancelled.");
-        console.log("");
-        return;
-      }
-      if (pick.index === found.length) {
-        file = await presetFromPaste(pr, home);
-        if (!file) {
-          console.log(GUTTER + "load cancelled.");
-          console.log("");
-          return;
-        }
-        pick.action = "select"; // a pasted preset goes on to be applied, whatever key opened the row
-      } else {
-        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];
-        // A whole-setup preset (#320) is shown and copied AS SAVED — every server, every key.
-        const body = shown.full ? JSON.parse(readFileSync(file, "utf8")) : shown.preset;
-        const command = ed.presetCopyCommand(pname, body);
-        if (pick.action === "view") {
-          const block = ed.presetBlock(pname, body, { 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(`/open-presets ${pname} applies it.`));
-          console.log("");
-          return;
-        }
-        const res = await writeClipboard(pick.action === "json" ? ed.presetCopyJson(body) : 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;
-      }
+      console.log(GUTTER + dim("/save-preset pastes one in — copy it from another computer's /open-presets.") + "\n");
+      return;
+    }
+    console.log(dim(`  Presets  (${ed.PICKER_HINT}):`));
+    const pick = await pickFromList(found, 0, { keys: ed.PICKER_KEYS });
+    if (!pick || pick.index < 0) {
+      console.log(GUTTER + dim("nothing changed.") + "\n");
+      return;
+    }
+    if (pick.action === "open") {
+      await runOpenPresetsCommand(`/open-presets ${found[pick.index]}`);
+      return;
     }
+    file = pr.presetFilePath(found[pick.index], home);
   }
   const checked = pr.validatePresetFile(readFileSync(file, "utf8"));
   if (checked.ok && checked.full) {
@@ -7531,6 +7556,195 @@ async function fetchWorkerSettings() {
     return null; // offline — callers fall back to showing what they know
   }
 }
+
+// ---------------------------------------------------------------------------------------------
+// WHAT A TURN COST (#323): prices from the account's own Mongo (seeded once from the table gu
+// ships), the turn's cached share from the provider when it reports one — else 90% of the later
+// steps assumed — and the result on the token row ("· ~$0.334") and in /price.
+// ---------------------------------------------------------------------------------------------
+let priceRows = null; // null = not loaded yet; [] = none (and seeding failed)
+let priceVersion = "";
+let pricePublishedAt = ""; // when gu published the tables this account last applied ("" = none)
+let lastTurnCost = null; // { usd, estimated, cachedTokens, input, model, host }
+let sessionCostUsd = 0;
+let sessionCostEstimated = false;
+let sessionCostTurns = 0;
+
+async function priceApi(method, body) {
+  try {
+    const r = await fetch(`${apiBase}/api/worker/model-prices`, {
+      method,
+      headers: { "X-Worker-Key": workerKey, ...(body ? { "Content-Type": "application/json" } : {}) },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+      signal: AbortSignal.timeout(8000),
+    });
+    const j = await r.json().catch(() => null);
+    return r.ok ? j : { error: j?.error || `HTTP ${r.status}` };
+  } catch (e) {
+    return { error: e?.message ?? String(e) };
+  }
+}
+
+/**
+ * The account's prices. An EMPTY table is seeded once with the one gu ships (an upsert — running it
+ * twice changes nothing). An API without the route (an older local API) → [] and no cost shown.
+ */
+async function loadPrices({ force = false } = {}) {
+  if (priceRows && !force) return priceRows;
+  const mp = await import("./model-prices.mjs");
+  let got = await priceApi("GET");
+  if (got && !got.error && Array.isArray(got.rows) && got.rows.length === 0) {
+    const seeded = await priceApi("PUT", { version: mp.PRICE_TABLE.version, rows: mp.PRICE_TABLE.prices, removes: [] });
+    if (!seeded?.error) got = await priceApi("GET");
+  }
+  priceRows = got && !got.error && Array.isArray(got.rows) ? got.rows : [];
+  priceVersion = typeof got?.version === "string" ? got.version : "";
+  pricePublishedAt = typeof got?.publishedAt === "string" ? got.publishedAt : "";
+  return priceRows;
+}
+
+/** The coder model id in use — the folder's /model pick ("<kind>::<model>") or the account default. */
+function activeCodingModelId() {
+  const m = String(sessionCodingModel || "");
+  return m.includes("::") ? m.slice(m.indexOf("::") + 2) : m || defaultCodingModel;
+}
+
+/** After a turn: what its prompt tokens cost, added to the session total. Never throws. */
+async function noteTurnCost(inputTokens, breakdown, coder = null) {
+  try {
+    lastTurnCost = null;
+    if (!(inputTokens > 0)) return;
+    const mp = await import("./model-prices.mjs");
+    const rows = await loadPrices();
+    const url = coder?.url ?? activeCodingUrl();
+    const model = coder?.model ?? activeCodingModelId();
+    const price = mp.findPrice(rows, url, model);
+    const cache = readTurnCache(breakdown) ?? { cached: 0, cacheReported: false, firstIn: 0 };
+    const c = mp.turnCost({ input: inputTokens, ...cache, price });
+    if (!c) {
+      lastTurnCost = { usd: null, model, host: mp.hostOf(url) };
+      return;
+    }
+    lastTurnCost = { ...c, input: inputTokens, cacheReported: cache.cacheReported, model, host: mp.hostOf(url) };
+    sessionCostUsd += c.usd;
+    sessionCostEstimated ||= c.estimated;
+    sessionCostTurns++;
+    if (barPinned()) paintBar();
+  } catch {
+    /* a cost is never worth a broken prompt */
+  }
+}
+
+/**
+ * /prices (#323) — the price table and the cache table this account's estimates use, the coder in
+ * use marked; what the last turn and this session cost; and, when gu has published newer tables,
+ * that they are waiting. `/prices update` applies them — the same as clicking the notice.
+ */
+async function runPricesCommand(line = "/prices") {
+  const mp = await import("./model-prices.mjs");
+  console.log("");
+  if (line.trim().slice("/prices".length).trim() === "update") {
+    await runPricesUpdate();
+    return;
+  }
+  const rows = await withPendingStatus("reading prices", () => loadPrices({ force: true }));
+  if (!rows.length) {
+    console.log(GUTTER + yellow("no prices — the local API is older than this gu, or unreachable.") + "\n");
+    return;
+  }
+  const width = process.stdout.columns || 80;
+  const url = activeCodingUrl();
+  const model = activeCodingModelId();
+  const paint = (l) => (l.startsWith("▸") ? accent(l) : /^[a-z0-9.-]+\.[a-z]+(:\d+)?( |$)/i.test(l) ? l : dim(l));
+  console.log(GUTTER + "Prices");
+  for (const l of mp.priceTableLines(rows, { width, current: { url, model }, version: priceVersion })) console.log(GUTTER + paint(l));
+  console.log("");
+  console.log(GUTTER + "Cache" + dim(" — the share of each step's prompt assumed cached, used only when a provider does not report its own count"));
+  for (const l of mp.cacheShareLines({ yours: rows, width, current: { url, model } })) console.log(GUTTER + paint(l));
+  console.log("");
+  console.log(GUTTER + dim(pricePublishedAt ? `from gu's tables published ${new Date(pricePublishedAt).toLocaleString()}` : "gu's built-in tables (none published applied yet)"));
+  if (priceUpdate) console.log(GUTTER + accent(`${mp.priceUpdateLabel(priceUpdate.publishedAt)} — click it below, or /prices update`));
+  if (!mp.findPrice(rows, url, model)) {
+    console.log(GUTTER + yellow(`no price for ${model || "the coder"} at ${mp.hostOf(url) || "its server"} — no cost is shown for its turns.`));
+  }
+  if (lastTurnCost?.usd != null) {
+    const share = lastTurnCost.input ? Math.round((100 * lastTurnCost.cachedTokens) / lastTurnCost.input) : 0;
+    console.log(GUTTER + `last turn: ${mp.formatUsd(lastTurnCost.usd, { estimated: lastTurnCost.estimated })}` +
+      dim(` — ${lastTurnCost.input.toLocaleString("en-US")} prompt tokens, ${share}% cached ${lastTurnCost.cacheReported ? "(reported by the provider)" : "(assumed)"}`));
+  }
+  if (sessionCostTurns) console.log(GUTTER + `this session: ${mp.formatUsd(sessionCostUsd, { estimated: sessionCostEstimated })}` + dim(` over ${sessionCostTurns} turn${sessionCostTurns === 1 ? "" : "s"} · input only — output is not counted yet`));
+  console.log("");
+}
+
+// ---------------------------------------------------------------------------------------------
+// "NEW PRICES UPDATED <date>" (#323): the hosted API's newest published tables, checked at start
+// and hourly beside the version check; when newer than what this account applied, a clickable item
+// on the notice row. A click (or /prices update) writes both tables into the user's own Mongo.
+// ---------------------------------------------------------------------------------------------
+let priceUpdate = null; // { publishedAt, tables } while newer tables wait
+let priceUpdateBusy = false;
+
+async function fetchPublishedTables() {
+  const { DEFAULT_API_BASE } = await import("./device-login.mjs");
+  const base = (String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE).replace(/\/+$/, "");
+  try {
+    const r = await fetch(`${base}/api/get-price-and-cache-table`, { signal: AbortSignal.timeout(8000) });
+    if (!r.ok) return null;
+    const j = await r.json().catch(() => null);
+    return j && (j.prices || j.cacheShares) ? j : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Are newer tables published? Fails silently to "no" — like the version check. */
+async function refreshPriceUpdate() {
+  try {
+    const mp = await import("./model-prices.mjs");
+    const tables = await fetchPublishedTables();
+    if (!tables) return;
+    await loadPrices({ force: true });
+    const was = Boolean(priceUpdate);
+    priceUpdate = mp.hasNewerPublished(pricePublishedAt, tables.publishedAt) ? { publishedAt: tables.publishedAt, tables } : null;
+    if (Boolean(priceUpdate) !== was && barPinned()) paintBar();
+  } catch {
+    /* a price notice is never worth an error */
+  }
+}
+
+/** Apply gu's newest published tables to this account's Mongo — the notice's click. */
+async function runPricesUpdate() {
+  if (priceUpdateBusy) return;
+  priceUpdateBusy = true;
+  try {
+    const mp = await import("./model-prices.mjs");
+    const tables = (await fetchPublishedTables()) ?? priceUpdate?.tables ?? null;
+    if (!tables) {
+      console.log(GUTTER + yellow("couldn't reach gu's published prices — try again later.") + "\n");
+      return;
+    }
+    const current = await loadPrices({ force: true });
+    const m = mp.mergePublishedTables(current, tables);
+    if (!m.ok) {
+      console.log(GUTTER + yellow(`prices not updated — ${m.problem}`) + "\n");
+      return;
+    }
+    const res = await priceApi("PUT", { version: m.version, publishedAt: m.publishedAt, rows: m.rows, removes: [] });
+    if (res?.error) {
+      console.log(GUTTER + red(`couldn't save the prices — ${res.error}. Nothing changed.`) + "\n");
+      return;
+    }
+    await loadPrices({ force: true });
+    priceUpdate = null;
+    const d = m.diff;
+    console.log(GUTTER + accent(`✓ ${mp.priceUpdateLabel(m.publishedAt).replace(/^new prices updated/, "prices updated to gu's tables of")}`) +
+      dim(` — ${d.added.length} new · ${d.changed.length} changed · ${d.unchanged} unchanged. /prices shows them.`) + "\n");
+    if (barPinned()) paintBar();
+  } finally {
+    priceUpdateBusy = false;
+  }
+}
+
 /**
  * `/embed-model` — switch the RAG embedder, the embed server, or the embed key (task #169).
  *
@@ -9513,9 +9727,12 @@ let listAllowDelete = false;
 // 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.
+// /use-presets' { o: "open" } (#312, #322). Null unless a caller asks, like ctrl+d above.
 let listKeys = null;
 let listKeyAction = "";
+/** #321: the screen under a picker when it opened (content rows, pad, region height), and its tallest draw. */
+let listOpenedOver = null;
+let listMaxRows = 0;
 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
@@ -9549,6 +9766,15 @@ function drawList(redraw) {
   if (listNote) rows.push(clipVisible(GUTTER + yellow(listNote), width - 1));
   // On a redraw the caret sits one row BELOW the block (each draw ends with "\n").
   const up = redraw ? physicalRows(listRowsDrawn, width) : 0;
+  // #321: what the screen held under the picker when it opened, and how far it reaches — so the
+  // wipe can account for anything it scrolled into the scrollback (blockClosedPad).
+  if (!redraw && barPinned() && !scrolledBack()) {
+    const content = displayRows(transcript.lines(), width - 1).length;
+    listOpenedOver = { content, pad: currentPad(content), height: viewportHeight() };
+    __dbg("picker open", listOpenedOver, { lastLines: transcript.lines().slice(-3) });
+    listMaxRows = 0;
+  }
+  listMaxRows = Math.max(listMaxRows, physicalRows(rows, width));
   regionUi(
     (up ? `\x1b[${up}A` : "") +
       rows.map((r) => "\x1b[K" + r).join("\n") +
@@ -9563,6 +9789,15 @@ function finishList(index) {
   const width = Math.max(20, process.stdout.columns || 80);
   const up = physicalRows(listRowsDrawn, width); // ESC[0A would still move ONE row — guard it
   regionUi((up ? `\x1b[${up}A` : "") + "\x1b[J"); // wipe the list block
+  // #321: the rows the picker scrolled away are in the scrollback; the content now sits that much
+  // higher with blank rows under it — remember them, so nothing repaints those lines back on screen.
+  if (listOpenedOver && barPinned() && !scrolledBack() && listOpenedOver.height === viewportHeight()) {
+    setPad(blockClosedPad({ contentRows: listOpenedOver.content, pad: listOpenedOver.pad, height: listOpenedOver.height, blockRows: listMaxRows }), listOpenedOver.content);
+    { const v = viewportSlice(screenRows(), 0, viewportHeight()).rows; __dbg("MODEL VIEW", v.map((r) => r.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 60))); }
+    __dbg("picker closed", { ...listOpenedOver, blockRows: listMaxRows, newPad: padRows, nowRows: displayRows(transcript.lines(), width - 1).length });
+  }
+  listOpenedOver = null;
+  listMaxRows = 0;
   listRowsDrawn = [];
   listTop = 0;
   const r = listResolve;
@@ -12329,6 +12564,9 @@ async function main() {
   // reason gu refuses to exit.
   void refreshAvailableUpdates();
   setInterval(() => void refreshAvailableUpdates(), UPDATE_CHECK_MS).unref();
+  // #323: gu's newest published price + cache tables — same cadence, same silent failure.
+  void refreshPriceUpdate();
+  setInterval(() => void refreshPriceUpdate(), UPDATE_CHECK_MS).unref();
   // The gu token (#232): same arrangement — background, never delays the prompt, unref'd.
   startupTokenRefresh = refreshCliToken();
   setInterval(() => void refreshCliToken(), TOKEN_TICK_MS).unref();
@@ -12457,13 +12695,13 @@ async function main() {
   }
 
   // #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.
+  // /use-presets flow (the list, the plan, the confirmation, the key) is that command's own.
   if (openPresetsAtStart) {
     openPresetsAtStart = false;
     try {
-      await runLoadPresetsCommand("/open-presets");
+      await runUsePresetsCommand("/use-presets");
     } catch (e) {
-      console.log(GUTTER + dim(`(could not open the presets: ${e?.message ?? e} — run /open-presets)`));
+      console.log(GUTTER + dim(`(could not open the presets: ${e?.message ?? e} — run /use-presets)`));
     }
   }
 
@@ -12483,6 +12721,10 @@ async function main() {
     announceCliUpdate(); // deferred if a 6h refresh landed mid-turn; harmless once shown
     announceScaffold(); // the startup scaffold line, if it arrived while a turn was running
     rl.prompt();
+    // #302, found live: prompt() puts the cursor at column 0, and a stopped turn's question is
+    // already in the line — so what was typed went IN FRONT of it and Ctrl+U erased nothing.
+    // The restored question is edited from its end, like a line just typed.
+    if (prefillFor) rl.cursor = rl.line.length;
     paintBar();
     if (!barPinned()) probeCaretRow(); // fallback path still needs the caret's absolute row
     // Absorb blank Enter-presses SILENTLY — they never reach the agent. Lines typed while
@@ -12678,9 +12920,12 @@ async function main() {
       await runSavePresetCommand(line);
       continue;
     }
-    // #322: /open-presets, and its old name /load-presets (older backups print it in their undo line)
-    if (line === "/open-presets" || line.startsWith("/open-presets ") || line === "/load-presets" || line.startsWith("/load-presets ")) {
-      await runLoadPresetsCommand(line);
+    if (line === "/open-presets" || line.startsWith("/open-presets ")) {
+      await runOpenPresetsCommand(line);
+      continue;
+    }
+    if (line === "/use-presets" || line.startsWith("/use-presets ")) {
+      await runUsePresetsCommand(line);
       continue;
     }
     if (line === "/save-settings" || line.startsWith("/save-settings ")) {
@@ -12774,6 +13019,10 @@ async function main() {
       );
       continue;
     }
+    if (line === "/prices" || line.startsWith("/prices ")) {
+      await runPricesCommand(line);
+      continue;
+    }
     if (line === "/tokens") {
       // Task #142: WHERE the last request's prompt went. The bar answers "how much is RAG";
       // this answers "and what displaced it", which is the part that tells you whether RAG is
@@ -12961,6 +13210,9 @@ async function main() {
     await saveSession(cwd, history, { unfinishedTask: isResumeWord(taskLine) ? "" : taskLine });
     try {
       const turnStartMs = Date.now();
+      // #323: priced by the coder this turn STARTS on — a /model switch afterwards must not put
+      // another model's price on it.
+      const turnCoder = { url: activeCodingUrl(), model: activeCodingModelId() };
       if (reattach) console.log(GUTTER + dim("following the turn that was running when the connection went…\n"));
       const turn = await runAgentTurn(history, reattach ? { attachJobId: reattach.jobId, ownJob: true } : {});
       // NOT SENT (licence block, or the token prompt declined): runAgentTurn already said so.
@@ -12983,6 +13235,8 @@ async function main() {
       lastTurnInputTokens = inputTokens ?? 0;
       lastTurnOutputTokens = turnOutputTokens ?? 0;
       lastTurnTotalOutput = outputTokens ?? 0;
+      // #323: what this turn's prompt tokens cost — on the token row and in /price.
+      void noteTurnCost(lastTurnInputTokens, lastPromptBreakdown, turnCoder);
       // A turn that FAILED carries the __TURN_FAILED__:: sentinel: the worker still delivers
       // the text (both UIs need to show it), but it is a failure notice, not a reply. Print
       // it as one and DROP it — persisting it would re-send "⚠️ your account is suspended" to