ucode-agent 1.9.0 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/loop.js

@@ -65,6 +65,32 @@ const MAX_ARG_RETRIES = 2;
 const MAX_CONTINUATIONS = 3;
 
 /** Read-only tools whose result line adds nothing — the user saw the output. */
+/**
+ * How many rows a diff adds and removes.
+ *
+ * The rows come through as "+12| text" and "-12| text", with a "~" heading
+ * for each file in a multi-file write and an undecorated note counting what
+ * was elided. Only the signs are counted.
+ */
+export function countDiff(rows = []) {
+  let added = 0;
+  let removed = 0;
+  for (const row of rows) {
+    const line = String(row ?? '');
+    if (line.startsWith('~')) continue;
+    // "… 218 more removed" / "… 508 more added" stand for rows not shown.
+    const more = /^\s*[….]+\s*(\d+)\s+more\s+(added|removed)/.exec(line);
+    if (more) {
+      if (more[2] === 'added') added += Number(more[1]);
+      else removed += Number(more[1]);
+      continue;
+    }
+    if (line.startsWith('+')) added++;
+    else if (line.startsWith('-')) removed++;
+  }
+  return { added, removed };
+}
+
 const QUIET = new Set(['read_file', 'read_files', 'list_dir', 'glob', 'grep', 'web_search', 'update_plan']);
 
 /** Tools that draw their own line, so they get no "● Doing X" line of their own. */
@@ -408,6 +434,11 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '',
     '## How to work',
     '',
+    'Say what you are about to do, in one short line, before you do it — "now the',
+    'tests", "wiring this into the loop". A line like that before a group of actions is',
+    'what makes the work readable. Keep it to a sentence: the narration is not the',
+    'answer, and three sentences of intent before every step reads as stalling.',
+    '',
     'Before you guess at an API, ask: type_of gives the exact signature from the',
     'TypeScript this project has installed, and find_symbol says where something is declared without',
     'reading five files to find it. Rename with rename_symbol rather than edit_file — a',
@@ -566,6 +597,42 @@ export class Agent {
     this.working.push(message);
   }
 
+  /**
+   * Answer every tool call a stopped turn never got to.
+   *
+   * An assistant message ends by asking for tools, and each of those asks
+   * needs an answer. Abandon them and the conversation is left mid-sentence,
+   * so the next time the model reads it the only sensible thing to do is
+   * carry on where it left off — which is exactly what the user pressed stop
+   * to prevent. Saying "this did not happen" for each one ends the sentence,
+   * and a line from the user ends the task.
+   */
+  closeInterrupted() {
+    const answered = new Set(this.working.filter((m) => m.role === 'tool').map((m) => m.toolCallId));
+    const missing = [];
+    for (const m of this.working) {
+      if (m.role !== 'assistant' || !m.toolCalls?.length) continue;
+      for (const call of m.toolCalls) {
+        if (!answered.has(call.id)) missing.push(call);
+      }
+    }
+    for (const call of missing) {
+      this.push({
+        role: 'tool',
+        toolCallId: call.id,
+        name: call.name,
+        content: 'The user stopped the turn before this ran. It did not happen, and it must not be retried.',
+      });
+    }
+    if (missing.length) {
+      this.push({
+        role: 'user',
+        content: 'I stopped that. Drop it and wait for what I ask next — do not pick it back up.',
+      });
+    }
+    return missing.length;
+  }
+
   async persist() {
     try {
       this.session.model = model();
@@ -607,6 +674,7 @@ export class Agent {
         if (this.busy && this.abort) {
           this.abort.abort();
           this.ui.stopSpinner();
+          this.ui.stopTimer?.();
           this.ui.note('interrupted');
         }
       };
@@ -849,9 +917,12 @@ export class Agent {
       trace({ kind: 'turn', ms: Date.now() - turnStarted });
       this.stats.workMs += Date.now() - turnStarted;
       this.stats.turns++;
+      if (!finished) this.closeInterrupted();
       this.busy = false;
       this.abort = null;
       this.ui.stopSpinner();
+      this.ui.stopTimer?.();
+      this.activity = null;
       this.ui.turnEnd?.({ ok: finished });
       await this.persist();
       if (this.full) this.showHeader({ clear: false });
@@ -1275,8 +1346,10 @@ export class Agent {
       this.sinceCheck?.clear();
     }
     if (!QUIET.has(call.name)) this.ui.toolResult(out.summary);
-    if (out.diff?.length) this.ui.diff(out.diff);
-    if (out.output?.length) this.ui.commandOutput(out.output);
+    // The change as its two numbers, not as a copy of the file. The diff rows
+    // are still built by the tool — the model reads them in the result — they
+    // simply do not go on screen.
+    if (out.diff?.length) this.ui.diffStat?.(countDiff(out.diff));
     this.push({ role: 'tool', toolCallId: call.id, name: call.name, content: out.content + this.stuckNote(call, { out }) });
   }
 

package/src/core/updater.js

@@ -1,95 +1,152 @@
-/**
- * updater.js — staying current without anyone running npm by hand.
- *
- * On every launch ucode asks the registry, in the background, whether a newer
- * version exists. If one does, it installs it globally, detached, while you
- * work. The version you are running carries on untouched; the next launch is
- * the new one. Nothing about starting ucode waits on any of this.
- *
- * It stays out of the way in three cases: a development checkout (updating
- * would overwrite the `npm link` that points at your working copy), when
- * UCODE_NO_UPDATE is set, and when another ucode is already updating.
- */
-
-import { spawn } from 'node:child_process';
-import { existsSync, promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { VERSION } from './version.js';
-
-const PACKAGE = 'ucode-agent';
-const PACKAGE_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const HOME = path.join(os.homedir(), '.ucode');
-const LOCK = path.join(HOME, 'update.lock');
-const LOG = path.join(HOME, 'update.log');
-const LOCK_TTL = 10 * 60_000;
-
-/** "1.10.0" > "1.9.3" — numeric, part by part. */
-export function newer(a, b) {
-  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
-  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
-  }
-  return false;
-}
-
-function isDevCheckout() {
-  return existsSync(path.join(PACKAGE_ROOT, '.git'));
-}
-
-async function latestVersion() {
-  const res = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`, {
-    signal: AbortSignal.timeout(5_000),
-    headers: { accept: 'application/json' },
-  });
-  if (!res.ok) return null;
-  return (await res.json())?.version ?? null;
-}
-
-async function takeLock() {
-  try {
-    const stat = await fs.stat(LOCK);
-    if (Date.now() - stat.mtimeMs < LOCK_TTL) return false;   // someone else is on it
-  } catch { /* no lock — good */ }
-  await fs.mkdir(HOME, { recursive: true });
-  await fs.writeFile(LOCK, String(process.pid));
-  return true;
-}
-
-/**
- * Check, and install if there is something newer.
- *
- * @param {object} o
- * @param {(v: string) => void} [o.onUpdated]  called when the install finishes
- */
-export async function autoUpdate({ onUpdated } = {}) {
-  try {
-    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return;
-    const latest = await latestVersion();
-    if (!latest || !newer(latest, VERSION)) return;
-    if (!(await takeLock())) return;
-
-    const log = await fs.open(LOG, 'w');
-    const child = spawn(`npm install -g ${PACKAGE}@${latest} --no-audit --no-fund`, {
-      shell: true,
-      detached: true,
-      windowsHide: true,
-      stdio: ['ignore', log.fd, log.fd],
-    });
-    await log.close();
-    child.unref();
-
-    child.on('exit', async (code) => {
-      await fs.rm(LOCK, { force: true }).catch(() => {});
-      if (code === 0) onUpdated?.(latest);
-    });
-    child.on('error', async () => {
-      await fs.rm(LOCK, { force: true }).catch(() => {});
-    });
-  } catch {
-    // An update check must never be the reason ucode misbehaves. Offline,
-    // registry down, no permission to install globally: all silently skipped.
-  }
-}
+/**
+ * updater.js — staying current without anyone running npm by hand.
+ *
+ * On every launch ucode asks the registry, in the background, whether a newer
+ * version exists. If one does, it installs it globally, detached, while you
+ * work. The version you are running carries on untouched; the next launch is
+ * the new one. Nothing about starting ucode waits on any of this.
+ *
+ * It stays out of the way in three cases: a development checkout (updating
+ * would overwrite the `npm link` that points at your working copy), when
+ * UCODE_NO_UPDATE is set, and when another ucode is already updating.
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, rmSync, promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VERSION } from './version.js';
+
+const PACKAGE = 'ucode-agent';
+const PACKAGE_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const HOME = path.join(os.homedir(), '.ucode');
+const LOCK = path.join(HOME, 'update.lock');
+const LOG = path.join(HOME, 'update.log');
+const LOCK_TTL = 10 * 60_000;
+
+/** "1.10.0" > "1.9.3" — numeric, part by part. */
+export function newer(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  }
+  return false;
+}
+
+function isDevCheckout() {
+  return existsSync(path.join(PACKAGE_ROOT, '.git'));
+}
+
+async function latestVersion() {
+  const res = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`, {
+    signal: AbortSignal.timeout(5_000),
+    headers: { accept: 'application/json' },
+  });
+  if (!res.ok) return null;
+  return (await res.json())?.version ?? null;
+}
+
+/** Is that process still running? A lock held by a dead one is not a lock. */
+function alive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch (err) { return err.code === 'EPERM'; }
+}
+
+/**
+ * Take the update lock, unless a live process holds it.
+ *
+ * The lock used to be dropped by the parent watching the installer exit — but
+ * the installer is detached and ucode usually leaves first, so the handler
+ * never ran and the lock sat there blocking every update until it aged out.
+ * Now the holder is checked for a pulse, so a lock left by a process that has
+ * gone is simply taken over.
+ */
+async function takeLock() {
+  try {
+    const stat = await fs.stat(LOCK);
+    const holder = parseInt(await fs.readFile(LOCK, 'utf8').catch(() => ''), 10);
+    if (alive(holder) && Date.now() - stat.mtimeMs < LOCK_TTL) return false;
+  } catch { /* no lock — good */ }
+  await fs.mkdir(HOME, { recursive: true });
+  await fs.writeFile(LOCK, String(process.pid));
+  return true;
+}
+
+export async function releaseLock() {
+  await fs.rm(LOCK, { force: true }).catch(() => {});
+}
+
+/**
+ * Install the newer version and return true once it is on disk.
+ *
+ * This one waits. It is used at startup, where waiting a few seconds once per
+ * release is the whole point: the alternative is being told an update exists
+ * and running the old one anyway.
+ */
+export async function installNow(version) {
+  if (!(await takeLock())) return false;
+  try {
+    const done = await new Promise((resolve) => {
+      const child = spawn(`npm install -g ${PACKAGE}@${version} --no-audit --no-fund --silent`, {
+        shell: true, windowsHide: true, stdio: 'ignore',
+      });
+      child.on('exit', (code) => resolve(code === 0));
+      child.on('error', () => resolve(false));
+      setTimeout(() => resolve(false), 90_000);
+    });
+    return done;
+  } finally {
+    await releaseLock();
+  }
+}
+
+/** The newest version on the registry, if it is newer than this one. */
+export async function pendingUpdate() {
+  try {
+    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return null;
+    const latest = await latestVersion();
+    return latest && newer(latest, VERSION) ? latest : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check, and install if there is something newer.
+ *
+ * @param {object} o
+ * @param {(v: string) => void} [o.onUpdated]  called when the install finishes
+ */
+export async function autoUpdate({ onUpdated } = {}) {
+  try {
+    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return;
+    const latest = await latestVersion();
+    if (!latest || !newer(latest, VERSION)) return;
+    if (!(await takeLock())) return;
+
+    const log = await fs.open(LOG, 'w');
+    const child = spawn(`npm install -g ${PACKAGE}@${latest} --no-audit --no-fund`, {
+      shell: true,
+      detached: true,
+      windowsHide: true,
+      stdio: ['ignore', log.fd, log.fd],
+    });
+    await log.close();
+    child.unref();
+
+    // The lock is cleared by whoever took it. This process may well be gone
+    // before npm finishes, so it cannot be left to an exit handler here.
+    child.on('exit', async (code) => {
+      await releaseLock();
+      if (code === 0) onUpdated?.(latest);
+    });
+    child.on('error', async () => { await releaseLock(); });
+    // And if this process leaves first, release it on the way out.
+    process.once('exit', () => { try { rmSync(LOCK, { force: true }); } catch {} });
+  } catch {
+    // An update check must never be the reason ucode misbehaves. Offline,
+    // registry down, no permission to install globally: all silently skipped.
+  }
+}

package/src/ui/screen.js

@@ -39,7 +39,7 @@ import chalk from 'chalk';
 import {
   theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
-  shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark } from './theme.js';
+  shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel, groupTarget, runLine } from './theme.js';
 import { FRAME_MS, fitActivity, shimmer, spinnerGlyph, formatDuration, doneLine, stepPaint } from './activity.js';
 import { renderer, render, polish } from './markdown.js';
 import { VERSION } from '../core/version.js';
@@ -84,6 +84,8 @@ const TRACK = process.platform === 'win32'
 const UNTRACK = process.platform === 'win32'
   ? '' : `${ESC}[?1006l${ESC}[?1015l${ESC}[?1002l${ESC}[?1000l`;
 
+const PASTE_ON = `${ESC}[?2004h`;
+const PASTE_OFF = `${ESC}[?2004l`;
 const MOUSE_ON = `${ESC}[?1007h${TRACK}`;
 const MOUSE_OFF = `${UNTRACK}${ESC}[?1007l`;
 const HIDE = `${ESC}[?25l`;
@@ -149,7 +151,7 @@ export class Screen {
 
   async start() {
     ensureColour(this.output);
-    this.output.write(ALT_ON + MOUSE_ON + HIDE + title(`ucode — ${path.basename(this.cwd)}`));
+    this.output.write(ALT_ON + MOUSE_ON + PASTE_ON + HIDE + title(`ucode — ${path.basename(this.cwd)}`));
     this.input.setRawMode?.(true);
     this.input.resume();
     this.input.setEncoding('utf8');
@@ -173,7 +175,7 @@ export class Screen {
     this.output.off?.('resize', this.onResize);
     this.input.setRawMode?.(false);
     this.input.pause();
-    this.output.write(MOUSE_OFF + ALT_OFF + SHOW);
+    this.output.write(PASTE_OFF + MOUSE_OFF + ALT_OFF + SHOW);
   }
 
   close() {
@@ -246,6 +248,7 @@ export class Screen {
 
   assistant(text) {
     if (!text?.trim()) return;
+    this.endRun();
     this.add('');
     this.add(render(this.md, text));
     this.add('');
@@ -291,21 +294,74 @@ export class Screen {
   toolCall(label) {
     // U+25CF, not U+23FA: the latter carries emoji presentation, which Windows
     // Terminal draws as a white circle on a blue tile.
-    this.push(`${narrationMark()} ${narration(asLabel(label))}`);
+    const kind = groupKind(label);
+    const run = this.run;
+    // The run's own line is either the last one, or the last but one with its
+    // result underneath. Anything further down means something else was said
+    // in between, and the run is over.
+    const gap = run ? this.lines.length - 1 - run.at : Infinity;
+
+    // A second step of the same kind rewrites the line the first one wrote,
+    // rather than adding another almost-identical one beneath it.
+    if (run && run.kind === kind && gap <= 1) {
+      if (gap === 1) this.lines.pop();   // its single result line, now counted
+      run.count++;
+      run.label = label;
+      run.targets.push(groupTarget(label));
+      this.paintRun();
+    } else {
+      this.push(`${narrationMark()} ${narration(asLabel(label))}`);
+      this.run = {
+        kind, count: 1, at: this.lines.length - 1, label,
+        targets: [groupTarget(label)], added: 0, removed: 0,
+      };
+    }
     this.updateSpinner(label);
   }
 
+  /** Anything that is not another step of the same kind ends the run. */
+  endRun() { this.run = null; }
+
+  /** Redraw the run's single line from what it has accumulated. */
+  paintRun() {
+    if (!this.run) return;
+    this.lines[this.run.at] = `${narrationMark()} ${narration(asLabel(runLine(this.run)))}`;
+    this.render();
+  }
+
+  /**
+   * A change, as its two numbers.
+   *
+   * The diff itself used to go into the transcript. A 539-line file printed
+   * there buries the answer under a copy of something already on disk, so
+   * what is kept is the shape of the change: how much arrived, how much left.
+   */
+  diffStat({ added = 0, removed = 0 } = {}) {
+    if (!this.run) return;
+    this.run.added += added;
+    this.run.removed += removed;
+    this.paintRun();
+  }
+
   /** The checklist, when the model updates it. One line, wrapped if it must. */
   plan(items) {
     const line = planLine(items);
     if (line) this.push(line);
   }
 
-  toolResult(summary) {
-    this.push(dim(`  └ ${summary}`));
-  }
+  /**
+   * What came of a step.
+   *
+   * Nothing goes underneath the bullet any more: a line of its own for every
+   * result doubles the height of the transcript to say "ok". The bullet
+   * already names the step, and a change adds its numbers to that same line.
+   * Only a failure earns a line of its own.
+   */
+  toolResult() {}
 
   toolFailed(summary) {
+    // A failure is never folded away.
+    this.endRun();
     this.push(`${dim('  └ ')}${theme.error(summary)}`);
   }
 
@@ -926,7 +982,55 @@ export class Screen {
     this.render();
   }
 
+  /**
+   * Text arriving as a paste rather than as typing.
+   *
+   * A terminal in bracketed-paste mode wraps pasted text in markers, which is
+   * the only way to tell forty lines pasted at once from forty lines typed
+   * very fast. Without it every newline in the paste reads as Enter, so a
+   * pasted block submits itself a line at a time and arrives as forty
+   * messages. Inside the markers a newline is just a character.
+   */
+  onPaste(text) {
+    const clean = String(text).replace(/\r\n?/g, '\n');
+    this.buffer = this.buffer.slice(0, this.cursor) + clean + this.buffer.slice(this.cursor);
+    this.cursor += clean.length;
+    this.render();
+  }
+
   onData(chunk) {
+    // Pasted text first: it is wrapped in markers and must not be read as
+    // keys, or its newlines submit it in pieces.
+    const paste = /\[200~([\s\S]*?)\[201~/g;
+    if (paste.test(chunk)) {
+      paste.lastIndex = 0;
+      let at = 0;
+      let m;
+      while ((m = paste.exec(chunk))) {
+        if (m.index > at) this.onData(chunk.slice(at, m.index));
+        this.onPaste(m[1]);
+        at = m.index + m[0].length;
+      }
+      if (at < chunk.length) this.onData(chunk.slice(at));
+      return;
+    }
+    // An unterminated paste: hold what has arrived and wait for the rest.
+    const open = chunk.indexOf('[200~');
+    if (open !== -1) {
+      if (open > 0) this.onData(chunk.slice(0, open));
+      this.pasting = chunk.slice(open + 6);
+      return;
+    }
+    if (this.pasting !== undefined && this.pasting !== null) {
+      const close = chunk.indexOf('[201~');
+      if (close === -1) { this.pasting += chunk; return; }
+      this.onPaste(this.pasting + chunk.slice(0, close));
+      this.pasting = null;
+      const after = chunk.slice(close + 6);
+      if (after) this.onData(after);
+      return;
+    }
+
     // UCODE_DEBUG_KEYS=1 logs every byte the terminal sends to
     // ~/.ucode/keys.log. Whether mouse reporting works at all depends on the
     // terminal forwarding it; this is how to find out.

package/src/ui/theme.js

@@ -291,3 +291,65 @@ export const narration = (text) => chalk.dim(text);
 
 /** The bullet beside a narration line: present, not loud. */
 export const narrationMark = () => chalk.dim(deep('●'));
+
+/**
+ * How a run of the same kind of step reads once it is over.
+ *
+ * While it happens, "Running npm test" is the useful thing to show. Once
+ * three of them have happened, three near-identical lines are just noise
+ * between the reader and the answer, so they fold into one: "Ran 3 commands".
+ * The present tense belongs to the thing happening now; the past tense to the
+ * summary of what did.
+ */
+const GROUPS = {
+  Running: ['Ran', 'command', 'commands'],
+  Reading: ['Read', 'file', 'files'],
+  Searching: ['Searched', 'time', 'times'],
+  Finding: ['Found', 'pattern', 'patterns'],
+  Listing: ['Listed', 'directory', 'directories'],
+  Writing: ['Wrote', 'file', 'files'],
+  Editing: ['Edited', 'file', 'files'],
+  Checking: ['Checked', 'thing', 'things'],
+  Looking: ['Looked up', 'name', 'names'],
+  Asking: ['Asked about', 'name', 'names'],
+  Mapping: ['Mapped', 'folder', 'folders'],
+  Adding: ['Added', 'block', 'blocks'],
+  Renaming: ['Renamed', 'name', 'names'],
+};
+
+/** The first word of a label, which is what decides whether two steps match. */
+export const groupKind = (label) => String(label ?? '').trim().split(/\s+/)[0] ?? '';
+
+/** One line standing in for `count` steps that all began with the same word. */
+export function groupLabel(label, count) {
+  if (count <= 1) return String(label ?? '');
+  const g = GROUPS[groupKind(label)];
+  if (!g) return `${label} (+${count - 1} more)`;
+  const [past, one, many] = g;
+  return `${past} ${count} ${count === 1 ? one : many}`;
+}
+
+/** The part of a label after its opening word: the file or command it is about. */
+export const groupTarget = (label) => String(label ?? '').trim().split(/\s+/).slice(1).join(' ');
+
+/**
+ * One narration line, standing for everything that happened under it.
+ *
+ * The transcript is a record of what was done, not a copy of what was
+ * written. A 539-line file printed into it buries the answer and tells the
+ * reader nothing they could not get from the file itself, so a change is its
+ * two numbers. Several steps on one file stay one line naming that file;
+ * several files become a count.
+ */
+export function runLine({ label, count = 1, targets = [], added = 0, removed = 0 }) {
+  const counts = added || removed
+    ? ` ${chalk.hex('#3fb950')(`+${added}`)} ${chalk.hex('#f2939c')(`-${removed}`)}`
+    : '';
+  if (count <= 1) return `${label}${counts}`;
+
+  const g = GROUPS[groupKind(label)];
+  const unique = [...new Set(targets.filter(Boolean))];
+  if (g && unique.length === 1) return `${g[0]} ${unique[0]}${counts}`;
+  if (!g) return `${label} (+${count - 1} more)${counts}`;
+  return `${g[0]} ${count} ${count === 1 ? g[1] : g[2]}${counts}`;
+}

package/ucode.js

@@ -81,6 +81,31 @@ async function main() {
     return;
   }
 
+  // Update before the session starts, not after it ends.
+  //
+  // Installing in the background and taking effect "next time" means the run
+  // you are doing now — the one that might be a demo — is the old one, and you
+  // have no way to know. So if there is something newer, it goes on now and
+  // this process hands over to it. The wait is a few seconds, once per
+  // release; every other launch pays one quick question to the registry.
+  if (!args.version && process.argv[2] !== 'login' && process.argv[2] !== 'doctor') {
+    const { pendingUpdate, installNow } = await import('./src/core/updater.js');
+    const waiting = await pendingUpdate();
+    if (waiting) {
+      process.stdout.write(`  updating to v${waiting}…\n`);
+      if (await installNow(waiting)) {
+        const { spawnSync } = await import('node:child_process');
+        const run = spawnSync(process.execPath, [process.argv[1], ...process.argv.slice(2)], {
+          stdio: 'inherit',
+          env: { ...process.env, UCODE_NO_UPDATE: '1' }, // the new one must not check again
+        });
+        process.exit(run.status ?? 0);
+      }
+      // It did not take. Carry on with the version already here rather than
+      // making a failed update the reason ucode will not start.
+    }
+  }
+
   if (args.model) {
     try {
       setModel(args.model);