@tiens.nguyen/gu-cli 1.0.783 → 1.0.784

package/gu-cli.mjs

@@ -20,7 +20,7 @@ import { execFile as execFileCallback, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { writeFileSync, unlinkSync } from "node:fs";
 import { createTaskPool, createFolderQueue } from "./job-pools.mjs";
-import { NO_STEP, foldStepTokens, withStepTokens } from "./step-tokens.mjs";
+import { NO_STEP, foldStepTokens, withStepTokens, NO_CACHE, foldTurnCache, withTurnCache } from "./step-tokens.mjs";
 import { agentStoppedLine, jobEnded, jobStatusFrom409, stopGracefully } from "./agent-stop.mjs";
 import { ragJobConfig } from "./rag-job-config.mjs";
 import { codingKeyFallbackLine, isOllamaCloudUrl } from "./coding-key-prompt.mjs";
@@ -4138,6 +4138,9 @@ async function runAgentChatJob(job) {
     // Task #298: the CURRENT model call's own ↑ in / ↓ out, for the thinking line (the bar
     // already shows the totals). Rides on the breakdown — see step-tokens.mjs.
     let stepTokens = NO_STEP;
+    // #323: the turn's cached prompt tokens (when the provider reports them) and its first step's
+    // prompt — what the terminal needs to say what the turn COST. Rides on the breakdown too.
+    let turnCache = NO_CACHE;
     // Raw model-stream tokens (event.type === "stream") are Python code + `Thought:`
     // prose + <code>/<|"|> fragments. The web Thought panel renders reasoning as
     // markdown, which turns `#`-prefixed code comments into <h1> headings and
@@ -4305,17 +4308,20 @@ async function runAgentChatJob(job) {
         if (breakdown) latestPromptBreakdown = breakdown;
         const prevStep = stepTokens;
         stepTokens = foldStepTokens(stepTokens, event);
+        const prevCache = turnCache;
+        turnCache = foldTurnCache(turnCache, event);
+        const cacheChanged = turnCache.cached !== prevCache.cached || turnCache.firstIn !== prevCache.firstIn || turnCache.cacheReported !== prevCache.cacheReported;
         const stepChanged =
           stepTokens.step !== prevStep.step ||
           stepTokens.stepIn !== prevStep.stepIn ||
           stepTokens.stepOut !== prevStep.stepOut;
-        if (latestPromptBreakdown) latestPromptBreakdown = withStepTokens(latestPromptBreakdown, stepTokens);
+        if (latestPromptBreakdown) latestPromptBreakdown = withTurnCache(withStepTokens(latestPromptBreakdown, stepTokens), turnCache);
         if (
           nextTotal !== latestCodeTokens ||
           nextMax !== latestMaxCodeTokens ||
           nextOut !== latestCodeOutputTokens ||
           breakdown ||
-          (stepChanged && latestPromptBreakdown)
+          ((stepChanged || cacheChanged) && latestPromptBreakdown)
         ) {
           latestCodeTokens = nextTotal;
           latestMaxCodeTokens = nextMax;

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));
@@ -886,6 +891,7 @@ const COMMANDS = [
   { 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" },
@@ -998,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;
@@ -1450,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)
@@ -1561,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;
@@ -2454,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
@@ -2468,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.
@@ -2488,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.
@@ -2613,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()) {
@@ -2623,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)` });
@@ -2705,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) };
 }
@@ -2725,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;
@@ -2749,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`;
@@ -2912,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", () => {
@@ -2928,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).
  *
@@ -3770,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.
@@ -3982,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);
@@ -7472,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).
  *
@@ -9457,6 +9730,9 @@ let listDeleteRequested = false;
 // /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
@@ -9490,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") +
@@ -9504,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;
@@ -12270,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();
@@ -12424,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
@@ -12718,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
@@ -12905,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.
@@ -12927,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

package/model-prices.mjs

@@ -0,0 +1,484 @@
+/**
+ * MODEL PRICES AND WHAT A TURN COST (#323).
+ *
+ * The user: "estimate cost of USD after each turn" — from each provider's price per 1 million INPUT
+ * tokens (output ignored for now, but stored so turning it on needs no migration), with the cheaper
+ * CACHED-input price for the part of each step the provider served from its prompt cache.
+ *
+ * HOW MUCH WAS CACHED. The agent reads the provider's own count when it reports one (OpenAI
+ * usage.prompt_tokens_details.cached_tokens, Anthropic cache_read_input_tokens, Kimi cached_tokens
+ * — see _cached_tokens_from_usage in gonext_agent_chat.py) and the cost then uses it: "$0.04".
+ * When nothing is reported, gu ASSUMES 90% of every step after the first was cached — what the
+ * user sees on the Kimi and Claude consoles for gu's turns — and says so: "~$0.04".
+ *
+ * Prices live in the user's own Mongo (one row per server + model, via the local API); this file is
+ * pure — the table it ships (PRICE_TABLE) is what an empty Mongo is seeded with, and what the Deploy
+ * app's "Prices" button exports for the admin to publish.
+ */
+
+export const PRICE_TABLE_VERSION = "1.0";
+/** Of a step after the first, the share assumed served from the cache when the provider says nothing. */
+export const ASSUMED_CACHED_SHARE = 0.9;
+export const MAX_PRICE_ROWS = 500;
+const MAX_PRICE = 1000; // USD per 1M tokens — anything above is a typo (per-token, per-1k…)
+
+const ANTHROPIC = "https://platform.claude.com/docs/en/about-claude/pricing";
+const OPENAI = "https://developers.openai.com/api/docs/pricing";
+const KIMI = "https://platform.kimi.ai/docs/pricing/chat";
+const OLLAMA = "https://ollama.com/pricing";
+const CHECKED = "2026-10-01";
+
+/** [host, model, input, cachedInput, output, cacheWrite?] — USD per 1M tokens. */
+const ROWS = [
+  // Anthropic — cache write (5 minutes) is 1.25× input; gu does not price writes yet (noted per row).
+  ["api.anthropic.com", "claude-fable-5-1", 10, 0.25, 50, 12.5],
+  ["api.anthropic.com", "claude-opus-5-5", 4, 0.2, 20, 5],
+  ["api.anthropic.com", "claude-opus-5", 5, 0.5, 25, 6.25],
+  ["api.anthropic.com", "claude-opus-4-8", 5, 0.5, 25, 6.25],
+  ["api.anthropic.com", "claude-sonnet-5-5", 2, 0.2, 10, 2.5],
+  ["api.anthropic.com", "claude-sonnet-5", 2, 0.2, 10, 2.5],
+  ["api.anthropic.com", "claude-sonnet-4-6", 3, 0.3, 15, 3.75],
+  ["api.anthropic.com", "claude-sonnet-4-5", 3, 0.3, 15, 3.75],
+  ["api.anthropic.com", "claude-haiku-4-5", 1, 0.1, 5, 1.25],
+  // OpenAI (standard tier)
+  ["api.openai.com", "gpt-6-astra", 10, 1, 50],
+  ["api.openai.com", "gpt-6.1-sol", 2, 0.1, 10],
+  ["api.openai.com", "gpt-6-sol", 2, 0.2, 10],
+  ["api.openai.com", "gpt-6-luna", 0.1, 0.01, 0.5],
+  ["api.openai.com", "gpt-5.6-sol", 4, 0.4, 20],
+  ["api.openai.com", "gpt-5.6-terra", 2, 0.2, 12],
+  ["api.openai.com", "gpt-5.6-luna", 0.2, 0.02, 1.2],
+  ["api.openai.com", "gpt-5.5", 5, 0.5, 30],
+  ["api.openai.com", "gpt-5.4", 2.5, 0.25, 15],
+  ["api.openai.com", "gpt-5.3-codex", 1.75, 0.175, 14],
+  ["api.openai.com", "gpt-5.2", 1.75, 0.175, 14],
+  ["api.openai.com", "gpt-5.1", 1.25, 0.125, 10],
+  ["api.openai.com", "gpt-5", 1.25, 0.125, 10],
+  ["api.openai.com", "gpt-4.1", 2, 0.5, 8],
+  ["api.openai.com", "gpt-4o", 2.5, 1.25, 10],
+  // Moonshot / Kimi
+  ["api.moonshot.ai", "kimi-k3", 3, 0.3, 15, 3], // cache write (5 min) = the input price
+  ["api.moonshot.ai", "kimi-k2.7-code", 0.95, 0.19, 4],
+  ["api.moonshot.ai", "kimi-k2.7-code-highspeed", 1.9, 0.38, 8],
+  ["api.moonshot.ai", "kimi-k2.6", 0.95, 0.16, 4],
+  // Ollama cloud — pay-as-you-go credits (peak price; off-peak is about half)
+  ["ollama.com", "kimi-k3", 3, 0.3, 15],
+  ["ollama.com", "kimi-k2.7-code", 0.95, 0.19, 4],
+  ["ollama.com", "kimi-k2.6", 0.95, 0.16, 4],
+  ["ollama.com", "glm-5.3", 1.4, 0.26, 4.4],
+  ["ollama.com", "glm-5.3-flash", 0.15, 0.03, 0.5],
+  ["ollama.com", "glm-5.2", 1.4, 0.26, 4.4],
+  ["ollama.com", "deepseek-v4-pro", 1.32, 0.044, 3.96],
+  ["ollama.com", "deepseek-v4.1-flash", 0.3, 0.006, 1.2],
+  ["ollama.com", "minimax-m3", 0.6, 0.12, 2.4],
+  ["ollama.com", "minimax-m2.7", 0.3, 0.06, 1.2],
+  ["ollama.com", "gpt-oss:120b", 0.15, 0.014, 0.6],
+  ["ollama.com", "gpt-oss:20b", 0.07, 0.035, 0.3],
+  ["ollama.com", "gemma4", 0.14, 0.05, 0.4],
+  ["ollama.com", "mistral-large-3", 0.5, null, 1.5],
+  ["ollama.com", "nemotron-3-nano", 0.06, null, 0.24],
+  ["ollama.com", "nemotron-3-super", 0.015, 0.015, 0.6],
+  ["ollama.com", "nemotron-3-ultra", 0.1, 0.1, 3],
+];
+const PROVIDER = { "api.anthropic.com": "Anthropic", "api.openai.com": "OpenAI", "api.moonshot.ai": "Moonshot (Kimi)", "ollama.com": "Ollama cloud" };
+const SOURCE = { "api.anthropic.com": ANTHROPIC, "api.openai.com": OPENAI, "api.moonshot.ai": KIMI, "ollama.com": OLLAMA };
+
+/** The table gu ships — what an empty Mongo is seeded with and what the Deploy app exports. */
+export const PRICE_TABLE = Object.freeze({
+  gu: "prices",
+  version: PRICE_TABLE_VERSION,
+  publishedAt: CHECKED,
+  currency: "USD",
+  unit: "per 1M tokens",
+  note: "input = uncached prompt tokens; cachedInput = prompt tokens served from the provider's cache; output is stored but not yet used. Anthropic cache writes (cacheWrite) are not priced yet. Ollama cloud: peak prices — off-peak is about half.",
+  prices: ROWS.map(([host, model, input, cachedInput, output, cacheWrite]) => ({
+    provider: PROVIDER[host],
+    host,
+    model,
+    input,
+    cachedInput,
+    output,
+    ...(cacheWrite != null ? { cacheWrite } : {}),
+    // Used only when the provider does not report its cached count: Kimi and OpenAI cache prompt
+    // prefixes automatically; Anthropic only when the request asks (gu's Claude path does); Ollama
+    // cloud lists cache prices. No cache price → no discount, so no share.
+    ...(cachedInput != null ? { assumedCacheShare: ASSUMED_CACHED_SHARE } : {}),
+    source: SOURCE[host],
+    checkedAt: CHECKED,
+  })),
+});
+
+// ---------------------------------------------------------------------------------------------
+// keys and lookup
+// ---------------------------------------------------------------------------------------------
+
+/** A server URL (or bare host) → its host: "https://api.moonshot.ai/v1/" → "api.moonshot.ai". */
+export function hostOf(urlOrHost) {
+  const raw = String(urlOrHost ?? "").trim();
+  if (!raw) return "";
+  try {
+    return new URL(raw.includes("://") ? raw : `https://${raw}`).host.toLowerCase();
+  } catch {
+    return raw.replace(/^[a-z]+:\/\//i, "").replace(/\/.*$/, "").toLowerCase();
+  }
+}
+
+/** One row's identity: host + model, lower-cased. */
+export const priceKey = (host, model) => `${hostOf(host)}|${String(model ?? "").trim().toLowerCase()}`;
+
+/**
+ * The price for a server + model, or null. Exact first; then without a dated suffix
+ * ("claude-haiku-4-5-20251001" → "claude-haiku-4-5"); then without an Ollama tag ("kimi-k3:cloud",
+ * "kimi-k3:latest" → "kimi-k3"). Never a different host — the same model costs differently there.
+ */
+export function findPrice(rows, url, model) {
+  const host = hostOf(url);
+  const m = String(model ?? "").trim().toLowerCase();
+  if (!host || !m || !Array.isArray(rows)) return null;
+  const byKey = new Map(rows.map((r) => [priceKey(r.host, r.model), r]));
+  const tries = [m, m.replace(/-\d{8}$/, ""), m.replace(/:(cloud|latest)$/, "")];
+  for (const t of tries) {
+    const r = byKey.get(`${host}|${t}`);
+    if (r) return r;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------------------------
+// what a turn cost
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The input cost of one turn.
+ *   input          prompt tokens sent, summed over every step of the turn
+ *   cached         prompt tokens the provider served from its cache (summed), when it reported them
+ *   cacheReported  whether the provider reported a cached count at all
+ *   firstIn        the first step's prompt tokens (nothing is cached on the first step of a turn)
+ * → { usd, estimated, cachedTokens } — or null when there is no price (never a misleading $0).
+ */
+export function turnCost({ input = 0, cached = 0, cacheReported = false, firstIn = 0, price, assumedShare } = {}) {
+  if (!price || !Number.isFinite(price.input)) return null;
+  // The row's own assumption wins (providers cache differently), else the 90% default.
+  const share = Number.isFinite(assumedShare) ? assumedShare
+    : Number.isFinite(price.assumedCacheShare) ? price.assumedCacheShare
+    : ASSUMED_CACHED_SHARE;
+  const sent = Math.max(0, Number(input) || 0);
+  let cachedTokens;
+  let estimated = false;
+  if (cacheReported) {
+    cachedTokens = Math.min(sent, Math.max(0, Number(cached) || 0));
+  } else {
+    cachedTokens = Math.round(Math.min(1, Math.max(0, share)) * Math.max(0, sent - Math.max(0, Number(firstIn) || 0)));
+    estimated = cachedTokens > 0;
+  }
+  const cachedRate = Number.isFinite(price.cachedInput) ? price.cachedInput : price.input; // no cache price → no discount
+  const usd = ((sent - cachedTokens) * price.input + cachedTokens * cachedRate) / 1e6;
+  return { usd, estimated, cachedTokens };
+}
+
+/** "$1.23", "$0.123", "$0.0042"; "~" in front when the cached share was assumed. */
+export function formatUsd(usd, { estimated = false } = {}) {
+  if (!Number.isFinite(usd)) return "";
+  const v = Math.max(0, usd);
+  const s = v >= 1 ? v.toFixed(2) : v >= 0.01 ? v.toFixed(3) : v > 0 ? v.toFixed(4) : "0";
+  return `${estimated ? "~" : ""}$${s}`;
+}
+
+// ---------------------------------------------------------------------------------------------
+// checking a price table (the published one, before it is applied)
+// ---------------------------------------------------------------------------------------------
+
+const ROW_FIELDS = new Set(["provider", "host", "url", "model", "input", "cachedInput", "output", "cacheWrite", "assumedCacheShare", "source", "checkedAt", "remove"]);
+const price = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= MAX_PRICE);
+
+/**
+ * Check a price table (the shape PRICE_TABLE has; a bare array of rows is accepted too).
+ * → { ok, version, rows, removes, warnings } | { ok: false, problem }.
+ * A row with "remove": true deletes that server + model — nothing is ever deleted otherwise.
+ */
+export function validatePriceTable(input) {
+  let doc = input;
+  if (typeof input === "string") {
+    const src = input.replace(/^[ \t]*\/\/.*$/gm, "");
+    if (!src.trim()) return { ok: false, empty: true, problem: "nothing was pasted." };
+    try {
+      doc = JSON.parse(src);
+    } catch (e) {
+      return { ok: false, problem: `that is not valid JSON — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$/, "")}.` };
+    }
+  }
+  const list = Array.isArray(doc) ? doc : doc?.prices;
+  if (!Array.isArray(list)) return { ok: false, problem: 'expected { "prices": [ … ] } or a list of rows.' };
+  if (list.length === 0) return { ok: false, problem: "the table has no rows." };
+  if (list.length > MAX_PRICE_ROWS) return { ok: false, problem: `${list.length} rows — at most ${MAX_PRICE_ROWS}.` };
+  const version = !Array.isArray(doc) && doc.version != null ? String(doc.version).slice(0, 40) : "";
+  const rows = [];
+  const removes = [];
+  const warnings = [];
+  const seen = new Set();
+  for (let i = 0; i < list.length; i++) {
+    const r = list[i];
+    const at = `row ${i + 1}`;
+    if (!r || typeof r !== "object" || Array.isArray(r)) return { ok: false, problem: `${at} is not an object.` };
+    const host = hostOf(r.host ?? r.url);
+    const model = typeof r.model === "string" ? r.model.trim() : "";
+    if (!host) return { ok: false, problem: `${at} needs "host" (or "url") — the server it is priced on.` };
+    if (!model || model.length > 120) return { ok: false, problem: `${at} needs "model" (at most 120 characters).` };
+    const key = priceKey(host, model);
+    if (seen.has(key)) return { ok: false, problem: `${at}: ${host} ${model} appears twice.` };
+    seen.add(key);
+    const extra = Object.keys(r).filter((k) => !ROW_FIELDS.has(k));
+    if (extra.length) warnings.push(`${at} (${model}): ignored ${extra.map((k) => `"${k}"`).join(", ")}`);
+    if (r.remove === true) {
+      removes.push({ host, model });
+      continue;
+    }
+    if (!(typeof r.input === "number" && price(r.input))) {
+      return { ok: false, problem: `${at} (${model}): "input" must be a number of USD per 1M tokens, 0 to ${MAX_PRICE}.` };
+    }
+    for (const f of ["cachedInput", "output", "cacheWrite"]) {
+      if (r[f] !== undefined && !price(r[f])) return { ok: false, problem: `${at} (${model}): "${f}" must be a number 0 to ${MAX_PRICE}, or null.` };
+    }
+    if (r.assumedCacheShare !== undefined && !(typeof r.assumedCacheShare === "number" && r.assumedCacheShare >= 0 && r.assumedCacheShare <= 1)) {
+      return { ok: false, problem: `${at} (${model}): "assumedCacheShare" must be a number from 0 to 1 (0.9 = 90%).` };
+    }
+    if (typeof r.cachedInput === "number" && r.cachedInput > r.input) warnings.push(`${at} (${model}): cachedInput is MORE than input — check it`);
+    rows.push({
+      ...(typeof r.provider === "string" && r.provider.trim() ? { provider: r.provider.trim().slice(0, 60) } : {}),
+      host,
+      model,
+      input: r.input,
+      cachedInput: r.cachedInput ?? null,
+      output: r.output ?? null,
+      ...(typeof r.cacheWrite === "number" ? { cacheWrite: r.cacheWrite } : {}),
+      ...(typeof r.assumedCacheShare === "number" ? { assumedCacheShare: r.assumedCacheShare } : {}),
+      ...(typeof r.source === "string" && /^https?:\/\//.test(r.source) ? { source: r.source.slice(0, 300) } : {}),
+      ...(typeof r.checkedAt === "string" && !Number.isNaN(Date.parse(r.checkedAt)) ? { checkedAt: r.checkedAt.slice(0, 30) } : {}),
+    });
+  }
+  return { ok: true, version, rows, removes, warnings };
+}
+
+const COMPARED = ["input", "cachedInput", "output", "cacheWrite", "assumedCacheShare", "provider"];
+
+/** What applying `incoming` to `current` would do. → { added, changed:[{row, was, fields}], unchanged, removed, missingRemoves } */
+export function diffPrices(current, incoming, removes = []) {
+  const now = new Map((current ?? []).map((r) => [priceKey(r.host, r.model), r]));
+  const added = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const r of incoming) {
+    const was = now.get(priceKey(r.host, r.model));
+    if (!was) {
+      added.push(r);
+      continue;
+    }
+    const fields = COMPARED.filter((f) => (r[f] ?? null) !== (was[f] ?? null) && !(f === "provider" && r[f] == null));
+    if (fields.length) changed.push({ row: r, was, fields });
+    else unchanged++;
+  }
+  const removed = removes.filter((x) => now.has(priceKey(x.host, x.model)));
+  const missingRemoves = removes.filter((x) => !now.has(priceKey(x.host, x.model)));
+  return { added, changed, unchanged, removed, missingRemoves };
+}
+
+/** The diff as lines, for the "apply? [y/N]" question. */
+export function diffLines(d) {
+  const p = (v) => (v == null ? "—" : `$${v}`);
+  const out = [];
+  for (const r of d.added) out.push(`+ ${r.host}  ${r.model}  in ${p(r.input)} · cached ${p(r.cachedInput)}`);
+  const pct = (v) => (v == null ? "—" : `${Math.round(v * 100)}%`);
+  const show = (f, v) => (f === "assumedCacheShare" ? pct(v) : p(v));
+  for (const c of d.changed) out.push(`~ ${c.row.host}  ${c.row.model}  ${c.fields.map((f) => (f === "provider" ? `provider → ${c.row.provider}` : `${f} ${show(f, c.was[f])} → ${show(f, c.row[f])}`)).join(", ")}`);
+  for (const r of d.removed) out.push(`- ${r.host}  ${r.model}  (removed)`);
+  out.push(`${d.added.length} new · ${d.changed.length} changed · ${d.unchanged} unchanged${d.removed.length ? ` · ${d.removed.length} removed` : ""}`);
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// /price
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The table for /price, grouped by server, newest-first nowhere — alphabetical, so a model is easy
+ * to find. `current` = { url, model } of the coder in use: its row is marked "▸".
+ * Columns: model · input · cached · output (USD per 1M). Fits `width` (80 on a server over SSH).
+ */
+export function priceTableLines(rows, { width = 80, current = null, version = "" } = {}) {
+  const cur = current ? findPrice(rows, current.url, current.model) : null;
+  const money = (v) => (v == null ? "—" : `$${Number(v) < 0.1 && v !== 0 ? Number(v).toString() : Number(v).toFixed(2)}`);
+  const numW = 9;
+  const modelW = Math.max(12, Math.min(34, width - 4 - 2 - numW * 3));
+  const cut = (s, w) => (s.length > w ? s.slice(0, w - 1) + "…" : s.padEnd(w));
+  const out = [`USD per 1M tokens${version ? ` · table v${version}` : ""}`];
+  out.push(`  ${"model".padEnd(modelW)}${"input".padStart(numW)}${"cached".padStart(numW)}${"output".padStart(numW)}`);
+  const hosts = [...new Set(rows.map((r) => r.host))].sort();
+  for (const h of hosts) {
+    const group = rows.filter((r) => r.host === h).sort((a, b) => a.model.localeCompare(b.model));
+    out.push(`${h}${group[0]?.provider ? `  (${group[0].provider})` : ""}`);
+    for (const r of group) {
+      out.push(`${r === cur ? "▸ " : "  "}${cut(r.model, modelW)}${money(r.input).padStart(numW)}${money(r.cachedInput).padStart(numW)}${money(r.output).padStart(numW)}`);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// THE ASSUMED-CACHE-SHARE TABLE (#323 follow-up) — its own table so the admin can review and
+// publish it on its own (Deploy app → "Cache shares" → Update to API), and users can read it with
+// /prices. Made FROM the price table (the rows that have a cache price), so the two cannot
+// disagree.
+// ---------------------------------------------------------------------------------------------
+
+/** Why each provider's share is what it is — shown beside the number, so it can be reviewed. */
+export const CACHE_SHARE_WHY = Object.freeze({
+  "api.moonshot.ai": "automatic prefix caching (Kimi reports cached_tokens)",
+  "api.openai.com": "automatic prefix caching for prompts ≥ 1024 tokens (reports cached_tokens)",
+  "api.anthropic.com": "cached only when the request asks — gu's Claude path does (reports cache reads)",
+  "ollama.com": "lists cache prices; whether it reports a count is not yet verified",
+});
+
+export const CACHE_SHARE_TABLE = Object.freeze({
+  gu: "cache-shares",
+  version: PRICE_TABLE_VERSION,
+  publishedAt: PRICE_TABLE.publishedAt,
+  note: "The share of a step's prompt (after a turn's first step) assumed served from the provider's cache, used ONLY when the provider does not report its own cached count. 0.9 = 90%.",
+  shares: PRICE_TABLE.prices
+    .filter((r) => r.cachedInput != null)
+    .map((r) => ({ provider: r.provider, host: r.host, model: r.model, assumedCacheShare: r.assumedCacheShare ?? ASSUMED_CACHED_SHARE, why: CACHE_SHARE_WHY[r.host] ?? "" })),
+});
+
+/** Check a cache-share table → { ok, version, shares } | { ok: false, problem }. */
+export function validateCacheShareTable(input) {
+  let doc = input;
+  if (typeof input === "string") {
+    try {
+      doc = JSON.parse(input.replace(/^[ \t]*\/\/.*$/gm, ""));
+    } catch (e) {
+      return { ok: false, problem: `that is not valid JSON — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$/, "")}.` };
+    }
+  }
+  const list = Array.isArray(doc) ? doc : doc?.shares;
+  if (!Array.isArray(list) || list.length === 0) return { ok: false, problem: 'expected { "shares": [ … ] } with at least one row.' };
+  if (list.length > MAX_PRICE_ROWS) return { ok: false, problem: `${list.length} rows — at most ${MAX_PRICE_ROWS}.` };
+  const seen = new Set();
+  const shares = [];
+  for (const [i, r] of list.entries()) {
+    const at = `row ${i + 1}`;
+    const host = hostOf(r?.host ?? r?.url);
+    const model = typeof r?.model === "string" ? r.model.trim() : "";
+    if (!host || !model) return { ok: false, problem: `${at} needs "host" and "model".` };
+    if (!(typeof r.assumedCacheShare === "number" && r.assumedCacheShare >= 0 && r.assumedCacheShare <= 1)) {
+      return { ok: false, problem: `${at} (${model}): "assumedCacheShare" must be a number from 0 to 1 (0.9 = 90%).` };
+    }
+    const key = priceKey(host, model);
+    if (seen.has(key)) return { ok: false, problem: `${at}: ${host} ${model} appears twice.` };
+    seen.add(key);
+    shares.push({
+      ...(typeof r.provider === "string" && r.provider.trim() ? { provider: r.provider.trim().slice(0, 60) } : {}),
+      host,
+      model,
+      assumedCacheShare: r.assumedCacheShare,
+      ...(typeof r.why === "string" && r.why.trim() ? { why: r.why.trim().slice(0, 200) } : {}),
+    });
+  }
+  const version = !Array.isArray(doc) && doc.version != null ? String(doc.version).slice(0, 40) : "";
+  return { ok: true, version, shares };
+}
+
+/**
+ * The cache table in /prices: the share each model is assumed to cache — THIS ACCOUNT's (its price rows, what its
+ * estimates use) beside the one gu PUBLISHED (when the API has one), marking where they differ.
+ * Fits `width`; the coder in use is marked "▸".
+ */
+export function cacheShareLines({ yours = [], published = null, width = 80, current = null } = {}) {
+  const pub = new Map((published?.shares ?? []).map((s) => [priceKey(s.host, s.model), s.assumedCacheShare]));
+  const mine = (yours ?? []).filter((r) => r.cachedInput != null || pub.has(priceKey(r.host, r.model)));
+  const cur = current ? findPrice(mine, current.url, current.model) : null;
+  const pct = (v) => (Number.isFinite(v) ? `${Math.round(v * 100)}%` : "—");
+  const colW = 8;
+  const modelW = Math.max(12, Math.min(34, width - 4 - 2 - colW * 2 - 2));
+  const cut = (s, w) => (s.length > w ? s.slice(0, w - 1) + "…" : s.padEnd(w));
+  const out = [];
+  out.push(`  ${"model".padEnd(modelW)}${"yours".padStart(colW)}${published ? "gu".padStart(colW) : ""}`);
+  const keys = new Set([...mine.map((r) => priceKey(r.host, r.model)), ...pub.keys()]);
+  const rows = [...keys].map((k) => {
+    const r = mine.find((x) => priceKey(x.host, x.model) === k);
+    const s = published?.shares?.find((x) => priceKey(x.host, x.model) === k);
+    return { host: r?.host ?? s.host, model: r?.model ?? s.model, yours: r ? (Number.isFinite(r.assumedCacheShare) ? r.assumedCacheShare : ASSUMED_CACHED_SHARE) : undefined, gu: pub.get(k), row: r };
+  });
+  for (const h of [...new Set(rows.map((r) => r.host))].sort()) {
+    out.push(h);
+    for (const r of rows.filter((x) => x.host === h).sort((a, b) => a.model.localeCompare(b.model))) {
+      const differs = published && r.gu !== undefined && r.yours !== undefined && Math.abs(r.gu - r.yours) > 1e-9;
+      out.push(`${r.row && r.row === cur ? "▸ " : "  "}${cut(r.model, modelW)}${pct(r.yours).padStart(colW)}${published ? pct(r.gu).padStart(colW) : ""}${differs ? " *" : ""}`);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// "NEW PRICES UPDATED <date>" (#323): gu checks the hosted API's GET /api/get-price-and-cache-table
+// (the newest tables the admin published from the Deploy app); when they are newer than what this
+// account last applied, the notice row offers them, and a click writes both into the user's Mongo.
+// ---------------------------------------------------------------------------------------------
+
+/** Is the published stamp newer than the one this account applied? ("" applied = never.) */
+export function hasNewerPublished(appliedAt, publishedAt) {
+  const p = Date.parse(publishedAt ?? "");
+  if (!Number.isFinite(p)) return false;
+  const a = Date.parse(appliedAt ?? "");
+  return !Number.isFinite(a) || p > a;
+}
+
+/** The notice: "new prices updated 1 Oct 2026". */
+export function priceUpdateLabel(publishedAt) {
+  const d = new Date(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()}`;
+}
+
+/**
+ * The published tables onto this account's rows → what to write.
+ *   · the published PRICE table's rows replace the same server + model here (others are kept —
+ *     a self-hosted server priced by hand stays);
+ *   · the published CACHE table's share is set on each matching row (published price rows and the
+ *     account's own);
+ *   · nothing is deleted.
+ * → { ok, rows: the rows that change (to PUT), diff, version, publishedAt } | { ok: false, problem }
+ */
+export function mergePublishedTables(current, cloud) {
+  const pub = cloud ?? {};
+  const priceRows = [];
+  if (pub.prices) {
+    const c = validatePriceTable(pub.prices);
+    if (!c.ok) return { ok: false, problem: `the published price table is not usable — ${c.problem}` };
+    priceRows.push(...c.rows);
+  }
+  let shares = [];
+  if (pub.cacheShares) {
+    const c = validateCacheShareTable(pub.cacheShares);
+    if (!c.ok) return { ok: false, problem: `the published cache table is not usable — ${c.problem}` };
+    shares = c.shares;
+  }
+  if (!priceRows.length && !shares.length) return { ok: false, problem: "nothing has been published yet." };
+  const share = new Map(shares.map((s) => [priceKey(s.host, s.model), s.assumedCacheShare]));
+  const byKey = new Map((current ?? []).map((r) => [priceKey(r.host, r.model), { ...r }]));
+  for (const r of priceRows) {
+    const was = byKey.get(priceKey(r.host, r.model));
+    // A published price row without its own share keeps the one this account has, until the cache
+    // table says otherwise.
+    byKey.set(priceKey(r.host, r.model), { ...r, ...(r.assumedCacheShare == null && was?.assumedCacheShare != null ? { assumedCacheShare: was.assumedCacheShare } : {}) });
+  }
+  for (const [k, row] of byKey) if (share.has(k) && row.cachedInput != null) row.assumedCacheShare = share.get(k);
+  const merged = [...byKey.values()];
+  const diff = diffPrices(current ?? [], merged);
+  return {
+    ok: true,
+    rows: [...diff.added, ...diff.changed.map((c) => c.row)],
+    diff,
+    version: pub.prices?.version || pub.cacheShares?.version || "",
+    publishedAt: pub.publishedAt || [pub.prices?.publishedAt, pub.cacheShares?.publishedAt].filter(Boolean).sort().at(-1) || "",
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.783",
+  "version": "1.0.784",
   "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",
@@ -69,6 +69,7 @@
     "image-capable-coders.json",
     "preset-editor.mjs",
     "preset-apply.mjs",
+    "model-prices.mjs",
     "device-login.mjs",
     "daemon-control.mjs",
     "log-policy.mjs",

package/step-tokens.mjs

@@ -53,3 +53,48 @@ export function readStepTokens(breakdown) {
   const n = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
   return { step, stepIn: n(breakdown.liveStepIn), stepOut: n(breakdown.liveStepOut) };
 }
+
+// ---------------------------------------------------------------------------------------------
+// WHAT THE TURN COST needs two more figures (#323), riding the same breakdown for the same reason:
+//   · liveCached / liveCacheReported — the prompt tokens the provider served from its cache, summed
+//     over the turn (python's `codeCached`, present ONLY when the provider reported a count);
+//   · liveFirstIn — the first step's prompt: nothing is cached on it, so when the provider reports
+//     nothing, gu assumes 90% of every LATER step was cached (model-prices.mjs).
+// ---------------------------------------------------------------------------------------------
+
+/** The turn's cache figures before any event. */
+export const NO_CACHE = Object.freeze({ cached: 0, cacheReported: false, firstIn: 0, firstStep: 0 });
+
+/** Fold one python "tokens" event into the turn's cache figures. */
+export function foldTurnCache(prev, event) {
+  let { cached, cacheReported, firstIn, firstStep } = prev ?? NO_CACHE;
+  if (!event || typeof event !== "object") return { cached, cacheReported, firstIn, firstStep };
+  if (Number.isFinite(event.codeCached) && event.codeCached >= 0) {
+    cacheReported = true;
+    if (event.codeCached > cached) cached = event.codeCached;
+  }
+  const step = Number.isFinite(event.step) ? event.step : 0;
+  if (step > 0 && (firstStep === 0 || step < firstStep)) {
+    firstStep = step;
+    firstIn = 0;
+  }
+  if (step > 0 && step === firstStep && Number.isFinite(event.stepInput) && event.stepInput > firstIn) firstIn = event.stepInput;
+  return { cached, cacheReported, firstIn, firstStep };
+}
+
+/** The breakdown, carrying the turn's cache figures. */
+export function withTurnCache(breakdown, c) {
+  if (!breakdown || typeof breakdown !== "object" || !c) return breakdown;
+  return {
+    ...breakdown,
+    liveFirstIn: c.firstIn,
+    ...(c.cacheReported ? { liveCached: c.cached, liveCacheReported: true } : {}),
+  };
+}
+
+/** What the terminal reads back: { cached, cacheReported, firstIn }, or null from an older worker. */
+export function readTurnCache(breakdown) {
+  if (!breakdown || typeof breakdown !== "object" || !("liveFirstIn" in breakdown)) return null;
+  const n = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
+  return { cached: n(breakdown.liveCached), cacheReported: breakdown.liveCacheReported === true, firstIn: n(breakdown.liveFirstIn) };
+}

package/terminal-layout.mjs

@@ -2852,3 +2852,17 @@ export function noticeRow(items, { width = 80, gutter = "   ", sep = "  ·  " }
   });
   return { row, spans };
 }
+
+/**
+ * THE TURN'S PRICE AT THE END OF THE TOKEN ROW (#323): "↑ sent 500k · ↓ out 4.3k · total ↓ 1.6M | ~$0.33".
+ *
+ * The row is clipped on the RIGHT at the window's width, and the price is the last thing on it — so
+ * on a narrow window (80 columns over SSH) it would be the first thing lost. When the whole row does
+ * not fit, the lifetime "total ↓" goes first (it changes no decision about this turn); the price
+ * stays. `price` = the already-painted " | ~$0.33" segment, or "" when the model has no price.
+ */
+export function tokenRowWithPrice({ withTotal = "", withoutTotal = "", price = "", room = 80 } = {}) {
+  if (!price) return withTotal;
+  if (visibleLen(withTotal) + visibleLen(price) <= room) return withTotal + price;
+  return withoutTotal + price;
+}

package/terminal-viewport.mjs

@@ -674,3 +674,68 @@ export function applySelectionHighlight(rows, sel, sgr = SELECTION_SGR) {
     return highlightRow(row, from, to, sgr);
   });
 }
+
+/**
+ * WHEN THE FROZEN ZONE CHANGES HEIGHT (#321) — move the screen the way a terminal would, instead of
+ * repainting it from the transcript.
+ *
+ * Reported: after an update, the banner and the update notice appeared again and again in the
+ * scrollback, and single lines ("auto-test off", "1 skill · 1 MCP server") were doubled. The cause
+ * was the repaint that followed every height change of the bottom zone (a picker, the notice row,
+ * the status block coming and going):
+ *   · the zone SHRANK → the region grew → the repaint filled the new rows at the TOP with older
+ *     transcript lines — lines the terminal had ALREADY scrolled into its scrollback. The next
+ *     output scrolled them in again: one more copy per shrink;
+ *   · the zone GREW → the repaint painted over the top rows, which never reached the scrollback.
+ *
+ * Now:
+ *   · GROW by k: the k rows the zone takes come out of the blank rows below the content first; for
+ *     the rest, the region is scrolled up (real newlines), so the top lines go into the scrollback
+ *     ONCE, the normal way;
+ *   · SHRINK by k: the content stays where it is and the k freed rows are cleared; they are
+ *     remembered as blank rows below the content ("pad"), which new output fills first.
+ * gu's model of the screen is the transcript's rows plus `pad` blank rows, bottom-aligned once it
+ * fills the region and top-aligned before (viewportSlice), so it matches without a repaint.
+ *
+ * → { scrollUp, clearRows, pad }: lines to scroll the OLD region up by, rows to clear below the old
+ *   region (the freed rows), and the new pad.
+ */
+export function zoneResizePlan({ contentRows = 0, pad = 0, oldHeight, newHeight }) {
+  const c = Math.max(0, contentRows | 0);
+  const p = Math.max(0, pad | 0);
+  const oldH = Math.max(1, oldHeight | 0);
+  const newH = Math.max(1, newHeight | 0);
+  const full = c + p >= oldH; // bottom-aligned (the region is full) vs top-aligned
+  if (newH >= oldH) {
+    const k = newH - oldH;
+    return { scrollUp: 0, clearRows: k, pad: full ? p + k : p };
+  }
+  const k = oldH - newH;
+  const blanks = full ? p : oldH - c; // rows at the bottom holding nothing
+  const fromBlank = Math.min(blanks, k);
+  const scrollUp = k - fromBlank;
+  if (scrollUp > 0) return { scrollUp, clearRows: 0, pad: 0 };
+  return { scrollUp: 0, clearRows: 0, pad: full ? p - fromBlank : Math.max(0, Math.min(p, newH - c)) };
+}
+
+/**
+ * A BLOCK DRAWN BELOW THE CONTENT AND WIPED AGAIN — a picker (#321). Its rows are not transcript
+ * content, but drawing them can scroll the region: whatever scrolled away is in the terminal's
+ * scrollback now. Wiping the block leaves the content shifted up by that much with blank rows under
+ * it — recorded as pad, so no later repaint brings the scrolled-away lines back (each one would
+ * land in the scrollback a second time).
+ *   contentRows  the transcript's rows when the block was first drawn (its last is the cursor row)
+ *   pad          the blank rows below the content then (gu's pad)
+ *   height       the region's rows
+ *   blockRows    the most physical rows the block drew (it ends with a newline)
+ * → the pad after the wipe.
+ */
+export function blockClosedPad({ contentRows = 0, pad = 0, height, blockRows = 0 }) {
+  const c = Math.max(0, contentRows | 0);
+  const p = Math.max(0, pad | 0);
+  const h = Math.max(1, height | 0);
+  const full = c + p >= h;
+  const blanks = full ? p : h - c; // rows below the cursor row's region that hold nothing
+  const scrolled = Math.max(0, (blockRows | 0) - blanks);
+  return full || scrolled > 0 ? blanks + scrolled : p;
+}

package/turn-stop.mjs

@@ -55,6 +55,23 @@ export function replaceStoppedQuestion(history, oldTask, newTask) {
   return true;
 }
 
+/**
+ * Has the user LET GO of the restored question? (task #247 meets #302)
+ *
+ * The line going EMPTY is "never mind", however it was emptied — Ctrl+C, Backspace, Ctrl+U, a
+ * picker taking the line. Only Ctrl+C used to count, so erasing the question and typing "where
+ * were we?" was taken for an EDIT of it: the message replaced the stopped question in history and
+ * the model was asked where we were with nothing before it — the report #247 began with.
+ * What is typed after that is a new message; the stopped question stays, tagged "still stands".
+ *
+ * Enter is not an emptying: readline has already cleared the line it is submitting by the time
+ * the keypress is seen.
+ */
+export function restoredQuestionLetGo(line, key) {
+  if (key && (key.name === "return" || key.name === "enter")) return false;
+  return String(line ?? "") === "";
+}
+
 /** Short relative names for the stop note: the last two path parts. */
 function shortPath(p) {
   const parts = String(p ?? "").split(/[\\/]/).filter(Boolean);