@hncode/hncode 0.5.1 → 0.5.4

package/src/cache.js

@@ -1,131 +1,176 @@
-// Prompt caching — explicit cache breakpoints for long, stable prefixes.
-//
-// Why this is worth doing: an agent resends the whole conversation every turn,
-// and the prefix (system prompt + tool definitions + early messages) is
-// byte-identical across turns. Providers that support prompt caching bill those
-// tokens at a fraction of the input price and skip the prefill compute. Without
-// explicit breakpoints only the providers that cache automatically benefit.
-//
-// Protocol differences:
-//   * anthropic — explicit: mark up to N breakpoints with
-//     `cache_control: { type: "ephemeral" }`. Anthropic caches everything UP TO
-//     and INCLUDING a marked block, so the LAST breakpoint should sit at the end
-//     of the stable prefix. The minimum cacheable prefix is model-dependent
-//     (~1024 tokens); marking a shorter prefix is a no-op, not an error.
-//   * openai — automatic for prompts over ~1024 tokens on supporting models. A
-//     stable `prompt_cache_key` improves routing; keys must not vary per request.
-//   * everything else — no-op. Unknown providers are left untouched: sending an
-//     unsupported `cache_control` field can 400 some gateways.
-//
-// The cache is only useful when the prefix is STABLE, so the helpers here take
-// care to mark the same positions every turn for the same conversation.
-
-import { estimateTokens } from './term.js';
-
-// Anthropic allows at most 4 cache breakpoints per request.
-export const MAX_BREAKPOINTS = 4;
-// Below this, a breakpoint is pointless: most providers will not cache a prefix
-// this short, and the marker is wasted budget.
-export const MIN_CACHEABLE_TOKENS = 1024;
-
-export function supportsCaching(protocol) {
-  return protocol === 'anthropic' || protocol === 'openai' || protocol === 'responses';
-}
-
-// Index (into `messages`) of the last message that belongs to the STABLE prefix.
-//
-// The prefix is only cacheable while it cannot change between turns. The system
-// prompt and tool list are fixed for a session; the conversation then grows by
-// APPENDING. So the prefix is "everything except the recent tail", and the tail
-// must be excluded because it is what changes next turn.
-//
-// We keep the last `keepTail` messages out of the cached region: a tool result
-// appended this turn is not part of the stable prefix next turn until it is
-// itself superseded. Returns -1 when there is nothing worth marking.
-export function stablePrefixEnd(messages, keepTail = 2) {
-  const n = Array.isArray(messages) ? messages.length : 0;
-  if (n === 0) return -1;
-  // Never mark the very last message: it is the newest content and is the most
-  // likely to be replaced/regenerated.
-  const end = Math.min(n - 1, n - 1 - Math.max(1, keepTail));
-  return end >= 0 ? end : -1;
-}
-
-// Attach Anthropic `cache_control` breakpoints to a request body IN PLACE-safe
-// fashion (returns a new body). Breakpoints are placed:
-//   1. on the LAST tool definition (caches the whole tool block),
-//   2. on the system prompt (caches tools + system together),
-//   3. on the last message of the stable prefix (caches the conversation head).
-// Marking the tail first and working backwards keeps the total <= MAX_BREAKPOINTS.
-export function withAnthropicCache(body, opts = {}) {
-  if (!body || typeof body !== 'object') return body;
-  const minTokens = opts.minTokens || MIN_CACHEABLE_TOKENS;
-  const out = { ...body };
-  const marker = { type: 'ephemeral' };
-
-  // Tools: marking the last one caches the entire tools array.
-  if (Array.isArray(out.tools) && out.tools.length) {
-    const tools = out.tools.slice();
-    tools[tools.length - 1] = { ...tools[tools.length - 1], cache_control: marker };
-    out.tools = tools;
-  }
-
-  // System: a plain string must become a text block to carry cache_control.
-  if (typeof out.system === 'string' && out.system.trim()) {
-    out.system = [{ type: 'text', text: out.system, cache_control: marker }];
-  } else if (Array.isArray(out.system) && out.system.length) {
-    const sys = out.system.slice();
-    const last = sys.length - 1;
-    sys[last] = { ...(typeof sys[last] === 'string' ? { type: 'text', text: sys[last] } : sys[last]), cache_control: marker };
-    out.system = sys;
-  }
-
-  // Conversation head: mark the stable prefix's last message.
-  if (Array.isArray(out.messages) && out.messages.length) {
-    const end = stablePrefixEnd(out.messages, opts.keepTail);
-    if (end >= 0 && end < out.messages.length) {
-      // Only worth a breakpoint once the prefix is long enough to cache.
-      const prefixText = out.messages.slice(0, end + 1)
-        .map((m) => (typeof m.content === 'string' ? m.content
-          : Array.isArray(m.content) ? m.content.map((b) => b.text || '').join('') : ''))
-        .join('\n');
-      if (estimateTokens(prefixText) >= minTokens) {
-        const msgs = out.messages.slice();
-        const msg = { ...msgs[end] };
-        if (typeof msg.content === 'string') {
-          msg.content = [{ type: 'text', text: msg.content }];
-        }
-        if (Array.isArray(msg.content) && msg.content.length) {
-          const c = msg.content.slice();
-          const li = c.length - 1;
-          c[li] = { ...c[li], cache_control: marker };
-          msg.content = c;
-        }
-        msgs[end] = msg;
-        out.messages = msgs;
-      }
-    }
-  }
-  return out;
-}
-
-// OpenAI-compatible: most providers cache automatically. A STABLE
-// `prompt_cache_key` helps routing on the providers that accept it, and must not
-// change between turns of the same conversation or the cache thrashes.
-// `seed` should therefore identify the SESSION, not the request.
-export function withOpenAiCache(body, opts = {}) {
-  if (!body || typeof body !== 'object') return body;
-  const key = opts.sessionKey;
-  if (!key) return body;
-  return { ...body, prompt_cache_key: String(key) };
-}
-
-// Apply the right caching strategy for `protocol`. Returns the body unchanged
-// for protocols with no explicit support.
-export function applyPromptCache(protocol, body, opts = {}) {
-  if (!opts.enabled) return body;
-  if (protocol === 'anthropic') return withAnthropicCache(body, opts);
-  // Responses API accepts the same stable `prompt_cache_key` as chat/completions.
-  if (protocol === 'openai' || protocol === 'responses') return withOpenAiCache(body, opts);
-  return body;
+// Prompt caching — explicit cache breakpoints for long, stable prefixes.
+//
+// Why this is worth doing: an agent resends the whole conversation every turn,
+// and the prefix (system prompt + tool definitions + early messages) is
+// byte-identical across turns. Providers that support prompt caching bill those
+// tokens at a fraction of the input price and skip the prefill compute. Without
+// explicit breakpoints only the providers that cache automatically benefit.
+//
+// Protocol differences:
+//   * anthropic — explicit: mark up to N breakpoints with
+//     `cache_control: { type: "ephemeral" }`. Anthropic caches everything UP TO
+//     and INCLUDING a marked block, so the LAST breakpoint should sit at the end
+//     of the stable prefix. The minimum cacheable prefix is model-dependent
+//     (~1024 tokens); marking a shorter prefix is a no-op, not an error.
+//   * openai — automatic for prompts over ~1024 tokens on supporting models. A
+//     stable `prompt_cache_key` improves routing; keys must not vary per request.
+//   * everything else — no-op. Unknown providers are left untouched: sending an
+//     unsupported `cache_control` field can 400 some gateways.
+//
+// The cache is only useful when the prefix is STABLE, so the helpers here take
+// care to mark the same positions every turn for the same conversation.
+
+import { estimateTokens } from './term.js';
+
+// Anthropic allows at most 4 cache breakpoints per request.
+export const MAX_BREAKPOINTS = 4;
+// Below this, a breakpoint is pointless: most providers will not cache a prefix
+// this short, and the marker is wasted budget.
+export const MIN_CACHEABLE_TOKENS = 1024;
+
+export function supportsCaching(protocol) {
+  return protocol === 'anthropic' || protocol === 'openai' || protocol === 'responses';
+}
+
+// Index (into `messages`) of the last message that belongs to the STABLE prefix.
+// The prefix is only cacheable while it cannot change between turns. The system
+// prompt and tool list are fixed for a session; the conversation then grows by
+// APPENDING. So the prefix is "everything except the recent tail", and the tail
+// must be excluded because it is what changes next turn.
+//
+// We keep the last `keepTail` messages out of the cached region: a tool result
+// appended this turn is not part of the stable prefix next turn until it is
+// itself superseded. Returns -1 when there is nothing worth marking.
+export function stablePrefixEnd(messages, keepTail = 2) {
+  const n = Array.isArray(messages) ? messages.length : 0;
+  if (n === 0) return -1;
+  // Never mark the very last message: it is the newest content and is the most
+  // likely to be replaced/regenerated.
+  const end = Math.min(n - 1, n - 1 - Math.max(1, keepTail));
+  return end >= 0 ? end : -1;
+}
+
+// Attach Anthropic `cache_control` breakpoints to a request body IN PLACE-safe
+// Total character length of the prefix's content. `.length` is O(1) per string,
+// so this is O(#messages) — versus the full-string join plus the per-character
+// token walk the decision below used to make on EVERY request (and on every
+// retry attempt): ~1 MB of building and ~1M loop iterations on a 200k-token
+// history.
+function prefixContentLength(messages, end) {
+  let n = 0;
+  for (let i = 0; i <= end; i++) {
+    const c = messages[i] && messages[i].content;
+    if (typeof c === 'string') n += c.length;
+    else if (Array.isArray(c)) {
+      for (const b of c) if (b && typeof b.text === 'string') n += b.text.length;
+    }
+  }
+  return n;
+}
+
+// Memo of the last decision, keyed by `end:totalLength`. Tool-result trimming
+// rewrites content in place, which changes the length and so invalidates it.
+let _prefixDecision = { key: '', cacheable: false };
+
+// Attach Anthropic `cache_control` breakpoints to a request body IN PLACE-safe
+// fashion (returns a new body). Breakpoints are placed:
+//   1. on the LAST tool definition (caches the whole tool block),
+//   2. on the system prompt (caches tools + system together),
+//   3. on the last message of the stable prefix (caches the conversation head).
+// Marking the tail first and working backwards keeps the total <= MAX_BREAKPOINTS.
+//
+// `cacheEnd` is the index of the last message that belongs to the stable prefix,
+// counted by the CALLER. The agent loop knows it exactly — everything before that
+// index was already sent in an earlier request of this turn — so passing it beats
+// any guess made from the message count here.
+export function withAnthropicCache(body, opts = {}) {
+  if (!body || typeof body !== 'object') return body;
+  const minTokens = opts.minTokens || MIN_CACHEABLE_TOKENS;
+  const out = { ...body };
+  const marker = { type: 'ephemeral' };
+
+  // Tools: marking the last one caches the entire tools array.
+  if (Array.isArray(out.tools) && out.tools.length) {
+    const tools = out.tools.slice();
+    tools[tools.length - 1] = { ...tools[tools.length - 1], cache_control: marker };
+    out.tools = tools;
+  }
+
+  // System: a plain string must become a text block to carry cache_control.
+  if (typeof out.system === 'string' && out.system.trim()) {
+    out.system = [{ type: 'text', text: out.system, cache_control: marker }];
+  } else if (Array.isArray(out.system) && out.system.length) {
+    const sys = out.system.slice();
+    const last = sys.length - 1;
+    sys[last] = { ...(typeof sys[last] === 'string' ? { type: 'text', text: sys[last] } : sys[last]), cache_control: marker };
+    out.system = sys;
+  }
+
+  // Conversation head: mark the stable prefix's last message.
+  if (Array.isArray(out.messages) && out.messages.length) {
+    // The caller's boundary when it has one; otherwise fall back to counting off
+    // the tail. A caller's value ABOVE the last index means the array grew after it
+    // was taken, so it is clamped to the end rather than rejected — the prefix it
+    // describes is still the stable one, it just no longer reaches the tail.
+    const n = out.messages.length;
+    const end = Number.isInteger(opts.cacheEnd)
+      ? Math.min(n - 1, opts.cacheEnd)
+      : stablePrefixEnd(out.messages, opts.keepTail);
+    // An EMPTY prefix is not worth marking. With `cacheEnd === -1` the caller is
+    // saying "nothing has been sent yet", so every message in this request is new.
+    if (end >= 0 && end < n) {
+      // Only worth a breakpoint once the prefix is long enough to cache. Memoized
+      // on the length fingerprint; a cold decision uses ~4 chars/token — exact for
+      // ASCII code and prose, conservative for CJK (whose real token count is
+      // HIGHER than chars/4, so a marked prefix is always truly cacheable). Being
+      // wrong on the other side is a harmless no-op: the provider ignores a
+      // breakpoint on a sub-minimum prefix.
+      const plen = prefixContentLength(out.messages, end);
+      const key = `${end}:${plen}`;
+      let cacheable;
+      if (_prefixDecision.key === key) cacheable = _prefixDecision.cacheable;
+      else {
+        cacheable = plen / 4 >= minTokens;
+        _prefixDecision.key = key;
+        _prefixDecision.cacheable = cacheable;
+      }
+      if (cacheable) {
+        const msgs = out.messages.slice();
+        const msg = { ...msgs[end] };
+        if (typeof msg.content === 'string') {
+          msg.content = [{ type: 'text', text: msg.content }];
+        }
+        if (Array.isArray(msg.content) && msg.content.length) {
+          const c = msg.content.slice();
+          const li = c.length - 1;
+          c[li] = { ...c[li], cache_control: marker };
+          msg.content = c;
+        }
+        msgs[end] = msg;
+        out.messages = msgs;
+      }
+    }
+  }
+  return out;
+}
+
+// OpenAI-compatible: most providers cache automatically. A STABLE
+// `prompt_cache_key` helps routing on the providers that accept it, and must not
+// change between turns of the same conversation or the cache thrashes.
+// `seed` should therefore identify the SESSION, not the request.
+export function withOpenAiCache(body, opts = {}) {
+  if (!body || typeof body !== 'object') return body;
+  const key = opts.sessionKey;
+  if (!key) return body;
+  return { ...body, prompt_cache_key: String(key) };
+}
+
+// Apply the right caching strategy for `protocol`. Returns the body unchanged
+// for protocols with no explicit support.
+export function applyPromptCache(protocol, body, opts = {}) {
+  if (!opts.enabled) return body;
+  if (protocol === 'anthropic') return withAnthropicCache(body, opts);
+  // Responses API accepts the same stable `prompt_cache_key` as chat/completions.
+  if (protocol === 'openai' || protocol === 'responses') return withOpenAiCache(body, opts);
+  return body;
 }

package/src/cell-buffer.js

@@ -126,6 +126,11 @@ export function renderCells(cells) {
     }
     out += c.ch;
   }
+  // Close the LAST run too. Without this the final style stayed open past the end of the
+  // row, and a caller that concatenates rows — `drawFrameBuffer` does, once per line —
+  // carried it into the next one: a card drawn over a dimmed or highlighted row tinted
+  // every line below it, and the row's own trailing SGR was simply lost.
+  if (cur !== null && cur !== '') out += RESET;
   return out;
 }
 

package/src/clipboard.js

@@ -40,6 +40,8 @@ let helperBuf = '';     // stdout accumulated since the last sentinel
 let helperQueue = [];   // pending read() resolvers, ONE per sentinel written
 let helperBusy = false; // one command in flight at a time
 let helperReady = false; // the warm sequence has answered: the shell can take commands
+let keepAliveTimer = null; // a scheduled respawn, after the helper died
+let _shuttingDown = false; // set by the exit handler so a dead shell is not respawned during cleanup
 
 /** How long a read will wait for the helper to finish warming. It is already coming
  *  up, and waiting for a ~10ms answer beats the multi-second cold fallback. */
@@ -57,16 +59,34 @@ const ONESHOT_MS = 20000;
 
 function win() { return process.platform === 'win32'; }
 
-// ---------------------------------------------------------------- copy
+/**
+ * Put text on the clipboard.
+ *
+ * WINDOWS: `Set-Clipboard` through PowerShell, NOT `clip.exe`.
+ *
+ * `clip.exe` takes UTF-16LE and needed a byte order mark to be read correctly — without it
+ * non-ASCII arrived as mojibake (`中文测试` came back as `-N噀Km諎`, measured). But the mark is then
+ * part of the clipboard text: every copy began with a zero-width U+FEFF that showed up as a stray
+ * invisible character wherever it was pasted. Measured over six samples, `Set-Clipboard` was better
+ * on every one:
+ *
+ *     copied           clip.exe + BOM             Set-Clipboard
+ *     hello            U+FEFF hello               hello
+ *     中文测试          U+FEFF 中文测试             中文测试
+ *     line1\nline2     U+FEFF line1 CRLF line2    line1\nline2   (line endings untouched)
+ *     emoji 🎉 ok       U+FEFF emoji 🎉 ok         emoji 🎉 ok
+ *
+ * It also needs no escaping: PowerShell receives a .NET string rather than a byte stream, so there
+ * is no console parser to satisfy — which is what the BOM and the quoting were working around.
+ *
+ * `clip.exe` stays as a fallback for a machine with no PowerShell at all, where a copy carrying a
+ * stray BOM beats no copy.
+ */
 export function copyText(text) {
   const s = String(text == null ? '' : text);
   if (!s) return false;
   if (win()) {
-    // clip.exe takes UTF-16LE. (`cmd /c echo "…" | clip` mangled quotes, '%'
-    // and newlines; plain UTF-8 input turned non-ASCII into mojibake.) Prefix the
-    // UTF-16 byte order mark (FF FE) so clip.exe is never left to guess the endian
-    // or treat input as ANSI — without it, non-ASCII on some Windows versions /
-    // code pages came out mojibake.
+    if (setClipboardText(s)) return true;
     cp.execSync('clip', { input: Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(s, 'utf16le')]), windowsHide: true, timeout: 5000 });
     return true;
   }
@@ -75,6 +95,24 @@ export function copyText(text) {
   return true;
 }
 
+/** `Set-Clipboard` via PowerShell. False when no PowerShell can be run. */
+function setClipboardText(s) {
+  // The text travels as base64 so nothing in it can end the script or be re-parsed. A quoted
+  // PowerShell literal would need every `'` doubled, and a newline or a backtick in the text would
+  // otherwise change what the script means.
+  const b64 = Buffer.from(s, 'utf16le').toString('base64');
+  const full = 'Add-Type -AssemblyName System.Windows.Forms; '
+    + '[System.Windows.Forms.Clipboard]::SetText('
+    + `[System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String('${b64}')))`;
+  for (const exe of [_psExe, 'powershell']) {
+    try {
+      cp.execFileSync(exe, ['-NoProfile', '-NonInteractive', '-Command', full], { timeout: 10000, windowsHide: true });
+      return true;
+    } catch { /* try the next exe */ }
+  }
+  return false;
+}
+
 // Which PowerShell the helper runs. `pwsh` (7) starts far faster than the built-in
 // `powershell` (5.1) — measured 1.9s vs 11.5s for the same image probe — and the image
 // path needs the WinForms/Drawing assemblies. This is only the PREFERRED name: it is
@@ -99,9 +137,24 @@ function runPowershell(args, opts) {
 // ------------------------------------------------------- PowerShell helper
 export function warmClipboard() {
   if (!win() || helper) return;
+  _shuttingDown = false;   // an explicit warm cancels a shutdown in progress
   startHelper(_psExe);
 }
 
+/**
+ * Stop the keep-alive respawn and let the helper die with the process.
+ *
+ * Called from the exit handler. Without it a helper that exits during shutdown would be respawned by
+ * `dropHelper`, leaving a PowerShell child running after the TUI is gone.
+ */
+export function stopClipboardHelper() {
+  _shuttingDown = true;
+  if (keepAliveTimer) { clearTimeout(keepAliveTimer); keepAliveTimer = null; }
+  const h = helper;
+  dropHelper();
+  if (h) { try { h.stdin.end(); } catch { /* already closed */ } }
+}
+
 /** Spawn the long-lived shell. `exe` is tried first; if that exe does not exist,
  *  the spawn reports ENOENT on its `error` event and this retries with 5.1. */
 function startHelper(exe) {
@@ -153,6 +206,18 @@ function dropHelper() {
   const waiting = helperQueue;
   helperQueue = [];
   for (const w of waiting) w(null);
+  // RESPAWN, unless this is a deliberate shutdown.
+  //
+  // The helper can die without anyone noticing — a shell that exits on its own, a resource hiccup — and
+  // nothing restarted it. The next paste then paid the cold path: a fresh spawn plus the warm-up
+  // sentinel, measured at 1.2 seconds, on a keypress that is supposed to be instant.
+  //
+  // A respawn is scheduled rather than immediate so a crash loop cannot spin: the shell gets a moment to
+  // be gone before a new one is asked for. `_shuttingDown` stops it after cleanup.
+  if (!_shuttingDown) {
+    if (keepAliveTimer) clearTimeout(keepAliveTimer);
+    keepAliveTimer = setTimeout(() => { if (!_shuttingDown) warmClipboard(); }, 200);
+  }
 }
 
 /** Resolve once the shell can take commands, or false when it never got there. */
@@ -242,6 +307,24 @@ export async function readText(timeoutMs = HELPER_CMD_MS) {
 // in use here), so it silently failed everywhere and image paste never worked.
 // `[Windows.Forms.Clipboard]::GetImage()` exists on Windows PowerShell 5.1 AND
 // pwsh 7 — verified on 5.1 — so it is the portable way to read a copied image.
+/**
+ * The TEXT-ONLY probe, run first.
+ *
+ * The full probe below checks three clipboard formats in order — files, text, image — so a plain text
+ * paste pays for two failed checks before the one that answers. Text is overwhelmingly the common case,
+ * and the two other checks are the slow ones: `Get-Clipboard -Format FileDropList` round-trips through
+ * the shell's COM clipboard, and `Clipboard::GetImage()` decodes an image.
+ *
+ * So the text check is split out and run alone. Only when it comes back EMPTY — no text on the clipboard,
+ * so it must be a file or an image — does the caller run the full probe. A text paste now costs one
+ * clipboard call instead of three.
+ */
+const CLIP_PROBE_TEXT = [
+  "$ErrorActionPreference='SilentlyContinue'",
+  "$t=Get-Clipboard -Raw",
+  "if($t){'T::'+[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($t))}",
+].join('; ');
+
 const CLIP_PROBE = [
   "$ErrorActionPreference='SilentlyContinue'",
   "$f=Get-Clipboard -Format FileDropList",
@@ -315,9 +398,29 @@ async function readViaHelper() {
     await new Promise((r) => setTimeout(r, 25));
   }
   if (helperBusy || !helper) return null;
+
+  // TEXT FIRST. One clipboard call instead of the full probe's three, so the common paste answers in a
+  // third of the round-trips.
   helperBusy = true;
-  const out = await helperRun(CLIP_PROBE, HELPER_CMD_MS);
-  return out == null ? null : parseClipResult(out);
+  let out;
+  try {
+    out = await helperRun(CLIP_PROBE_TEXT, HELPER_CMD_MS);
+  } finally {
+    helperBusy = false;
+  }
+  const parsed = out == null ? null : parseClipResult(out);
+  // Text found — done. An EMPTY answer means there is no text, so the clipboard holds a file or an
+  // image and the full probe is worth its cost.
+  if (parsed) return parsed;
+
+  helperBusy = true;
+  let out2;
+  try {
+    out2 = await helperRun(CLIP_PROBE, HELPER_CMD_MS);
+  } finally {
+    helperBusy = false;
+  }
+  return out2 == null ? null : parseClipResult(out2);
 }
 
 export function readClipboardContent() {

package/src/context-bar.js

@@ -228,10 +228,51 @@ export function formatReadout(used, window, freeCols) {
   return '';
 }
 
-/** 1200 -> `1.2k`, 97000 -> `97.0k`, 3_400_000 -> `3.4M`. */
+/**
+ * A token count as a compact string: `1200` -> `1.2k`, `97000` -> `97k`, `3400000` -> `3.4M`.
+ *
+ * Deliberately the SAME shape `fmtTokensShort` produces for the working row, because both appear
+ * in one frame — the context bar and the live turn counter would otherwise disagree about the same
+ * quantity. Two rules:
+ *
+ *   * one decimal while it carries information, dropped when it is a zero (`97000` is `97k`, not
+ *     `97.0k` — the trailing `.0` is three characters saying nothing);
+ *   * K/M/B/T suffixes, with only the kilo lower-case, so `3.4M` here and `3.4M` on the working row
+ *     read as one vocabulary.
+ *
+ * The previous version kept `.0` and disagreed with the working row on units entirely: it divided
+ * by 1024 where the row divided by 1000, so a 97k context read `94.7k` beside a `97k` turn.
+ */
 export function compactTokens(n) {
-  const v = Number(n) || 0;
-  if (v >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
-  if (v >= 1e3) return `${(v / 1e3).toFixed(1)}k`;
-  return String(Math.round(v));
+  const v = Math.max(0, Math.floor(Number(n) || 0));
+  const units = [
+    { at: 1e12, suffix: 'T' },
+    { at: 1e9, suffix: 'B' },
+    { at: 1e6, suffix: 'M' },
+    { at: 1e3, suffix: 'k' },
+  ];
+  for (let i = 0; i < units.length; i++) {
+    const u = units[i];
+    if (v < u.at) continue;
+    // The identical scaling rule the working row and the /ctx readout use: one decimal below 100,
+    // whole numbers above. Three formatters render token counts into one frame, so a single rule is
+    // the only way `262k` cannot appear beside `262.1k` for the same quantity.
+    const shown = scaleUnit(v / u.at);
+    // Rounding can reach the next unit (`999999` is `1000k`, which is `1m`), and showing `1000k`
+    // makes the reader convert a unit themselves.
+    if (Number(shown) >= 1000 && i > 0) return `${scaleUnit(v / units[i - 1].at)}${units[i - 1].suffix}`;
+    return `${shown}${u.suffix}`;
+  }
+  return String(v);
+}
+
+/**
+ * One unit's worth of a count: `1.2`, `97`, `262`.
+ *
+ * Duplicated from tui.js rather than imported, because `context-bar.js` must stay a leaf module the
+ * TUI can import without a cycle. The two are pinned together by test/context-bar.test.mjs and
+ * test/working-tokens.test.mjs, which assert the same table of values through both.
+ */
+function scaleUnit(v) {
+  return v < 100 ? v.toFixed(1).replace(/\.0$/, '') : String(Math.round(v));
 }

package/src/doctor.js

@@ -306,8 +306,14 @@ function checkGit(workspace, cp) {
   const branch = run(['rev-parse', '--abbrev-ref', 'HEAD']);
   out.push(check('git', 'ok', `${branch || '(detached)'} in ${top}`));
 
+  // Because `run` pins cwd to the workspace, `config --get` reports the identity that a
+  // commit HERE would actually use — not one inherited from an unrelated directory.
+  // A value that IS set is reported too: only a row in the report distinguishes
+  // "configured" from "the check never ran", and silence reads as success.
   for (const key of ['user.name', 'user.email']) {
-    if (!run(['config', '--get', key])) {
+    const value = run(['config', '--get', key]);
+    if (value) out.push(check(`git ${key}`, 'ok', value));
+    else {
       out.push(check(`git ${key}`, 'warn', 'not set',
         `Every commit fails without it. Run: git config --global ${key} "…"`));
     }
@@ -324,7 +330,6 @@ function checkGit(workspace, cp) {
     }
   }
   return out;
-  return out;
 }
 
 /**