@tiens.nguyen/gu-cli 1.0.783 → 1.0.785

package/gu-repl.mjs

@@ -24,8 +24,8 @@
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
 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 +66,7 @@ import {
   formatThinkTime,
   plainAnswer,
   summarizeError,
+  tokenRowWithPrice,
   visibleLen,
   createProbeReplyReader,
   agentPickerItems,
@@ -125,12 +126,13 @@ import {
   rankSlashCommands,
   slashMenuWindow,
 } from "./terminal-layout.mjs";
-import { completedFlush } from "./completed-flush.mjs";
+import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
 import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
 import { unapprovedProjectServers } from "./mcp-command.mjs";
 import { readHooks } from "./hooks-config.mjs";
+import { readSkillSource, sourceLabel, SKILL_SOURCE_KEY } from "./skill-source.mjs";
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
 import { IMAGE_NEEDS_CLAUDE, coderTakesImagesFor, clipboardImageToFile, fitImageNotice, imageMarkersForDisplay, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
@@ -179,6 +181,8 @@ import {
   viewportSlice,
   paintViewportSeq,
   jumpToBottomRow,
+  zoneResizePlan,
+  blockClosedPad,
 } from "./terminal-viewport.mjs";
 
 const DIR = dirname(fileURLToPath(import.meta.url));
@@ -886,11 +890,13 @@ 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" },
   { name: "/hooks", usage: "/hooks [list|approve|unapprove]", desc: "hooks: commands gu runs on onStart, onAsk, onToolDone, onTurnEnd — list them, approve this project's" },
   { name: "/mcp", usage: "/mcp [list|tools|add|remove|enable|disable|approve|allow|disallow|reconnect]", desc: "MCP servers: see which connect, add one (asks step by step), choose which tools run without asking" },
+  { name: "/switch-skill", usage: "/switch-skill [claude|gu]", desc: "whose skills, MCP servers and hooks this folder uses — Claude Code's (.claude) or gu's own (.gonext)" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -1450,6 +1456,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 +1572,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 +2466,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 +2486,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 +2506,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.
@@ -2572,9 +2597,15 @@ const viewportHeight = () => Math.max(1, viewportRows() - barReserved);
  * Set by the active turn (it owns `statusShown`/`shownRows`), null between turns.
  */
 let liveOverlayRows = null;
-/** Rows the TRANSCRIPT actually gets: the scrolling area, less any live block under it. */
+/**
+ * Rows the TRANSCRIPT actually gets: the scrolling area, less any live block under it — and less
+ * the blank rows a closed picker or a shrunk zone left below the content (#321's pad, #324).
+ * Those rows hold nothing, exactly like the live block's: every screen-row → line mapping that
+ * forgot them was off by that many rows. Reported as the question echo landing on the line above
+ * it: the slash menu and the hover put rows BACK from a view that sat `pad` rows too low.
+ */
 const transcriptRows = () =>
-  Math.max(1, viewportHeight() - (liveOverlayRows ? liveOverlayRows() : 0));
+  Math.max(1, viewportHeight() - (liveOverlayRows ? liveOverlayRows() : 0) - livePad());
 // Rows the frozen zone occupies: the zone's head (the separator and the blank under it — see
 // INPUT_HEAD_ROWS) + the input line, then the bar's own rows (which grow by one under
 // --verbose). Everything that reserves, measures or paints the zone MUST use this — reserving
@@ -2590,10 +2621,23 @@ function pinBar() {
   const rows = frozenRowCount();
   // Re-cutting keeps the OUTPUT position that is already in the save slot (preserveCaret:false);
   // paintBar() below puts the caret back on the input line.
-  if (barPinned()) ui(scrollRegionSeq(viewportRows(), rows, { preserveCaret: false }));
+  const first = !barPinned();
+  if (!first) ui(scrollRegionSeq(viewportRows(), rows, { preserveCaret: false }));
   else ui(reserveRowsSeq(viewportRows(), rows) + OUT_SAVE); // …and remember where output goes
   barReserved = rows;
-  paintBar();
+  if (!first) {
+    paintBar();
+    return;
+  }
+  // THE FIRST PIN TAKES THE SCREEN INTO gu's HANDS (#321, #324): one repaint from the transcript,
+  // which also puts the OUTPUT POSITION at the end of the content. reserveRowsSeq leaves it on
+  // the region's LAST row — right when the screen is full, but after a short banner the content
+  // ends near the top, and every later height change is planned from where the content ends
+  // (zoneResizePlan). Left at the bottom, the two disagreed: the region was cut above the saved
+  // position and the next line — the question's echo — was written rows away from its place, on
+  // top of the line printed before it. No pad survives a repaint: the screen IS the model now.
+  padRows = 0;
+  paintLiveTail(); // ends in paintBar
 }
 /** Give the rows back and clear them — every exit path must reach this. */
 function unpinBar() {
@@ -2613,6 +2657,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 +2675,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 +2758,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 +2779,36 @@ 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) {
+    // #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 = !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);
     barReserved = zone.rows.length;
   }
   const top = viewportRows() - zone.rows.length + 1;
@@ -2749,19 +2828,16 @@ 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();
+  // NO REPAINT HERE: a height change moved the screen above (#321) — repainting it from the
+  // transcript is what filled the scrollback with copies. The one repaint is pinBar's, on the
+  // first pin.
 }
 /** 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 +2988,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 +3006,28 @@ 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);
+/** The pad right now — free when there is none, which is nearly always. */
+const livePad = () =>
+  padRows > 0 ? currentPad(displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length) : 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).
  *
@@ -3342,8 +3437,10 @@ let copyBadgeTimer = null;
 /** The transcript row currently under the viewport row `row`, as it should look. */
 function viewportRowText(row) {
   const width = Math.max(20, process.stdout.columns || 80);
+  // The view as it is ON SCREEN — pad rows included (#324), or every row comes back `pad` too low.
   const rows = displayRows(transcript.lines(), width - 1);
-  const view = viewportSlice(rows, scrollOffset, viewportHeight());
+  const pad = currentPad(rows.length);
+  const view = viewportSlice(pad ? [...rows, ...Array(pad).fill("")] : rows, scrollOffset, viewportHeight());
   const line = view.rows[row - 1];
   return typeof line === "string" ? line : "";
 }
@@ -3554,7 +3651,9 @@ function paintLiveTail() {
   // painted row down by the block's height so a selection highlight lands N rows away from the
   // text it belongs to. Between turns the block is gone, transcriptRows() === viewportHeight(),
   // and this is the behaviour it always had.
-  const height = transcriptRows();
+  // The pad rows are part of the screen (screenRows has them) but not of the transcript's rows.
+  const pad = livePad();
+  const height = transcriptRows() + pad;
   const view = viewportSlice(screenRows(), 0, height);
   ui(paintViewportSeq(view.rows, height, width, clipVisible, { preserveCaret: false }));
   // Park the caret at the end of the last printed line AND SAVE IT: the tail we just repainted
@@ -3565,8 +3664,9 @@ function paintLiveTail() {
   // that slot with the caret parked on the INPUT LINE. The next line printed after any scroll
   // round trip was then written at the prompt's column inside the frozen zone — on screen, a
   // question indented three columns to the right of every other line.
-  const lastRow = Math.max(1, view.rows.length);
-  const lastCol = Math.min(width, visibleLen(view.rows[view.rows.length - 1] ?? "") + 1);
+  // …the last CONTENT row: output continues above the pad, which it then fills (#324).
+  const lastRow = Math.max(1, view.rows.length - pad);
+  const lastCol = Math.min(width, visibleLen(view.rows[lastRow - 1] ?? "") + 1);
   ui(`\x1b[${lastRow};${lastCol}H` + OUT_SAVE);
   paintBar();
 }
@@ -3770,6 +3870,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 +4085,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);
@@ -7075,6 +7181,82 @@ async function afterStoppedTurn({ taskLine, submittedInput, turnStartMs, stopped
   if (barPinned()) paintBar();
 }
 
+/**
+ * /switch-skill — whose skills, MCP servers and hooks THIS FOLDER uses (task #325): Claude Code's,
+ * read where Claude keeps them (~/.claude, ./.claude, ~/.claude.json), or gu's own (~/.gonext,
+ * ./.gonext). One choice for all three — a skill names its MCP server's tools and the hooks feed
+ * the same database, so they only make sense together. Stored in the folder's session file, which
+ * the worker reads for every turn (skill-source.mjs): it holds from the next question, no restart.
+ */
+async function runSwitchSkillCommand(line) {
+  const cwd = resolve(process.cwd());
+  const current = readSkillSource(cwd);
+  const arg = (line.trim().split(/\s+/)[1] ?? "").toLowerCase();
+  const where = (src) => (src === "claude" ? "~/.claude, ./.claude, ~/.claude.json" : "~/.gonext, ./.gonext");
+  let pick = "";
+  console.log("");
+  if (arg) {
+    pick = /^claude/.test(arg) ? "claude" : arg === "gu" ? "gu" : "";
+    if (!pick) {
+      console.log(GUTTER + yellow(`"${arg}" is not one of them — /switch-skill claude  or  /switch-skill gu\n`));
+      return;
+    }
+  } else {
+    const options = ["claude", "gu"];
+    console.log(dim(`  Whose skills, MCP servers and hooks this folder uses  (${PICK_HINT}):`));
+    const idx = await pickFromList(
+      options.map((o) => sourceLabel(o) + dim(`  · ${where(o)}`) + (o === current ? dim("  · in use") : "")),
+      Math.max(0, options.indexOf(current))
+    );
+    if (idx < 0) {
+      console.log(dim("  (cancelled)\n"));
+      paintBar();
+      return;
+    }
+    pick = options[idx];
+  }
+  try {
+    await updateSessionFile(cwd, (raw) => {
+      raw[SKILL_SOURCE_KEY] = pick;
+      raw.updatedAt = new Date().toISOString();
+    });
+  } catch (err) {
+    console.log(GUTTER + red(`couldn't save the choice — ${err.message}. Nothing changed.\n`));
+    return;
+  }
+  _skillScan = { at: 0, skills: [] }; // the "/" menu and Tab follow at once
+  const say = (l) => console.log(GUTTER + l);
+  say(accent(`✓ ${pick === current ? "this folder uses" : "this folder now uses"} ${sourceLabel(pick)}`));
+  say(dim(`  skills, MCP servers and hooks are read from ${where(pick)}`));
+  // What was found there — and what was not, said rather than shown as an empty list.
+  try {
+    const sk = discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES });
+    const mcp = listMcpServers({ cwd: process.cwd() });
+    const hk = readHooks({ cwd: process.cwd() });
+    const nHooks = (h) => Object.values(h).reduce((a, groups) => a + groups.reduce((b, g) => b + g.hooks.length, 0), 0);
+    const count = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+    const running = mcp.servers.filter((x) => x.runnable).length;
+    say(dim(`  ${count(sk.skills.length, "skill")}${sk.skills.length ? ` (${sk.skills.map((x) => "/" + x.name).join(", ")})` : ""} · ${count(running, "MCP server")} · ${count(nHooks(hk.user) + (hk.projectApproved ? nHooks(hk.project) : 0), "hook")}`));
+    // Nothing there at all is a normal state, not a fault: say so, and that gu needs none of it.
+    if (!sk.skills.length && !mcp.servers.length && !nHooks(hk.user) && !nHooks(hk.project) && !hk.notes.length) {
+      say(dim("  Nothing is set up there yet — gu works the same without any of them."));
+    }
+    for (const w of [...sk.warnings, ...mcp.warnings, ...hk.warnings]) say(yellow("  " + w));
+    const unsupported = mcp.servers.filter((x) => x.error);
+    if (unsupported.length) say(yellow(`  ${count(unsupported.length, "MCP server")} cannot run here: ${unsupported.map((x) => `${x.name} (${x.error})`).join("; ")}`));
+    const waiting = mcp.servers.filter((x) => x.scope === "project" && !x.approved && !x.error);
+    if (waiting.length) say(yellow(`  ${count(waiting.length, "project MCP server")} waiting for your approval: ${waiting.map((x) => x.name).join(", ")} — /mcp approve <name>`));
+    if (hk.projectPending) say(yellow(`  this folder's ${hk.projectFile.replace(/^\.\//, "")} has hooks that will not run until you approve them — /hooks approve`));
+    if (hk.notes.length) say(yellow(`  ${count(hk.notes.length, "hook")} in Claude's settings ${hk.notes.length === 1 ? "is" : "are"} NOT run by gu — /hooks says which and why`));
+    if (pick === "claude" && (nHooks(hk.user) || nHooks(hk.project))) say(dim("  Claude's hooks get Claude's event and tool names from gu, so they record here as they do there."));
+  } catch (err) {
+    say(yellow(`  (could not read it back: ${err.message})`));
+  }
+  say(dim(`  It holds from your next question. ${pick === "claude" ? "/switch-skill gu" : "/switch-skill claude"} switches back.`));
+  console.log("");
+  if (barPinned()) paintBar();
+}
+
 /**
  * /undo — put back what a stopped turn changed (task #302): the last stopped turn's run, or the
  * run named. Shows exactly what it will do and asks first — a file edited by hand since the turn
@@ -7472,6 +7654,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).
  *
@@ -9236,6 +9607,8 @@ let forgetActiveStatus = null;
 // Ctrl+T reveal the full Thought from the KEYBOARD, so the feature doesn't depend on the mouse
 // capture that would block scrolling (see hoverMouse).
 let toggleActiveThought = null;
+/** #324: the screen under the Yes/No picker when it opened — the list picker's bookkeeping (#321). */
+let approvalOpenedOver = null;
 function drawApprovalOptions(redraw) {
   // Two option lines, redrawn in place. On redraw the cursor sits one row below "No";
   // step up 2 rows, clear+rewrite both, landing back where we started.
@@ -9245,11 +9618,24 @@ function drawApprovalOptions(redraw) {
   // each and the \x1b[2A count stays exact — which is why a resize can simply redraw here.
   const yes = approvalSel === 0 ? accent("▸ Yes") : dim("  Yes");
   const no = approvalSel === 1 ? accent("▸ No") : dim("  No");
+  if (!redraw && barPinned() && !scrolledBack()) {
+    const content = displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length;
+    approvalOpenedOver = { content, pad: currentPad(content), height: viewportHeight() };
+  }
   regionUi((redraw ? "\x1b[2A" : "") + "\x1b[K" + GUTTER + yes + "\n\x1b[K" + GUTTER + no + "\n");
 }
 function finishApproval(allow) {
   if (!approvalActive) return;
   approvalActive = false;
+  // #324: on a full screen the two option rows SCROLLED the conversation up by two, and the one
+  // result line below takes only one of them back — the content now ends a row above the region's
+  // bottom. Unrecorded, every row put back from the transcript afterwards (the slash menu, a
+  // hover) was drawn one row low, over its neighbour. Same account as a closed list picker.
+  const over = approvalOpenedOver;
+  approvalOpenedOver = null;
+  if (over && barPinned() && !scrolledBack() && over.height === viewportHeight()) {
+    setPad(blockClosedPad({ contentRows: over.content, pad: over.pad, height: over.height, blockRows: 2 }), over.content);
+  }
   // Settle the picker: overwrite the two option lines with a single result line.
   process.stdout.write("\x1b[2A\x1b[J" + GUTTER + (allow ? accent("▸ Yes — running it") : red("▸ No — skipped")) + "\n");
   const r = approvalResolve;
@@ -9457,6 +9843,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 +9879,14 @@ 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() };
+    listMaxRows = 0;
+  }
+  listMaxRows = Math.max(listMaxRows, physicalRows(rows, width));
   regionUi(
     (up ? `\x1b[${up}A` : "") +
       rows.map((r) => "\x1b[K" + r).join("\n") +
@@ -9504,6 +9901,13 @@ 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);
+  }
+  listOpenedOver = null;
+  listMaxRows = 0;
   listRowsDrawn = [];
   listTop = 0;
   const r = listResolve;
@@ -10383,6 +10787,8 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // completed resultText really EXTENDS what we streamed (an old worker replaces it
   // with the shorter bare answer, which must not be sliced by shownChars).
   let seenRaw = "";
+  // #326: where the live stream is relative to the <think> fence, carried from poll to poll.
+  let liveSplit = { inThink: false, held: "" };
 
   // --- Live in-progress ("blinking") bullet -------------------------------------------
   // The agent's raw Thought/code stream is SUPPRESSED (see the ~~~-fence handling in
@@ -11366,7 +11772,15 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         if (seenRaw.length < 4096) {
           seenRaw = (seenRaw + text.slice(shownChars)).slice(0, 4096);
         }
-        consume(text.slice(shownChars));
+        // #326: only the turn's WORK is shown live — the step lines and thoughts inside
+        // <think>. What follows the fence is the ANSWER, which the caller prints once from the
+        // completed text; fed to the step printer it came out as "●" bullets and then again
+        // under "recap:". A plain chat reply is the exception: its live stream IS its output.
+        const live = splitLiveStream(text.slice(shownChars), liveSplit);
+        liveSplit = live.state;
+        for (const part of live.parts) {
+          if (part.inside || plainReplyFlow) consume(part.text);
+        }
         shownChars = text.length;
       }
       // Interactive command-approval gate: the agent paused on a risky command. Show the
@@ -11940,7 +12354,11 @@ async function main() {
         const nSkills = currentSkills().length;
         const nMcp = listMcpServers({ cwd: process.cwd() }).servers.filter((x) => x.runnable).length;
         const bits = [nSkills ? `${nSkills} skill${nSkills === 1 ? "" : "s"}` : "", nMcp ? `${nMcp} MCP server${nMcp === 1 ? "" : "s"}` : ""].filter(Boolean);
-        if (bits.length) statusRows.push(dim(bits.join(" · ") + "  (/help · /mcp)"));
+        // #325: say whose they are when this folder uses Claude Code's — even when there are none.
+        const claudes = readSkillSource(process.cwd()) === "claude";
+        if (bits.length || claudes) {
+          statusRows.push(dim((claudes ? "Claude's: " : "") + (bits.join(" · ") || "no skills or MCP servers") + (claudes ? "  (/switch-skill · /mcp)" : "  (/help · /mcp)")));
+        }
       } catch {
         /* a broken file is reported below; the banner is not the place to fail */
       }
@@ -11957,7 +12375,7 @@ async function main() {
       for (const w of hk.warnings) console.log(GUTTER + yellow(w));
       if (hk.projectPending) {
         console.log(
-          GUTTER + yellow("This folder's .gonext/settings.json has hooks that will not run until you approve them.") +
+          GUTTER + yellow(`This folder's ${hk.projectFile.replace(/^\.\//, "")} has hooks that will not run until you approve them.`) +
             "\n" + GUTTER + dim("  /hooks shows the commands · /hooks approve")
         );
       }
@@ -12270,6 +12688,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 +12845,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
@@ -12589,6 +13014,10 @@ async function main() {
       await runMcpSlashCommand(line);
       continue;
     }
+    if (line === "/switch-skill" || line.startsWith("/switch-skill ")) {
+      await runSwitchSkillCommand(line);
+      continue;
+    }
     if (line === "/hooks" || line.startsWith("/hooks ")) {
       const { runHooksCommand } = await import("./hooks-command.mjs");
       const style = { ok: accent, warn: yellow, dim };
@@ -12718,6 +13147,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 +13338,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 +13363,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