@tiens.nguyen/gu-cli 1.0.752 → 1.0.754

package/gonext_agent_chat.py

@@ -6633,6 +6633,92 @@ def _ws_delete_outside_reason(argv, wd, roots=None):
             + (" …" if len(outside) > 3 else "") + ")")
 
 
+# GU AS A CO-AUTHOR (task #289), the way Claude Code credits Claude: every commit the AGENT makes
+# ends with a trailer GitHub turns into a second author with gu's avatar. GitHub only does that
+# when the email belongs to an account — gu-marsic-agent's noreply address always does. Added by
+# run_command itself (after the risk gate, just before the spawn), not left to the model: a rule
+# in the prompt is followed most of the time. Only commits gu makes; the user's own are untouched.
+#
+# Settings, ~/.gonext/settings.json then <project>/.gonext/settings.json (the project wins):
+#     "attribution": {"commit": true, "pr": true, "name": "gu", "email": "…"}
+_ATTRIBUTION_DEFAULT = {"commit": True, "pr": True, "name": "gu",
+                        "email": "334027377+gu-marsic-agent@users.noreply.github.com"}
+_PR_FOOTER = "Generated with gu"
+_GIT_GLOBAL_WITH_VALUE = {"-C", "-c", "--git-dir", "--work-tree", "--namespace", "--exec-path",
+                          "--super-prefix", "--config-env"}
+
+
+def _attribution_settings(wd="", home=None, roots=None):
+    """The attribution settings in force for a command run in `wd`."""
+    out = dict(_ATTRIBUTION_DEFAULT)
+    home = home or os.path.expanduser("~")
+    places = [os.path.join(home, ".gonext", "settings.json")]
+    wd_real = os.path.realpath(wd) if wd else ""
+    for r in (_WS_ROOTS if roots is None else roots):
+        p = os.path.realpath(r.get("path") or "")
+        if p and wd_real and (wd_real == p or wd_real.startswith(p.rstrip(os.sep) + os.sep)):
+            places.append(os.path.join(p, ".gonext", "settings.json"))
+            break
+    for path in places:
+        try:
+            with open(path, encoding="utf-8") as fh:
+                a = (json.load(fh) or {}).get("attribution")
+        except (OSError, ValueError, AttributeError):
+            continue
+        if isinstance(a, dict):
+            out.update({k: v for k, v in a.items() if k in _ATTRIBUTION_DEFAULT})
+    return out
+
+
+def _git_subcommand(argv):
+    """(index, name) of git's subcommand in `argv`, skipping git's own options — or (-1, "")."""
+    if not argv or os.path.basename(argv[0]).lower() not in ("git", "git.exe"):
+        return -1, ""
+    i = 1
+    while i < len(argv):
+        a = argv[i]
+        if a in _GIT_GLOBAL_WITH_VALUE:
+            i += 2
+            continue
+        if a.startswith("-"):
+            i += 1
+            continue
+        return i, a
+    return -1, ""
+
+
+def _with_attribution(argv, settings):
+    """`argv` with gu credited, and a note for the log — or (argv, "") when nothing applies.
+
+    git commit → `--trailer "Co-Authored-By: gu <email>"` (git ≥ 2.32; git places it after any
+    other trailers and skips it when the same one is already last). Skipped when the message
+    already names that email (the model wrote it itself). gh pr create → a footer on --body.
+    """
+    argv = list(argv)
+    name = str(settings.get("name") or "").strip()
+    email = str(settings.get("email") or "").strip()
+    i, sub = _git_subcommand(argv)
+    if sub == "commit" and settings.get("commit") and name and email:
+        if any(email.lower() in str(a).lower() for a in argv[i + 1:]):
+            return argv, ""
+        return argv[:i + 1] + ["--trailer", f"Co-Authored-By: {name} <{email}>"] + argv[i + 1:], \
+            f"co-author trailer added ({name})"
+    if (argv[:3] == ["gh", "pr", "create"] or (argv and os.path.basename(argv[0]).lower() == "gh.exe"
+                                                and argv[1:3] == ["pr", "create"])) and settings.get("pr"):
+        for k, a in enumerate(argv):
+            if a in ("--body", "-b") and k + 1 < len(argv):
+                if _PR_FOOTER not in argv[k + 1]:
+                    argv[k + 1] = argv[k + 1].rstrip() + f"\n\n{_PR_FOOTER}"
+                    return argv, "PR footer added"
+                return argv, ""
+            if a.startswith("--body="):
+                if _PR_FOOTER not in a:
+                    argv[k] = a.rstrip() + f"\n\n{_PR_FOOTER}"
+                    return argv, "PR footer added"
+                return argv, ""
+    return argv, ""
+
+
 def _ws_command_risk(command, argv, denyset, wd=""):
     """Classify a command for the run policy. Returns (hard_reason, ask_reason), either
     None when N/A:
@@ -7125,21 +7211,69 @@ def _take_image_markers(messages, images_dir=None):
     return found
 
 
+# WHAT CLAUDE WILL TAKE (task #285). smolagents re-encodes every image as PNG, base64, before
+# sending (smolagents.utils.encode_image_base64) — so a 4 MB JPEG photo can become a PNG over the
+# 5 MB per-image limit, and then Claude rejects the WHOLE request, not just the image. Claude
+# also scales anything with a long edge over 1568 px down to that (and rejects > 8000 px), so
+# shrinking first sends the same picture Claude would see, in fewer bytes.
+_IMAGE_MAX_EDGE = 1568
+_IMAGE_MAX_B64 = 5 * 1024 * 1024  # measured on the base64 string — the stricter reading
+
+
+def _png_b64_len(im) -> int:
+    import io
+    buf = io.BytesIO()
+    im.save(buf, format="PNG")
+    return (len(buf.getvalue()) + 2) // 3 * 4
+
+
+def _prepare_image(path):
+    """Open `path` and return a PIL image Claude will accept, or raise ValueError(reason)."""
+    from PIL import Image
+    try:
+        with Image.open(path) as src:
+            src.load()  # a truncated or non-image file fails here, not later in the request
+            im = src.copy()
+    except Image.DecompressionBombError:
+        raise ValueError("too many pixels to open safely") from None
+    except Exception as e:  # noqa: BLE001
+        raise ValueError(f"not a readable image ({type(e).__name__})") from None
+    # Colour modes PNG cannot hold, or holds oddly: CMYK photos, 16-bit, float, palette.
+    if im.mode == "P":
+        im = im.convert("RGBA" if "transparency" in im.info else "RGB")
+    elif im.mode not in ("RGB", "RGBA", "L", "LA"):
+        im = im.convert("RGBA" if "A" in im.mode else "RGB")
+    if max(im.size) > _IMAGE_MAX_EDGE:
+        im.thumbnail((_IMAGE_MAX_EDGE, _IMAGE_MAX_EDGE), Image.LANCZOS)
+    while _png_b64_len(im) > _IMAGE_MAX_B64:
+        if max(im.size) <= 256:
+            raise ValueError("still over 5 MB after shrinking")
+        im = im.resize((max(1, im.width * 3 // 4), max(1, im.height * 3 // 4)), Image.LANCZOS)
+    return im
+
+
 def _load_turn_images(refs):
-    """[(label, path)] → PIL images, skipping any that will not open."""
-    out = []
+    """[(label, path)] → (PIL images ready for Claude, [(label, reason)] for the ones that failed)."""
+    out, failed = [], []
     try:
-        from PIL import Image
+        import PIL  # noqa: F401
     except Exception:  # noqa: BLE001
-        return out
+        return out, [(label, "image support (Pillow) is not installed") for label, _ in refs]
     for label, path in refs:
         try:
-            with Image.open(path) as im:
-                im.load()
-                out.append(im.copy())
-        except Exception as e:  # noqa: BLE001
-            _log(f"image {label}: could not open ({type(e).__name__})")
-    return out
+            out.append(_prepare_image(path))
+        except ValueError as e:
+            failed.append((label, str(e)))
+            _log(f"image {label}: not attached — {e}")
+    return out, failed
+
+
+def _label_failed_images(text, failed):
+    """Say which images did not make it, where the model reads their labels — a bare
+    "[Image #1]" with nothing attached invites the model to guess what it shows."""
+    for label, reason in failed:
+        text = text.replace(label, f"{label} (could not be opened: {reason})")
+    return text
 
 
 def run_agent_chat(cfg):
@@ -12228,6 +12362,11 @@ def run_agent_chat(cfg):
                 os.makedirs(logs_dir, exist_ok=True)
                 log_path = os.path.join(logs_dir, f"{_t.strftime('%Y%m%d-%H%M%S')}-{os.getpid()}.log")
                 log_fh = open(log_path, "wb")
+                # gu as a co-author on the commits it makes (task #289) — after every check
+                # above, which judged the command as the model wrote it.
+                argv, _attrib_note = _with_attribution(argv, _attribution_settings(wd))
+                if _attrib_note:
+                    _log(f"run_command: {_attrib_note}")
                 # Scrubbed env: repo scripts must never see worker secrets.
                 proc = subprocess.Popen(
                     argv, cwd=wd, env=_ws_scrubbed_env(),
@@ -12807,9 +12946,14 @@ def run_agent_chat(cfg):
         _turn_images = []
         if _turn_image_refs:
             if _is_anthropic_url(coding_base_url):
-                _turn_images = _load_turn_images(_turn_image_refs)
-                _log(f"attached {len(_turn_images)} image(s) to the question")
-                _emit({"type": "step", "text": f"Sending {len(_turn_images)} image(s) with the question"})
+                _turn_images, _img_failed = _load_turn_images(_turn_image_refs)
+                task_with_hint = _label_failed_images(task_with_hint, _img_failed)
+                _log(f"attached {len(_turn_images)} image(s) to the question"
+                     + (f", {len(_img_failed)} could not be opened" if _img_failed else ""))
+                if _turn_images:
+                    _emit({"type": "step", "text": f"Sending {len(_turn_images)} image(s) with the question"})
+                for _lbl, _why in _img_failed:
+                    _emit({"type": "step", "text": f"⚠ {_lbl} not sent — {_why}"})
             else:
                 task_with_hint += ("\n\n(The user pasted " + ", ".join(l for l, _ in _turn_image_refs)
                                    + " but this coding model is not sent images — say so if the "

package/gu-cli.mjs

@@ -111,9 +111,6 @@ gu-cli
 Usage:
   gu-cli
   gu-cli login [--api-base <url>]   # browser sign-in → writes ~/.gonext/worker.env
-  gu-cli full-log on|off|status [account] # administrators: Enable Full Log for an account (asks for
-                                           # an admin token from the web admin page first); status
-                                           # alone shows this computer's account, no token needed
   gu-cli token [<token>]                   # show this computer's gu token, or save one pasted from
                                                #   the Account page (Client Expert machines)
   gu-cli set <workerKey> [--api-base <url>]

package/gu-repl.mjs

@@ -128,7 +128,7 @@ import { unapprovedProjectServers } from "./mcp-command.mjs";
 import { readHooks } from "./hooks-config.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, clipboardImageToFile, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
+import { IMAGE_NEEDS_CLAUDE, clipboardImageToFile, fitImageNotice, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
 import {
   isDoubleClick,
   clickRun,
@@ -815,7 +815,6 @@ const COMMANDS = [
   { name: "/load-settings", usage: "/load-settings [name|path]", desc: "read that file back on another machine — picks from the settings files in your home folder, asks before it replaces anything" },
   { 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: "/full-log", usage: "/full-log [on|off|status] [account]", desc: "administrators: Enable Full Log for an account — asks for an admin token from the web admin page first" },
   // 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" },
@@ -1849,8 +1848,7 @@ function slashCloseSeq(line, cursor, cols) {
 let editMode = "accept"; // "accept" | "manual"
 const modeLineText = () =>
   white("✎ " + (editMode === "accept" ? "accept edits on" : "manually edit")) +
-  dim("   (shift+tab to switch)") +
-  (imageNotice ? "   " + orange("⚠ " + imageNotice) : "");
+  dim("   (shift+tab to switch)");
 // Token usage for the bar's middle row (task #104): the LAST turn's code-model input +
 // output, then the coder's lifetime output total. Unlike the old per-turn print, this row is
 // ALWAYS on screen — a turn that did no code-model work honestly reads "0", and the lifetime
@@ -1872,6 +1870,9 @@ let lastPromptBreakdown = null;
  * never leads it, so the screen never claims output that has not been produced.
  */
 let shownOutputTokens = 0;
+// The same for INPUT (#53): this turn's input so far — the bar's "sent" — shown as "↑ N" before
+// the "↓ N" output figure, so the thinking line reads both directions the way the bar does.
+let shownInputTokens = 0;
 // Seconds from Enter to the first full prompt reaching the coding model (prompt assembly +
 // retrieval). Shown by /tokens; 0 until a turn has run.
 let lastPromptAssemblySeconds = 0;
@@ -2298,6 +2299,10 @@ const footerRows = () =>
     identity: identityLineText(),
     token: tokenLineText(),
     mode: modeLineText(),
+    // Its own row (#54), sized to the window so the fix it names is never the part cut off.
+    notice: imageNotice
+      ? orange("⚠ " + fitImageNotice(imageNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
+      : "",
   });
 // True only while the MAIN loop's ">> " prompt is waiting for input. The bar belongs to that
 // prompt, so it must never appear under an ask()/askSecret() question or during a turn.
@@ -9644,8 +9649,12 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
     // what makes the climb visible at all. Parked (streaming) the block is not rebuilt, so the
     // figure holds rather than jittering against flowing output.
     shownOutputTokens = easeCount(shownOutputTokens, latestOutputTokens);
+    shownInputTokens = easeCount(shownInputTokens, latestCodeTokens);
+    // ↑ input (this turn's "sent", every request so far — cached input included: the model read
+    // it) then ↓ output (#53). Each absent until known, never a "0" that claims a measurement.
     const outLabel =
-      shownOutputTokens > 0 ? dim(" · ↓ ") + accent(fmtTokens(shownOutputTokens)) : "";
+      (shownInputTokens > 0 ? dim(" · ↑ ") + accent(fmtTokens(shownInputTokens)) : "") +
+      (shownOutputTokens > 0 ? dim(" · ↓ ") + accent(fmtTokens(shownOutputTokens)) : "");
     // Task #96: the thought line is "clickable" only when the fuller thought has MORE text than
     // fits on line 1 (a live command / bare "Thinking" / a thought that already fits has nothing
     // to reveal). Line 1 (what's happening now): a live command > the model's current Thought >
@@ -11712,7 +11721,7 @@ async function main() {
       console.log(GUTTER + dim("   Ctrl+C stops watching (it keeps running) · its answer is printed here, not added to this chat\n"));
       let stoppedWatching = false; // detached rather than watched to the end — see below
       try {
-        const { text: answer, shown: streamed, elapsedMs, turnOutputTokens, detached } =
+        const { text: answer, shown: streamed, elapsedMs, turnOutputTokens, detached, inputTokens } =
           await runAgentTurn(history, { attachJobId: jobId });
         stoppedWatching = Boolean(detached);
         if (answer && answer.startsWith(TURN_FAILED_PREFIX)) {
@@ -11725,6 +11734,7 @@ async function main() {
             const block = answerBlock({
               elapsedMs, answer: plain, worked: (turnOutputTokens ?? 0) > 0,
               gutter: GUTTER, dim, render: renderAnswer,
+              inputLabel: inputTokens > 0 ? fmtTokens(inputTokens) : "",
             });
             console.log(`${LINE_SPACING}${block.text}\n`);
             registerCopyBlock(block.rows, plain, 1);
@@ -11858,6 +11868,7 @@ async function main() {
           // two must come from one place, and for the empty line under "thought for …".
           const block = answerBlock({
             elapsedMs, answer: plain, worked, gutter: GUTTER, dim, render: renderAnswer,
+            inputLabel: inputTokens > 0 ? fmtTokens(inputTokens) : "",
           });
           console.log(`${LINE_SPACING}${block.text}\n`);
           // Register the SOURCE, not the rendering (task #158): renderAnswer hard-wraps the

package/image-paste.mjs

@@ -20,13 +20,47 @@
  *     most reliable way; Windows Terminal quotes a path with spaces.
  */
 import { spawnSync } from "node:child_process";
-import { chmodSync, copyFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, existsSync, mkdirSync, openSync, readSync, rmSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import path, { extname, join } from "node:path";
+import path, { join } from "node:path";
 
 export const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
-/** Anthropic's limit per image. A bigger one would fail the whole request. */
-export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+/**
+ * The largest file gu takes at paste time. NOT Claude's 5 MB limit: the agent shrinks every image
+ * to what Claude accepts before sending (task #285), so a 12 MB photo is fine. This only stops a
+ * file far too big to be a screenshot from being copied around.
+ */
+export const MAX_IMAGE_BYTES = 30 * 1024 * 1024;
+
+/**
+ * What the file's first bytes say it is — "png" | "jpeg" | "gif" | "webp" | "" (task #285). The
+ * EXTENSION is only a name: a renamed text file, or a screenshot still being written, has the
+ * right one and is not an image.
+ */
+export function imageKind(bytes) {
+  const b = Buffer.from(bytes ?? []);
+  if (b.length >= 8 && b.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "png";
+  if (b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return "jpeg";
+  if (b.length >= 6 && /^GIF8[79]a$/.test(b.subarray(0, 6).toString("latin1"))) return "gif";
+  if (b.length >= 12 && b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP") return "webp";
+  return "";
+}
+
+function fileImageKind(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    const buf = Buffer.alloc(12);
+    const n = readSync(fd, buf, 0, 12, 0);
+    return imageKind(buf.subarray(0, n));
+  } catch {
+    return "";
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+const NOT_AN_IMAGE = "that file is not an image (png, jpg, gif or webp)";
 
 export const imagesDir = (home = homedir()) => join(home, ".gonext", "images");
 
@@ -41,6 +75,19 @@ export function isClaudeCoderUrl(url) {
 
 export const IMAGE_NEEDS_CLAUDE =
   "image paste needs a Claude coding model — pick one with /model";
+/** The same, for a window too narrow for the full sentence: the fix (/model) must survive. */
+export const IMAGE_NEEDS_CLAUDE_SHORT = "images need a Claude coder — /model";
+
+/**
+ * The notice as it fits `cols` columns (#54): the full sentence, else its short form, else the
+ * short form clipped by the caller. Only the Claude warning has a short form; other notices
+ * ("no image on the clipboard…") are clipped as they are.
+ */
+export function fitImageNotice(text, cols) {
+  const t = String(text ?? "");
+  if (t === IMAGE_NEEDS_CLAUDE && [...t].length + 2 > cols) return IMAGE_NEEDS_CLAUDE_SHORT;
+  return t;
+}
 
 /** The key to name in hints on this platform (both work everywhere). */
 export const imagePasteKey = (platform = process.platform) => (platform === "win32" ? "Alt+V" : "Ctrl+V");
@@ -97,13 +144,15 @@ export function storeImageFile(src, { home = homedir() } = {}) {
     return { error: `cannot read ${src}` };
   }
   if (size > MAX_IMAGE_BYTES) return { error: tooBig(size) };
-  const dest = newImagePath(extname(src).toLowerCase() === ".jpeg" ? ".jpg" : extname(src).toLowerCase(), home);
+  const kind = fileImageKind(src);
+  if (!kind) return { error: NOT_AN_IMAGE };
+  const dest = newImagePath(kind === "jpeg" ? ".jpg" : `.${kind}`, home);
   copyFileSync(src, dest);
   chmodSync(dest, 0o600);
   return { path: dest };
 }
 
-const tooBig = (n) => `the image is ${(n / 1048576).toFixed(1)} MB — Claude accepts up to 5 MB`;
+const tooBig = (n) => `the image is ${(n / 1048576).toFixed(1)} MB — gu takes up to ${MAX_IMAGE_BYTES / 1048576} MB`;
 
 /** The command that writes the clipboard's image to `dest` as PNG, per platform (null = none). */
 export function clipboardImageCommand(dest, platform = process.platform) {
@@ -148,8 +197,19 @@ export function clipboardImageToFile({ home = homedir(), platform = process.plat
   } catch {
     /* nothing written */
   }
-  if (r?.status !== 0 || size === 0) return { none: true };
-  if (size > MAX_IMAGE_BYTES) return { error: tooBig(size) };
+  if (r?.status !== 0 || size === 0) {
+    rmSync(dest, { force: true });
+    return { none: true };
+  }
+  if (size > MAX_IMAGE_BYTES) {
+    rmSync(dest, { force: true });
+    return { error: tooBig(size) };
+  }
+  // A file copied in Explorer is copied as-is, so it can be anything with an image's name.
+  if (!fileImageKind(dest)) {
+    rmSync(dest, { force: true });
+    return { error: "the clipboard's file is not an image (png, jpg, gif or webp)" };
+  }
   chmodSync(dest, 0o600);
   return { path: dest };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.752",
+  "version": "1.0.754",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",

package/scripts/image-paste-check.mjs

@@ -62,7 +62,7 @@ const snippet = [
   "spec = importlib.util.spec_from_file_location('a', sys.argv[1]); a = importlib.util.module_from_spec(spec); spec.loader.exec_module(a)",
   "msgs = [{'role': 'user', 'content': 'look [Image #1: ' + sys.argv[2] + '] and [Image #2: ' + sys.argv[3] + ']'}]",
   "refs = a._take_image_markers(msgs)",
-  "imgs = a._load_turn_images(refs)",
+  "imgs, failed = a._load_turn_images(refs)",
   "print(json.dumps({'refs': refs, 'text': msgs[0]['content'], 'opened': len(imgs)}))",
 ].join("\n");
 const r = spawnSync(py.cmd, [...py.args, "-c", snippet, join(WORKER, "gonext_agent_chat.py"), stored.path ?? "", shot], {

package/terminal-layout.mjs

@@ -475,6 +475,7 @@ export function buildFooterRows({
   identity = "",
   token = "",
   mode = "",
+  notice = "",
 }) {
   const w = Math.max(20, width || 80);
   return [
@@ -483,6 +484,10 @@ export function buildFooterRows({
     ...(identity ? [clipVisible(gutter + identity, w - 1)] : []),
     clipVisible(gutter + token, w - 1),
     clipVisible(gutter + mode, w - 1),
+    // A passing notice (the image-paste warning, #54) gets its OWN row, under the mode row — it
+    // used to be appended to that row and was clipped at the right edge ("…pick one with /mo").
+    // Present only while it shows; paintBar re-cuts the frozen zone when the count changes.
+    ...(notice ? [clipVisible(gutter + notice, w - 1)] : []),
   ];
 }
 
@@ -1691,13 +1696,17 @@ export function answerBlock({
   dim = (x) => x,
   render = (x) => x,
   doneAt = Date.now(),
+  inputLabel = "",
 } = {}) {
   const rendered = render(worked ? `recap: ${answer}` : answer);
   const clock = formatClockTime(doneAt);
   // The stamp is DROPPED, not defaulted, when the time is unusable — "done Invalid Date" beside
-  // a correct duration is worse than no stamp at all.
+  // a correct duration is worse than no stamp at all. The same for the input figure (#53): the
+  // turn's total INPUT tokens, "(↑ 38.2k)", only when the backend reported them.
   const foot =
-    gutter + dim(`thought for ${formatThinkTime(elapsedMs)}${clock ? ` · done ${clock}` : ""}`);
+    gutter +
+    dim(`thought for ${formatThinkTime(elapsedMs)}${clock ? ` · done ${clock}` : ""}` +
+      (inputLabel ? ` (↑ ${inputLabel})` : ""));
   const text = `${rendered}\n\n${foot}`;
   return { text, rows: text.split("\n").length };
 }
@@ -2079,6 +2088,8 @@ export const HIDDEN_COMMANDS = [
   "/hover",                     // in-turn mouse capture — behaviour unchanged, just hidden
   "/reset",                     // the old name of /new (#278) — still works, one name is offered
   "/clear",                     // Claude Code's name for it — still works, likewise unlisted
+  "/full-log",                  // administrators only (#52): needs an ADMIN token from the web admin
+                                // page — typing it still works, and that token check is the gate
   "/reset-output-token-global", // pending a rename to /reset-global-token that also resets
                                 // the INPUT total — which does not exist yet as a counter
 ];