jaitus 0.3.13 → 0.3.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.13",
+  "version": "0.3.16",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js",
+    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/service-notices.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js && node tests/compaction.js && node tests/copy-clean.js && node tests/parallel-tools.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/agent/loop.js

@@ -32,6 +32,7 @@ import { c, out, write, spinner, glyph } from '../ui.js';
 import { discoverMcpTools } from '../mcp.js';
 import { unifiedDiff } from '../diff.js';
 import { fromResponse, fromGatewayBody, JaitusError } from '../errors.js';
+import { explainFailure } from '../serviceNotice.js';
 
 const MAX_ITERATIONS = 1000;
 const STUCK_REPEATS = 4;
@@ -76,7 +77,10 @@ export function retryDelay(e, attempt = 0) {
     return hinted <= MAX_RETRY_WAIT_MS ? hinted : null;
   }
   if (!TRANSIENT_CODES.has(code) || code === 'internal') return null;
-  return Math.min(BLIP_MAX_WAIT_MS, hinted ?? 2000 * 2 ** attempt);
+  if (hinted != null) return Math.min(BLIP_MAX_WAIT_MS, hinted);
+  // ±25% spread: every CLI cut off by the same restart would otherwise retry in the
+  // same instant and arrive together.
+  return Math.min(BLIP_MAX_WAIT_MS, Math.round(2000 * 2 ** attempt * (0.75 + Math.random() * 0.5)));
 }
 
 function sleepUnlessAborted(ms, signal) {
@@ -258,6 +262,12 @@ export function repairToolPairs(messages) {
 export const TRIM_AT = 40_000;          // estimated tokens of conversation
 export const KEEP_RECENT = 6;           // latest tool results always kept whole
 export const TRIM_AT_LEAST = 12_000;    // estimated tokens a clearing must free
+// Past DEEP_AT only the newest KEEP_RECENT_DEEP results stay whole. Production, 7 days to
+// 2 Oct: requests carrying 150k+ tokens were a quarter of all requests and 62% of all
+// credits — every step of a long task re-sent the outputs of its last six tools whole,
+// up to 60,000 characters each.
+export const DEEP_AT = 100_000;
+export const KEEP_RECENT_DEEP = 3;
 const TRIM_MIN_CHARS = 1_500;           // results shorter than this are never cleared
 const CLEARED = '[Output cleared';
 
@@ -277,8 +287,10 @@ export function conversationTokens(messages) {
  * Clear old tool outputs in place when the conversation is large. Returns how many
  * estimated tokens were freed (0 when nothing was worth clearing).
  */
-export function clearOldToolResults(messages, { at = TRIM_AT, keep = KEEP_RECENT, atLeast = TRIM_AT_LEAST } = {}) {
-  if (conversationTokens(messages) < at) return 0;
+export function clearOldToolResults(messages, { at = TRIM_AT, keep, atLeast = TRIM_AT_LEAST } = {}) {
+  const size = conversationTokens(messages);
+  if (size < at) return 0;
+  if (keep === undefined) keep = size >= DEEP_AT ? KEEP_RECENT_DEEP : KEEP_RECENT;
   const names = new Map();
   for (const m of messages) {
     if (m?.role === 'assistant' && Array.isArray(m.content)) for (const b of m.content) if (b?.type === 'tool_use') names.set(b.id, b.name);
@@ -302,6 +314,9 @@ export function clearOldToolResults(messages, { at = TRIM_AT, keep = KEEP_RECENT
   return freed;
 }
 
+// Tools that change nothing and ask nothing: several in one batch run at the same time.
+const PARALLEL_SAFE = new Set(['read_file', 'glob', 'list_files', 'search', 'web_search', 'web_fetch', 'background_list', 'background_read', 'load_skill']);
+
 export const IMAGE_BUDGET = 6_000_000;
 export function withinImageBudget(messages, budget = IMAGE_BUDGET) {
   let used = 0;
@@ -491,7 +506,7 @@ export async function runAgent({
   client, messages, model, cwd, permissions, signal, tui = null,
   extraSystem = '', maxIterations = MAX_ITERATIONS, silent = false,
   onText = null, onEvent = null, systemOverride = null, journal = null,
-  subagents = true, onContext = null, trimContext = true,
+  subagents = true, onContext = null, trimContext = true, beforeStep = null,
 }) {
   // Loop detection. A call is identified by its tool, its input, and how many files had
   // been changed when it was made — so edit → test → edit → test is progress (the count
@@ -540,6 +555,11 @@ export async function runAgent({
       const freed = clearOldToolResults(messages);
       if (freed && tui?.notice) tui.notice(`Cleared old tool output (~${Math.round(freed / 1000)}k tokens) to keep each request small.`, 'info');
     }
+    // The caller may compact the history between steps (index.js: when the context is
+    // nearly full). Never before the first step — the caller already checked then.
+    if (beforeStep && iteration > 0 && !signal?.aborted) {
+      try { await beforeStep(messages); } catch { /* a failed compaction is reported by the caller; the step still runs */ }
+    }
     let streamed = false;
     const spin = tui ? { stop: () => {}, update: () => {} } : (silent ? { stop: () => {}, update: () => {} } : spinner(glyph('Working…', 'Working...')));
     if (tui) tui.setStatus(`${c.brand(glyph('•', '*'))} ${c.brand(glyph('Working…', 'Working...'))}`);
@@ -610,6 +630,10 @@ export async function runAgent({
         else if (!silent) out(c.yellow(`  ${glyph('⏹', '[x]')}  Interrupted.`));
         return { ...totals, stopReason: 'interrupted' };
       }
+      // Out of retries: say what the status page knows (back-at time, known problem).
+      // Asked of the same service the request went to; a client with no address (a test
+      // double) asks nothing.
+      if (client?.baseUrl) await explainFailure(e, { baseUrl: client.baseUrl }).catch(() => {});
       throw e;
     }
     spin.stop();
@@ -720,6 +744,26 @@ export async function runAgent({
       return { ...totals, stopReason: 'stuck' };
     }
 
+    // Read-only calls in one batch run AT THE SAME TIME. The model is told to batch
+    // independent reads, and then they ran one after another anyway: five file reads or
+    // three searches cost five or three round trips of wall time. Only tools that change
+    // nothing and need no permission start early; their rows, results and order are
+    // exactly as before — the loop below just finds the work already done. Anything
+    // that writes, runs a command or asks the user still runs one by one, in order.
+    const early = new Map();
+    const parallel = calls.filter((call) => {
+      const t = toolMap[call.name];
+      return t && PARALLEL_SAFE.has(call.name) && !t.needsPermission && call.input?.__parse_error === undefined
+        && !planBlocked.has(call.id) && permissions?.verdict?.(call.name, call.input, cwd) !== 'deny';
+    });
+    if (parallel.length > 1 && !signal?.aborted) {
+      for (const call of parallel) {
+        const started = Promise.resolve().then(() => toolMap[call.name].run(call.input, { cwd, signal }));
+        started.catch(() => { /* reported when the loop reaches the call */ });
+        early.set(call.id, started);
+      }
+    }
+
     // Every call gets a result, whatever happened.
     const results = [];
     for (const call of calls) {
@@ -803,7 +847,7 @@ export async function runAgent({
         } else if (journal && call.name === 'run_command') {
           journal.snapshotTracked(cwd);
         }
-        const output = await tool.run(call.input, { cwd, signal });
+        const output = await (early.get(call.id) ?? tool.run(call.input, { cwd, signal }));
         spin2.stop(); stopElapsed();
         const took = ((Date.now() - toolStarted) / 1000).toFixed(1);
         // opencode tool icons: $ shell, ← edits, → reads, ✱ search,

package/src/agent/tools.js

@@ -746,11 +746,17 @@ export const TOOLS = [
     async run(input) {
       if (input.clear) { todoState.splice(0, todoState.length); return 'Task list cleared.'; }
       if (!Array.isArray(input.todos)) throw new ToolError('Give a todos array (or clear: true).');
-      const cleaned = input.todos.map((t) => ({
-        task: String(t?.task || '').trim(),
-        status: ['pending', 'in_progress', 'completed'].includes(t?.status) ? t.status : 'pending',
-      })).filter((t) => t.task);
-      if (!cleaned.length) throw new ToolError('The list has no usable items.');
+      // Models trained on other agents name the step `content` (or title, text…) and the
+      // status "done" or "in-progress". Only `task` used to count, so a perfectly good
+      // plan was refused as "no usable items" and the list never appeared.
+      const STATUS = { pending: 'pending', todo: 'pending', not_started: 'pending', in_progress: 'in_progress', inprogress: 'in_progress', active: 'in_progress', doing: 'in_progress', started: 'in_progress', completed: 'completed', complete: 'completed', done: 'completed', finished: 'completed' };
+      const cleaned = input.todos.map((t) => {
+        const item = typeof t === 'string' ? { task: t } : (t || {});
+        const text = [item.task, item.content, item.title, item.text, item.description, item.step, item.name].find((v) => typeof v === 'string' && v.trim());
+        const key = String(item.status || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
+        return { task: String(text || '').trim(), status: STATUS[key] || (item.done === true || item.completed === true ? 'completed' : 'pending') };
+      }).filter((t) => t.task);
+      if (!cleaned.length) throw new ToolError('The list has no usable items. Each item is { "task": "one step", "status": "pending" | "in_progress" | "completed" }.');
       todoState.splice(0, todoState.length, ...cleaned);
       return `Task list updated (${cleaned.filter((t) => t.status === 'completed').length}/${cleaned.length} done).`;
     },

package/src/api.js

@@ -4,9 +4,10 @@
 // a JaitusError here, at the edge, so no caller ever has an HTTP body in its hands to
 // print — see errors.js for why that matters.
 
-import { endpoints } from './config.js';
+import { endpoints, version } from './config.js';
 import { signedIn, withAuth } from './session.js';
 import { fromGatewayBody, fromNetwork, JaitusError } from './errors.js';
+import { machineHeader } from './machine.js';
 
 export class NotSignedIn extends Error {}
 
@@ -93,8 +94,10 @@ export function createClient() {
 
   // x-jaitus-features: what this build understands, so the gateway can use newer error
   // codes (a used-up usage window) without an older CLI reading them as "went wrong".
-  const base = { 'Content-Type': 'application/json', 'user-agent': 'jaitus-cli', 'x-jaitus-features': 'usage-window' };
-  const headers = (token) => ({ ...base, authorization: `Bearer ${token}` });
+  const base = { 'Content-Type': 'application/json', 'user-agent': `jaitus-cli/${version()}`, 'x-jaitus-features': 'usage-window' };
+  // x-jaitus-device: this computer's hashed identifiers (machine.js), which the free
+  // tier is limited by. Built once per process.
+  const headers = (token) => ({ ...base, 'x-jaitus-device': machineHeader(), authorization: `Bearer ${token}` });
 
   return {
     baseUrl,

package/src/commands/update.js

@@ -14,7 +14,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { c, out, ok, info, warn, fail, present, askKey } from '../ui.js';
+import { c, out, ok, info, warn, fail, present } from '../ui.js';
 import { version, HOME } from '../config.js';
 import { RUNNING_FILE } from '../pendingUpdate.js';
 
@@ -89,7 +89,7 @@ export async function updateNotice(opts = {}) {
   const current = opts.current || version();
   const latest = await cachedLatest(opts).catch(() => null);
   if (!latest || !isNewer(latest, current)) return null;
-  return `Jaitus v${latest} is out — you have v${current}. Quit and run \`jaitus update\` to install it.`;
+  return `Jaitus v${latest} is out — you have v${current}. Quit and start jaitus again: it updates itself as it starts.`;
 }
 
 function run(cmd, args, { capture = false } = {}) {
@@ -121,10 +121,15 @@ function run(cmd, args, { capture = false } = {}) {
 export function installGlobal(v, { onTick = () => {}, onStart = () => {} } = {}) {
   return new Promise((resolve) => {
     const args = ['install', '-g', `jaitus@${v}`, '--no-audit', '--no-fund', '--loglevel=error'];
-    const opts = { stdio: ['ignore', 'ignore', 'pipe'], detached: true, windowsHide: true };
+    // Windows: `detached` gives the child a console of its OWN — the update opened a
+    // second terminal window. Instead npm runs in this window through `start /b`, which
+    // makes it ignore Ctrl+C (cmd's documented behaviour), so it still cannot be cut off
+    // halfway; delayed expansion hands npm's exit code back through `start /wait`.
+    // Elsewhere a detached process group does the same without any window.
     const child = process.platform === 'win32'
-      ? spawn(['npm', ...args].join(' '), { ...opts, shell: true })
-      : spawn('npm', args, opts);
+      ? spawn('cmd.exe', ['/d', '/v:on', '/s', '/c', `"start "" /b /wait npm ${args.join(' ')} & exit !errorlevel!"`],
+        { stdio: ['ignore', 'ignore', 'pipe'], windowsHide: true, windowsVerbatimArguments: true })
+      : spawn('npm', args, { stdio: ['ignore', 'ignore', 'pipe'], detached: true });
     if (child.pid) onStart(child.pid);
     let stderr = '';
     child.stderr?.on('data', (d) => { stderr = (stderr + d).slice(-4000); });
@@ -147,7 +152,14 @@ export async function installMethod({ here = fileURLToPath(import.meta.url), npm
   const norm = (p) => path.resolve(p).toLowerCase();
   if (/[\\/]_npx[\\/]/.test(real)) return 'npx';
   const root = npmRoot ?? (await run('npm', ['root', '-g'], { capture: true })).stdout.trim();
-  if (root && norm(real).startsWith(norm(path.join(root, 'jaitus')) + path.sep.toLowerCase())) return 'npm-global';
+  if (!root) return 'other';
+  // Both sides through their links: with nvm (and similar) npm's global folder is a link
+  // to the active Node's folder, so this file's real path never started with the
+  // reported one, and a perfectly normal npm install was skipped as "not npm".
+  const realRoot = (() => { try { return fs.realpathSync(root); } catch { return root; } })();
+  for (const r of new Set([root, realRoot])) {
+    if (norm(real).startsWith(norm(path.join(r, 'jaitus')) + path.sep.toLowerCase())) return 'npm-global';
+  }
   return 'other';
 }
 
@@ -173,56 +185,70 @@ export function isNewer(a, b) {
 }
 
 /**
- * Update on launch, then reopen: every time `jaitus` starts, the registry is asked
- * (with a short timeout, so a slow network costs at most that); when a newer version is
- * out and this copy is a global npm install, it is installed and the same command is
- * started again on the new version.
+ * Update on launch, then reopen. Every time `jaitus` starts in a terminal, the registry
+ * is asked — always, not from a cache — and when a newer version is out it is installed,
+ * with progress on screen, and the same command is started again on the new version.
  *
- * It never blocks the session on a failure. A failed install (commonly: a system-wide
- * Node on macOS or Linux, where npm -g needs sudo) says so once and is not retried for a
- * day, so a machine that cannot update does not pay for trying on every start.
+ * It used to skip far too often: the registry got 1.5 s (a slower answer meant this
+ * launch went ahead on the old version), one failed install switched updating off for a
+ * day, a copy whose npm folder is reached through a link (nvm and similar) was taken for
+ * "not an npm install" and skipped without a word, and a setting could turn it off. Now:
+ * - the check waits up to `waitMs` (10 s), saying "Checking for updates…" while it does;
+ * - a failed install says why and how to fix it, and is tried again on the next launch;
+ * - a copy that cannot update itself (npx, a linked or vendored copy) says so, every time;
+ * - only CI, scripts/pipes and JAITUS_NO_AUTOUPDATE (for tests and automation) skip it.
  *
- * Off with `jaitus config autoUpdate off`, JAITUS_NO_AUTOUPDATE=1, NO_UPDATE_NOTIFIER or CI.
+ * It never blocks the session on a failure: the user is told, and the app starts.
  * Returns the child's exit code when it relaunched, or null to carry on in this process.
  */
-export async function autoUpdate({ argv = [], settings = {}, env = process.env, current = version(), log = out,
+export async function autoUpdate({ argv = [], env = process.env, current = version(), log = out,
   check = () => checkRegistry(), method = () => installMethod(), install = null,
-  relaunch = defaultRelaunch, now = Date.now(), failFile = path.join(HOME, 'update-failed.json'),
-  cacheFile = CHECK_FILE, waitMs = 1500, write = (s) => process.stdout.write(s),
-  runningFile = RUNNING_FILE } = {}) {
+  relaunch = defaultRelaunch, cacheFile = CHECK_FILE, waitMs = 10_000, write = (s) => process.stdout.write(s),
+  runningFile = RUNNING_FILE, showAfterMs = 300 } = {}) {
   if (env.JAITUS_UPDATED_FROM) return null;                // just relaunched: never loop
-  if (!updateCheckEnabled(env) || env.JAITUS_NO_AUTOUPDATE || settings.autoUpdate === false) return null;
+  if (!updateCheckEnabled(env) || env.JAITUS_NO_AUTOUPDATE) return null;
   if (!process.stdout.isTTY || !process.stdin.isTTY) return null;   // scripts and pipes get a stable version
   const first = argv.find((a) => !a.startsWith('-'));
   if (['update', 'completion', 'help', 'logout'].includes(first) || argv.some((a) => ['--version', '-v', '--help', '-h', '--print', '-p'].includes(a))) return null;
-  try {
-    const failed = JSON.parse(fs.readFileSync(failFile, 'utf8'));
-    if (now - Number(failed.at) < DAY_MS) return null;
-  } catch { /* no recent failure */ }
 
-  // What the last check found. A check that outlived its wait on a slow connection still
-  // finishes and records its answer here, so the NEXT launch updates without waiting —
-  // before this, a network slower than the wait skipped the update on every launch.
   const remember = (latest) => {
     try { fs.mkdirSync(path.dirname(cacheFile), { recursive: true }); fs.writeFileSync(cacheFile, JSON.stringify({ checkedAt: Date.now(), latest: latest || null })); } catch { /* read-only home */ }
   };
-  let latest = null;
-  try {
-    const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
-    if (cached?.latest && isNewer(cached.latest, current) && now - Number(cached.checkedAt) < 6 * 3600e3) latest = cached.latest;
-  } catch { /* no earlier answer */ }
+  // Ask the registry. A quick answer shows nothing; a slow one says what is happening.
+  let shown = false;
+  const showing = setTimeout(() => { shown = true; write(`  ${c.dim('Checking for updates…')}`); }, showAfterMs);
+  // An answer that arrives after the wait is still recorded, for the next launch.
+  const asked = Promise.resolve().then(check).then((r) => { if (r?.version) remember(r.version); return r; }, () => ({ version: null, status: 'unreachable' }));
+  const answer = await Promise.race([
+    asked,
+    new Promise((resolve) => setTimeout(() => resolve({ version: null, status: 'timeout' }), waitMs).unref()),
+  ]);
+  clearTimeout(showing);
+  if (shown) write('\r\x1b[2K');
+  let latest = answer?.version || null;
+  // (an answer is recorded by `asked` itself, on time or late)
   if (!latest) {
-    const asked = Promise.resolve().then(check).then((r) => { if (r?.version) remember(r.version); return r; }, () => ({ version: null }));
-    ({ version: latest } = await Promise.race([
-      asked,
-      // unref: a quick command must not sit waiting for this timer after the answer came.
-      new Promise((resolve) => setTimeout(() => resolve({ version: null }), waitMs).unref()),
-    ]));
+    // No answer this time. A newer version seen earlier is still worth installing.
+    try {
+      const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+      if (cached?.latest && isNewer(cached.latest, current)) latest = cached.latest;
+    } catch { /* no earlier answer */ }
+    if (!latest) {
+      if (answer?.status !== 'unpublished') log(`  ${c.dim(`Could not reach npm to check for updates — starting v${current}.`)}`);
+      return null;
+    }
+  }
+  if (!isNewer(latest, current)) return null;
+
+  const how = await method();
+  if (how !== 'npm-global') {
+    log(`  ${c.yellow('!')} ${c.bold(`Jaitus v${latest}`)} ${c.dim(`is out — you have v${current}, and this copy cannot update itself.`)}`);
+    log(`    ${c.dim(how === 'npx' ? 'Start it with' : 'Update it with')} ${c.bold(how === 'npx' ? 'npx jaitus@latest' : 'npm install -g jaitus@latest')}`);
+    return null;
   }
-  if (!latest || !isNewer(latest, current)) return null;
-  if ((await method()) !== 'npm-global') return null;       // the in-app notice covers these
 
   const head = `  ${c.brand('Jaitus')} ${c.dim(`v${current} →`)} ${c.bold(`v${latest}`)}`;
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
   write(`${head} ${c.dim('— updating…')}`);
   // Ctrl+C now leaves npm to finish on its own (it is detached) — say so rather than
   // leaving someone to wonder whether they broke the install. Runs before the bin's own
@@ -232,7 +258,7 @@ export async function autoUpdate({ argv = [], settings = {}, env = process.env,
   };
   process.prependListener('SIGINT', onInterrupt);
   const doInstall = install || ((v) => installGlobal(v, {
-    onTick: (s) => write(`\r${head} ${c.dim(`— updating… ${s}s (this takes about a minute)`)}`),
+    onTick: (s) => write(`\r\x1b[2K${head} ${c.brand(frames[s % frames.length])} ${c.dim(`updating… ${s}s — this usually takes under a minute`)}`),
     // Left behind only if this process is gone before npm is — the next launch waits on it.
     onStart: (pid) => { try { fs.mkdirSync(path.dirname(runningFile), { recursive: true }); fs.writeFileSync(runningFile, JSON.stringify({ pid, at: Date.now(), version: v })); } catch { /* best effort */ } },
   }));
@@ -243,14 +269,15 @@ export async function autoUpdate({ argv = [], settings = {}, env = process.env,
   }
   write('\n');
   if (result.code !== 0) {
-    try { fs.mkdirSync(path.dirname(failFile), { recursive: true }); fs.writeFileSync(failFile, JSON.stringify({ at: now, version: latest })); } catch { /* best effort */ }
     const needsSudo = /EACCES|permission denied/i.test(result.stderr || '');
-    log(`  ${c.yellow('!')} ${c.dim('Could not update automatically — continuing on')} v${current}${c.dim('. To update:')} ${c.bold(process.platform !== 'win32' && needsSudo ? 'sudo npm install -g jaitus@latest' : 'npm install -g jaitus@latest')}`);
+    const busy = /EBUSY|EPERM|resource busy|operation not permitted/i.test(result.stderr || '');
+    log(`  ${c.yellow('!')} ${c.dim('The update to')} v${latest} ${c.dim('did not install — starting')} v${current}${c.dim('. It is tried again next time you start jaitus.')}`);
+    if (busy) log(`    ${c.dim('Another jaitus window may be holding its files: close every jaitus window, then start it again.')}`);
+    log(`    ${c.dim('To install it by hand:')} ${c.bold(process.platform !== 'win32' && needsSudo ? 'sudo npm install -g jaitus@latest' : 'npm install -g jaitus@latest')}`);
     const reason = (result.stderr || '').split('\n').map((l) => l.trim()).filter(Boolean).find((l) => /ERR|EACCES|EPERM|EBUSY|ENOTEMPTY/i.test(l));
-    if (reason) log(`  ${c.dim(reason.slice(0, 200))}`);
+    if (reason) log(`    ${c.dim(reason.slice(0, 200))}`);
     return null;
   }
-  remember(latest);
   log(`  ${c.accent('✓')} ${c.dim(`Updated to v${latest} — reopening`)}`);
   return relaunch({ ...env, JAITUS_UPDATED_FROM: current });
 }
@@ -303,16 +330,20 @@ export default async function update(argv = [], { json = false, interactive = tr
     manual();
     return 0;
   }
-  const yes = argv.includes('--yes') || argv.includes('-y');
-  if (!yes) {
-    if (!process.stdin.isTTY) { manual(); return 0; }
-    const answer = await askKey(`  Install v${latest} now? ${c.dim('[Y/n]')} `, ['y', 'n', '\r', '\n']);
-    if (answer === 'n') { manual(); return 0; }
-  }
-  out(`  ${c.dim('running')} npm install -g jaitus@${latest}`);
-  const { code } = await run('npm', ['install', '-g', `jaitus@${latest}`]);
+  // Asking for the update IS the yes: it installs straight away, with the same progress
+  // line as an update on launch.
+  const tty = process.stdout.isTTY;
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  const line = `  ${c.dim('installing')} v${latest}`;
+  if (tty) process.stdout.write(`${line}…`); else out(`${line} (npm install -g jaitus@${latest})`);
+  const { code, stderr } = await installGlobal(latest, {
+    onTick: (s) => { if (tty) process.stdout.write(`\r\x1b[2K${line} ${c.brand(frames[s % frames.length])} ${c.dim(`${s}s — this usually takes under a minute`)}`); },
+  });
+  if (tty) process.stdout.write('\n');
   if (code !== 0) {
     fail(`npm could not install it (exit ${code}). Try it yourself — on macOS or Linux it may need sudo, or a Node version manager:`);
+    const reason = (stderr || '').split('\n').map((l) => l.trim()).filter(Boolean).find((l) => /ERR|EACCES|EPERM|EBUSY|ENOTEMPTY/i.test(l));
+    if (reason) info(reason.slice(0, 200));
     manual();
     return 1;
   }

package/src/compact.js

@@ -0,0 +1,224 @@
+// ─── Compaction: summarising a conversation so it fits again ──────────────────────
+//
+// Shared by /compact, automatic compaction between prompts, compaction between the
+// steps of one long task, and the automatic recovery from "too large / too long".
+//
+// The one rule: the summary request itself must always fit. It used to carry up to
+// 360,000 characters of transcript whatever the model's window was, with pasted text and
+// @mentions unclipped — so on exactly the sessions that needed it, /compact failed with
+// the same "too long" error it was meant to cure, and the history stayed as it was.
+// Now the transcript is sized from the window the gateway advertises, a session bigger
+// than that is summarised in parts (each part folded into the summary so far), and a
+// refused summary request is retried with half as much.
+
+import { streamTurn } from './agent/loop.js';
+import { JaitusError } from './errors.js';
+
+/** Errors that mean "this request is too big" — the ones compaction can cure. */
+export const SIZE_FAULTS = new Set(['context_too_long', 'request_too_large']);
+
+/** Rough token estimate — ~4 characters per token of English. */
+export function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages || []) {
+    if (typeof m.content === 'string') chars += m.content.length;
+    else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === 'text') chars += (b.text || '').length;
+        else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length;
+        else if (b.type === 'tool_result') {
+          chars += typeof b.content === 'string' ? b.content.length
+            : Array.isArray(b.content) ? b.content.reduce((n, c) => n + (c?.text?.length || (c?.type === 'image' ? 6000 : 0)), 0) : 0;
+        } else if (b.type === 'image') chars += 6000; // ~1.5k tokens, what providers count for one
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+/** How many characters of transcript one summary request may carry for this window. */
+export function summaryBudgetChars(contextTokens) {
+  const window = Number(contextTokens) > 0 ? Number(contextTokens) : 128_000;
+  // Half the window for the transcript (≈ 2 characters per token of window, code and
+  // JSON tokenise denser than prose), the rest for the instructions, the reply and the
+  // gateway's own system prompt. Bounded: a 1M window does not need a 2 MB request.
+  return Math.max(20_000, Math.min(240_000, Math.floor(window * 2)));
+}
+
+const clip = (s, n) => (s.length > n ? `${s.slice(0, n)}… [${s.length - n} more characters left out]` : s);
+
+/**
+ * The conversation as plain lines, for summarising. Tool calls and results become short
+ * lines, images a note, and any one text block is clipped — the person's own words are
+ * kept far longer than anything a tool printed, because they are what a summary must
+ * not lose.
+ */
+export function transcriptLines(messages) {
+  const lines = [];
+  for (const m of messages || []) {
+    const who = m.role === 'assistant' ? 'ASSISTANT' : 'USER';
+    const textCap = m.role === 'assistant' ? 6_000 : 12_000;
+    if (typeof m.content === 'string') { lines.push(`${who}: ${clip(m.content, textCap)}`); continue; }
+    for (const b of Array.isArray(m.content) ? m.content : []) {
+      if (b?.type === 'text' && b.text) lines.push(`${who}: ${clip(b.text, textCap)}`);
+      else if (b?.type === 'tool_use') lines.push(`${who} ran ${b.name}: ${clip(JSON.stringify(b.input ?? {}), 400)}`);
+      else if (b?.type === 'tool_result') {
+        const t = typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
+        lines.push(`RESULT${b.is_error ? ' (error)' : ''}: ${clip(t, 1500)}`);
+      } else if (b?.type === 'image') lines.push(`${who}: [an image]`);
+    }
+  }
+  return lines;
+}
+
+/** Lines → parts of at most `maxChars` each, cutting only between lines. */
+export function chunkLines(lines, maxChars) {
+  const parts = [];
+  let cur = '';
+  for (const line of lines) {
+    const l = line.length > maxChars ? clip(line, maxChars - 80) : line;
+    if (cur && cur.length + l.length + 1 > maxChars) { parts.push(cur); cur = ''; }
+    cur = cur ? `${cur}\n${l}` : l;
+  }
+  if (cur) parts.push(cur);
+  return parts;
+}
+
+/** Kept for callers that want the single-request transcript (and its tests). */
+export function transcriptForSummary(messages, maxChars = 240_000) {
+  let text = transcriptLines(messages).join('\n');
+  if (text.length > maxChars) {
+    const head = text.slice(0, Math.floor(maxChars * 0.25));
+    const tail = text.slice(-Math.floor(maxChars * 0.7));
+    text = `${head}\n\n[… the middle of the session is left out …]\n\n${tail}`;
+  }
+  return text;
+}
+
+const HEADINGS = 'Use these headings, and be specific (paths, names, numbers) rather than general:\n'
+  + '1. Request — what the user asked for, with their exact words for any instruction, constraint or preference.\n'
+  + '2. Corrections — anything the user rejected, corrected or asked to do differently, verbatim where short.\n'
+  + '3. Files — every file read or changed: path, what changed or what matters in it.\n'
+  + '4. Commands and results — what was run and what it showed (test/build results, errors and how each was fixed).\n'
+  + '5. Decisions — what was chosen and why.\n'
+  + '6. Current state — exactly what was being done when this summary was made, and what is unfinished.\n'
+  + '7. Next step — the single next action, if the work was mid-way.\n'
+  + 'Omit headings that have nothing. No preamble.';
+
+async function summaryRequest(client, model, prompt, signal) {
+  // Streamed, like every other turn: the proxy in front of the gateway cuts a response
+  // that is silent for 100 s, and a long summary used to be exactly that.
+  const turn = await streamTurn({
+    client,
+    model,
+    // Room for the model to reason before it writes; at 2048 the reasoning could use
+    // it all and the summary came back empty.
+    maxTokens: 6000,
+    system: 'You write precise working summaries of coding sessions.',
+    messages: [{ role: 'user', content: prompt }],
+    signal,
+  });
+  // Half a summary would silently become the whole memory of the session.
+  if (turn.stopReason === 'cut') throw new JaitusError({ code: 'interrupted', message: 'The summary was cut off on the way. Try /compact again.' });
+  const text = (turn.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
+  if (!text) throw new Error('the summary came back empty');
+  return text;
+}
+
+/**
+ * Summarise `messages`. `contextTokens` is the window the gateway advertises; the
+ * transcript is cut into parts that fit it, and each part is folded into the summary so
+ * far (a rolling summary — nothing in the middle is dropped). A part the provider still
+ * refuses as too large is retried at half the size, down to a floor.
+ */
+export async function summarise(client, model, messages, focus = '', { contextTokens = 128_000, signal, onProgress } = {}) {
+  const lines = transcriptLines(messages);
+  let budget = summaryBudgetChars(contextTokens);
+  const focusNote = focus ? ` Focus on: ${focus}.` : '';
+  for (let attempt = 0; ; attempt++) {
+    const parts = chunkLines(lines, budget);
+    try {
+      let summary = '';
+      for (let i = 0; i < parts.length; i++) {
+        if (parts.length > 1) onProgress?.(i + 1, parts.length);
+        const prompt = summary
+          ? `You are summarising a long coding session in parts. Here is the summary of everything before this part:\n<summary>\n${summary}\n</summary>\n\n`
+            + `Write ONE updated summary that keeps everything that still matters from it and adds this part. ${HEADINGS}${focusNote}`
+            + `\n\n<conversation part="${i + 1} of ${parts.length}">\n${parts[i]}\n</conversation>`
+          : 'Summarize this conversation for a successor agent that will continue the work with no other memory of it. '
+            + `${HEADINGS}${focusNote}\n\n<conversation>\n${parts[i]}\n</conversation>`;
+        summary = await summaryRequest(client, model, prompt, signal);
+      }
+      return summary;
+    } catch (e) {
+      if (!SIZE_FAULTS.has(e?.code) || budget <= 20_000 || attempt >= 3) throw e;
+      budget = Math.max(20_000, Math.floor(budget / 2));
+    }
+  }
+}
+
+/** The single message a summary becomes. */
+export const summaryMessage = (summary) => ({ role: 'user', content: `[Earlier conversation, summarized:]\n${summary}\n\n[Continue from here.]` });
+
+/**
+ * Where to cut so the newest exchange stays word for word. Between the steps of a task
+ * the history ends with the model's tool calls and their results: those stay, so the
+ * task carries on from them. Before a new prompt the last message is the person's: it
+ * stays, so their question is sent whole instead of as a summary of it.
+ */
+export function tailStart(messages) {
+  const n = messages.length;
+  if (n < 2) return n;
+  const last = messages[n - 1];
+  const prev = messages[n - 2];
+  const hasResults = Array.isArray(last?.content) && last.content.some((b) => b?.type === 'tool_result');
+  if (last?.role === 'user' && hasResults && prev?.role === 'assistant') return n - 2;
+  if (last?.role === 'user') return n - 1;
+  return n;
+}
+
+/**
+ * Replace `messages` (in place) with a summary of everything before the tail, followed
+ * by the tail. Returns what happened, or null when there was too little to compact.
+ */
+export async function compactInPlace(client, model, messages, { focus = '', contextTokens, keepTail = true, signal, onProgress } = {}) {
+  const cut = keepTail ? tailStart(messages) : messages.length;
+  const head = messages.slice(0, cut);
+  if (!head.length) return null;
+  const tail = messages.slice(cut);
+  const before = estimateTokens(messages);
+  const summary = await summarise(client, model, head, focus, { contextTokens, signal, onProgress });
+  messages.length = 0;
+  // The tail after a summary must still alternate: summary (user) → assistant tool calls
+  // → user results. A tail that starts with the person's message is joined to the
+  // summary instead, so two user messages never sit side by side.
+  if (tail[0]?.role === 'user') {
+    const t = tail[0];
+    const blocks = typeof t.content === 'string' ? [{ type: 'text', text: t.content }] : t.content;
+    messages.push({ role: 'user', content: [{ type: 'text', text: summaryMessage(summary).content }, ...blocks] }, ...tail.slice(1));
+  } else {
+    messages.push(summaryMessage(summary), ...tail);
+  }
+  return { before, after: estimateTokens(messages), dropped: head.length };
+}
+
+/**
+ * Images are the usual reason a request is too large in BYTES. Every image except those
+ * in the newest message becomes a short note.
+ */
+export function dropOldImages(messages) {
+  let dropped = 0;
+  for (let i = 0; i < messages.length - 1; i++) {
+    const m = messages[i];
+    if (!Array.isArray(m.content)) continue;
+    m.content = m.content.map((b) => {
+      if (b?.type === 'image') { dropped++; return { type: 'text', text: '[an image was here; removed to keep the request small]' }; }
+      if (b?.type === 'tool_result' && Array.isArray(b.content) && b.content.some((c) => c?.type === 'image')) {
+        dropped++;
+        return { ...b, content: b.content.map((c) => (c?.type === 'image' ? { type: 'text', text: '[an image was here; removed to keep the request small]' } : c)) };
+      }
+      return b;
+    });
+  }
+  return dropped;
+}