jaitus 0.3.3 → 0.3.5

package/src/commands/commit.js

@@ -1,71 +1,88 @@
 // ─── /commit — review the diff, write a real message, land it ───────────────────
 //
-// Shows what changed, asks the model to summarise the WHY into a subject line,
-// then commits. Pushing is always a separate confirmation — never implicit.
+// Shows what changed, asks the model to summarise the WHY into a subject line, then
+// asks before committing. Pushing is always a separate, explicit choice — never implicit.
+//
+//   /commit                    the model proposes a subject; you confirm
+//   /commit fix the login bug  your subject, used as written; you still confirm
+//
+// The previous version could never commit through its normal path: it did not await
+// its own prompts (so the answer was a Promise, never 'y'), read the subject from a
+// field the agent does not return, and ran git in the process directory rather than the
+// session's --cwd.
 import { spawnSync } from 'node:child_process';
 import { runAgent } from '../agent/loop.js';
 import { createPermissions } from '../agent/permissions.js';
 import { c, out, ok, warn, fail, askKey, glyph } from '../ui.js';
 
-function git(args, opts = {}) {
-  const r = spawnSync('git', args, { encoding: 'utf8', ...opts });
+function git(args, cwd) {
+  const r = spawnSync('git', args, { encoding: 'utf8', cwd, windowsHide: true });
   return { ok: r.status === 0, out: (r.stdout || '').trim(), err: (r.stderr || '').trim() };
 }
 
+/** A choice, through the app's dialog when there is one, else a key prompt. */
+async function choose(ctx, question, options) {
+  if (ctx.tui?.askDialog) {
+    const r = await ctx.tui.askDialog(question, options.map(([value, label]) => ({ value, label })), [], { title: 'COMMIT', hideComment: true });
+    return r && typeof r === 'object' ? r.value : r;
+  }
+  if (!process.stdin.isTTY) return null;
+  const keys = options.map(([value]) => value[0]);
+  const key = await askKey(`  ${question} ${options.map(([v, l]) => `(${v[0]}) ${l}`).join(' / ')}`, keys);
+  return options.find(([value]) => value[0] === key)?.[0] ?? null;
+}
+
 export default async function commit(args, ctx) {
-  if (!git(['rev-parse', '--is-inside-work-tree']).ok) {
+  const cwd = ctx.flags?.cwd || process.cwd();
+  if (!git(['rev-parse', '--is-inside-work-tree'], cwd).ok) {
     fail('Not a git repository.');
     return null;
   }
-  const status = git(['status', '--porcelain']);
+  const status = git(['status', '--porcelain'], cwd);
   if (!status.out) { ok('Nothing to commit — the working tree is clean.'); return null; }
 
-  // What the commit would contain, shown before anything happens.
-  const stat = git(['diff', '--stat', 'HEAD']).out || '';
-  if (stat) {
-    out(c.dim('  Changes:'));
-    for (const line of stat.split('\n').slice(0, 20)) out(`  ${c.dim(line)}`);
-    const n = stat.split('\n').length - 20;
-    if (n > 0) out(c.dim(`  ${glyph('…', '...')} and ${n} more files`));
-  }
-
-  // The model writes the message from the actual diff — with a firm brevity
-  // leash, because left alone every model writes essays.
-  let subject = '';
-  try {
-    const diff = git(['diff', 'HEAD']).out.slice(0, 12000);
-    const side = await runAgent({
-      client: ctx.client, cwd: ctx.flags.cwd,
-      permissions: createPermissions({ mode: 'plan' }),
-      messages: [{ role: 'user', content: `Write a git commit subject for this diff. Rules: imperative mood, no prefix, max 72 chars, say WHAT changed and WHY. Answer with the subject line ONLY — no quotes, no body, no markdown.\n\n${diff}` }],
-    });
-    const text = (side?.messages || []).filter((m) => m.role === 'assistant').pop();
-    const content = Array.isArray(text?.content) ? text.content.filter((b) => b.type === 'text').map((b) => b.text).join(' ') : (text?.content || '');
-    subject = content.trim().split('\n')[0].replace(/^["'`]|["'`]$/g, '').slice(0, 72);
-  } catch { /* fall through to the manual path */ }
+  // What the commit would contain, shown before anything happens — including files git
+  // does not track yet, which `git add -A` below will add.
+  const lines = status.out.split('\n');
+  out(c.dim(`  ${lines.length} file${lines.length === 1 ? '' : 's'} changed:`));
+  for (const line of lines.slice(0, 20)) out(`  ${c.dim(line)}`);
+  if (lines.length > 20) out(c.dim(`  ${glyph('…', '...')} and ${lines.length - 20} more`));
 
-  const typed = subject || '';
-  out(`  ${c.dim('Subject:')} ${c.bold(typed || '(write your own below)')}`);
-  const answer = askKey('  Commit with this message? (y)es / (e)dit / (n)o', ['y', 'e', 'n']);
-  if (answer === 'n') { warn('Commit cancelled.'); return null; }
-
-  let message = typed;
-  if (answer === 'e' || !typed) {
-    const editorMsg = git(['commit', '--dry-run', '--allow-empty'], {});
-    message = process.env.JAITUS_COMMIT_MSG || typed;
-    if (!message) { warn('No message — commit cancelled.'); return null; }
+  let subject = args.join(' ').trim();
+  if (!subject) {
+    // The model writes the message from the actual diff — with a firm brevity leash,
+    // because left alone every model writes essays.
+    const diff = git(['diff', 'HEAD'], cwd).out.slice(0, 12000) || status.out;
+    let text = '';
+    const messages = [{ role: 'user', content: `Write a git commit subject for this change. Rules: imperative mood, no prefix, max 72 chars, say WHAT changed and WHY. Answer with the subject line ONLY — no quotes, no body, no markdown.\n\n${diff}` }];
+    try {
+      if (ctx.runSide) await ctx.runSide({ messages, mode: 'plan', onText: (t) => { text += t; } });
+      else await runAgent({ client: ctx.client, model: ctx.model, cwd, permissions: createPermissions({ mode: 'plan' }), messages, silent: true, onText: (t) => { text += t; } });
+    } catch (e) {
+      warn(`Could not write a subject (${e.message}). Give one yourself: /commit <subject>`);
+      return null;
+    }
+    subject = text.trim().split('\n')[0].replace(/^["'`]|["'`]$/g, '').slice(0, 72);
+    if (!subject) { warn('No subject came back. Give one yourself: /commit <subject>'); return null; }
   }
 
-  const add = git(['add', '-A']);
+  out(`  ${c.dim('Subject:')} ${c.bold(subject)}`);
+  const answer = await choose(ctx, `Commit ${lines.length} file${lines.length === 1 ? '' : 's'} as "${subject}"?`, [
+    ['commit', 'Commit'],
+    ['push', 'Commit and push'],
+    ['no', 'Cancel'],
+  ]);
+  if (answer !== 'commit' && answer !== 'push') { warn('Commit cancelled. To use your own subject: /commit <subject>'); return null; }
+
+  const add = git(['add', '-A'], cwd);
   if (!add.ok) { fail(`Could not stage: ${add.err}`); return null; }
-  const done = git(['commit', '-m', message]);
+  const done = git(['commit', '-m', subject], cwd);
   if (!done.ok) { fail(`Commit failed: ${done.err || done.out}`); return null; }
-  ok(`Committed: ${message}`);
+  ok(`Committed: ${subject}`);
 
-  const push = askKey('  Push now? (y/N)', ['y', 'n']);
-  if (push === 'y') {
-    const branch = git(['branch', '--show-current']).out || 'main';
-    const pushed = git(['push', 'origin', branch]);
+  if (answer === 'push') {
+    const branch = git(['branch', '--show-current'], cwd).out || 'main';
+    const pushed = git(['push', 'origin', branch], cwd);
     if (pushed.ok) ok(`Pushed to origin/${branch}.`);
     else fail(`Push failed: ${pushed.err || pushed.out}`);
   }

package/src/commands/doctor.js

@@ -108,7 +108,7 @@ export default async function doctor(argv = [], { json = false } = {}) {
   // ── The account ───────────────────────────────────────────────────────────────
   if (key && reachable) {
     try {
-      const res = await reach(`${baseUrl}/api/auth/me`, { headers: { 'x-api-key': key } });
+      const res = await reach(`${baseUrl}/api/auth/me`, { headers: { authorization: `Bearer ${key}` } });
       const body = await res.json().catch(() => ({}));
       const u = body.user || body.data || {};
       if (res.ok && (u.email || u.id)) {

package/src/commands/explain.js

@@ -24,10 +24,10 @@ export default async function explain(args, ctx) {
       : `Explain the concept "${topic}" grounded in this project where it applies — read files to find real usages rather than answering abstractly. Keep it under 250 words.`;
 
   const sideMessages = [{ role: 'user', content: brief }];
-  const side = await runAgent({
-    client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd,
-    permissions: createPermissions({ mode: 'plan' }),
-    extraSystem: `You are the Jaitus explainer. Read-only: never edit files or run commands. Show file:line references for every claim about the code. Prefer short paragraphs over walls of text.`,
-  });
+  const extraSystem = `You are the Jaitus explainer. Read-only: never edit files or run commands. Show file:line references for every claim about the code. Prefer short paragraphs over walls of text.`;
+  // In the app: the transcript, Esc stops it, the session's own rules (see runSide).
+  const side = ctx.runSide
+    ? await ctx.runSide({ messages: sideMessages, mode: 'plan', extraSystem })
+    : await runAgent({ client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd, permissions: createPermissions({ mode: 'plan' }), extraSystem });
   return null;
 }

package/src/commands/logout.js

@@ -12,6 +12,8 @@ import { ok, info, warn } from '../ui.js';
 export default async function logout() {
   const { hadSession, server } = await signOut();
   if (!hadSession) {
+    // JAITUS_TOKEN signs every request by itself, so "not signed in" was untrue with it.
+    if (process.env.JAITUS_TOKEN) { info('This terminal signs in with JAITUS_TOKEN. Unset that variable to sign out; there is no saved sign-in to remove.'); return 0; }
     info('You were not signed in.');
     return 0;
   }

package/src/commands/research.js

@@ -48,12 +48,11 @@ export default async function research(args, ctx) {
   ].join('\n');
 
   const sideMessages = [{ role: 'user', content: brief }];
-  const sidePermissions = createPermissions({ mode: 'plan' }); // read-only: web tools only
-  const side = await runAgent({
-    client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd,
-    permissions: sidePermissions,
-    extraSystem: `You are the Jaitus research agent. You find things out on the web and report back with sources. You never edit files or run commands — web_search and web_fetch only. Be precise about what a source actually says; never invent a URL.`,
-  });
+  const sidePermissions = createPermissions({ mode: 'plan', allow: ['web_fetch'] }); // read-only: web tools only
+  const extraSystem = `You are the Jaitus research agent. You find things out on the web and report back with sources. You never edit files or run commands — web_search and web_fetch only. Be precise about what a source actually says; never invent a URL.`;
+  const side = ctx.runSide
+    ? await ctx.runSide({ messages: sideMessages, mode: 'plan', extraSystem, allow: ['web_fetch'] })
+    : await runAgent({ client: ctx.client, messages: sideMessages, model: ctx.model, cwd: ctx.flags.cwd, permissions: sidePermissions, extraSystem });
 
   ok(`Research complete (${side.tools || 0} tool calls, ${((side.input || 0) + (side.output || 0)).toLocaleString()} tokens).`);
   return null;

package/src/commands/review.js

@@ -64,17 +64,14 @@ export async function runReview(mode, args, ctx) {
     role: 'user',
     content: `${brief.task(target)}\n\nDiff${target ? ` (${target})` : ''}:\n${diff.out.slice(0, 30000)}${diff.out.length > 30000 ? `\n${glyph('…', '...')}(truncated)` : ''}`,
   }];
-  await runAgent({
-    client: ctx.client, messages, model: ctx.model, cwd: ctx.flags.cwd,
-    // Reviewing reads; --fix writes — so the fix pass inherits the session's
-    // own permission mode instead of smuggling in a permissive one.
-    permissions: fix
-      ? createPermissions({ mode: ctx.permissions?.mode || 'default' })
-      : createPermissions({ mode: 'plan' }),
-    extraSystem: fix
-      ? `${brief.system}\n\nAfter reporting, APPLY the fixes you recommended (minimal diffs, same style as the file). Then summarize what changed.`
-      : brief.system,
-  });
+  // Reviewing reads; --fix writes — so the fix pass inherits the session's own
+  // permission mode AND its allow/deny rules instead of smuggling in fresh ones.
+  const runMode = fix ? (ctx.permissions?.mode || 'default') : 'plan';
+  const extraSystem = fix
+    ? `${brief.system}\n\nAfter reporting, APPLY the fixes you recommended (minimal diffs, same style as the file). Then summarize what changed.`
+    : brief.system;
+  if (ctx.runSide) await ctx.runSide({ messages, mode: runMode, extraSystem });
+  else await runAgent({ client: ctx.client, messages, model: ctx.model, cwd: ctx.flags.cwd, permissions: createPermissions({ mode: runMode }), extraSystem });
   if (!fix) warn(`Run with --fix to let the agent apply the findings (permissions still ask first).`);
   return null;
 }

package/src/commands/test.js

@@ -6,7 +6,6 @@
 // only after permission, and re-runs until green or you stop it.
 //
 // Usage: /test [anything forwarded to the runner]
-import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { ok, warn, fail, out, c } from '../ui.js';
@@ -33,18 +32,25 @@ export default async function test(args, ctx) {
   const runner = detectRunner(ctx.flags.cwd);
   if (!runner) { warn('No test runner found (package.json scripts, pytest, go, cargo).'); return null; }
 
-  out(c.dim(`  Running: ${runner.label}${forward.length ? ` ${forward.join(' ')}` : ''}`));
-  const r = spawnSync(runner.cmd, [...runner.args, ...forward], {
-    cwd: ctx.flags.cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
-  });
-  const output = `${r.stdout || ''}\n${r.stderr || ''}`.trim();
+  const command = [runner.cmd, ...runner.args, ...forward].join(' ');
+  out(c.dim(`  Running: ${command}  (Esc stops it)`));
+  // Through the same runner as the agent's commands: a shell (on Windows `npm` is
+  // npm.cmd, and spawnSync without one failed every time — "Tests failed (exit null)"),
+  // the whole process tree killed on Esc or at the limit, output capped — and it no
+  // longer freezes the interface while the suite runs.
+  const { byName } = await import('../agent/tools.js');
+  const run = (signal) => byName.run_command.run({ command, timeout_ms: 600_000 }, { cwd: ctx.flags.cwd, signal });
+  const output = String(ctx.abortable ? await ctx.abortable(run) : await run(null));
+  const status = Number((/exit code: (\d+)/.exec(output) || [])[1]);
+  const body = output.replace(/\n*exit code: .*$/s, '');
 
   // Show the tail — enough to see failures, not the whole log.
-  const lines = output.split('\n');
+  const lines = body.split('\n');
   for (const line of lines.slice(-40)) out(`  ${line}`);
 
-  if (r.status === 0) { ok('All tests passed.'); return null; }
-  fail(`Tests failed (exit ${r.status}).`);
+  if (/\[stopped by the user\]/.test(output)) { warn('Test run stopped.'); return null; }
+  if (status === 0) { ok('All tests passed.'); return null; }
+  fail(`Tests failed (exit ${Number.isFinite(status) ? status : 'none'}).`);
 
   if (!wantsFix) {
     warn('Run /test --fix to let the agent fix the failures.');
@@ -59,10 +65,8 @@ export default async function test(args, ctx) {
     role: 'user',
     content: `These tests are failing in ${ctx.flags.cwd}. Diagnose and FIX them: read the failing code, make the minimal correct changes, then run \`${runner.label}\` again. Do not weaken assertions to make tests pass unless the test itself is provably wrong.\n\nFailure output (tail):\n${output.slice(-12000)}`,
   }];
-  await runAgent({
-    client: ctx.client, messages: fixMessages, model: ctx.model, cwd: ctx.flags.cwd,
-    permissions: createPermissions({ mode: ctx.permissions?.mode || 'default' }),
-    extraSystem: `You are fixing failing tests. Minimal, correct changes. Never delete a failing test to go green; fix the code (or fix the test only if the test is wrong).`,
-  });
+  const extraSystem = `You are fixing failing tests. Minimal, correct changes. Never delete a failing test to go green; fix the code (or fix the test only if the test is wrong).`;
+  if (ctx.runSide) await ctx.runSide({ messages: fixMessages, mode: ctx.permissions?.mode || 'default', extraSystem });
+  else await runAgent({ client: ctx.client, messages: fixMessages, model: ctx.model, cwd: ctx.flags.cwd, permissions: createPermissions({ mode: ctx.permissions?.mode || 'default' }), extraSystem });
   return null;
 }

package/src/commands/update.js

@@ -16,6 +16,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { c, out, ok, info, warn, fail, present, askKey } from '../ui.js';
 import { version, HOME } from '../config.js';
+import { RUNNING_FILE } from '../pendingUpdate.js';
 
 const REGISTRY = process.env.JAITUS_REGISTRY || 'https://registry.npmjs.org';
 const TIMEOUT_MS = 5000;
@@ -108,6 +109,33 @@ function run(cmd, args, { capture = false } = {}) {
   });
 }
 
+/**
+ * `npm install -g jaitus@<version>`, run so that it cannot be cut off halfway.
+ *
+ * A global install takes 30–60s (measured: 46s on Windows), and a Ctrl+C in the
+ * terminal reaches every process attached to it — npm killed mid-install can leave the
+ * package half-replaced and `jaitus` unable to start. So npm runs in its own process
+ * group (detached; windowsHide keeps Windows from opening a console for it) and carries
+ * on to the end whatever happens to this process. `onTick` gets the seconds elapsed.
+ */
+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 };
+    const child = process.platform === 'win32'
+      ? spawn(['npm', ...args].join(' '), { ...opts, shell: true })
+      : spawn('npm', args, opts);
+    if (child.pid) onStart(child.pid);
+    let stderr = '';
+    child.stderr?.on('data', (d) => { stderr = (stderr + d).slice(-4000); });
+    const t0 = Date.now();
+    const ticker = setInterval(() => onTick(Math.round((Date.now() - t0) / 1000)), 1000);
+    const finish = (code) => { clearInterval(ticker); resolve({ code, stderr: stderr.trim() }); };
+    child.on('error', () => finish(-1));
+    child.on('close', (code) => finish(code));
+  });
+}
+
 /**
  * How this copy was installed: 'npm-global', 'npx', or 'other'.
  *
@@ -158,8 +186,10 @@ export function isNewer(a, b) {
  * 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,
-  check = () => checkRegistry(), method = () => installMethod(), install = (v) => run('npm', ['install', '-g', `jaitus@${v}`], { capture: true }),
-  relaunch = defaultRelaunch, now = Date.now(), failFile = path.join(HOME, 'update-failed.json') } = {}) {
+  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 } = {}) {
   if (env.JAITUS_UPDATED_FROM) return null;                // just relaunched: never loop
   if (!updateCheckEnabled(env) || env.JAITUS_NO_AUTOUPDATE || settings.autoUpdate === false) return null;
   if (!process.stdout.isTTY || !process.stdin.isTTY) return null;   // scripts and pipes get a stable version
@@ -170,22 +200,58 @@ export async function autoUpdate({ argv = [], settings = {}, env = process.env,
     if (now - Number(failed.at) < DAY_MS) return null;
   } catch { /* no recent failure */ }
 
-  const { version: latest } = await Promise.race([
-    check(),
-    // unref: a quick command must not sit waiting for this timer after the answer came.
-    new Promise((resolve) => setTimeout(() => resolve({ version: null }), 1500).unref()),
-  ]);
+  // 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 */ }
+  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()),
+    ]));
+  }
   if (!latest || !isNewer(latest, current)) return null;
   if ((await method()) !== 'npm-global') return null;       // the in-app notice covers these
 
-  log(`  ${c.brand('Jaitus')} ${c.dim(`v${current} →`)} ${c.bold(`v${latest}`)} ${c.dim('— updating…')}`);
-  const { code } = await install(latest);
-  if (code !== 0) {
+  const head = `  ${c.brand('Jaitus')} ${c.dim(`v${current} →`)} ${c.bold(`v${latest}`)}`;
+  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
+  // SIGINT handler, which exits.
+  const onInterrupt = () => {
+    write(`\n  ${c.dim(`The update keeps installing in the background. Start ${c.bold('jaitus')} again in a minute.`)}\n`);
+  };
+  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)`)}`),
+    // 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 */ } },
+  }));
+  let result;
+  try { result = await doInstall(latest); } finally {
+    process.removeListener('SIGINT', onInterrupt);
+    try { fs.rmSync(runningFile, { force: true }); } catch { /* best effort */ }
+  }
+  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 */ }
-    log(`  ${c.yellow('!')} ${c.dim('Could not update automatically — continuing on')} v${current}${c.dim('. To update:')} ${c.bold(process.platform === 'win32' ? 'npm install -g jaitus@latest' : 'sudo npm install -g jaitus@latest')}`);
+    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 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))}`);
     return null;
   }
-  log(`  ${c.accent('✓')} ${c.dim('Updated — reopening')}`);
+  remember(latest);
+  log(`  ${c.accent('✓')} ${c.dim(`Updated to v${latest} — reopening`)}`);
   return relaunch({ ...env, JAITUS_UPDATED_FROM: current });
 }
 

package/src/config.js

@@ -75,8 +75,19 @@ export function loadSettings() {
   return readJson(SETTINGS, {});
 }
 
+// Whoever is showing settings live (the app view) is told when they change. /scroll-speed,
+// /animations, /config mouse and copyOnSelect used to say "saved" and do nothing until a
+// restart, because the app had read them once at start.
+const settingsListeners = new Set();
+export function onSettingsChange(fn) {
+  settingsListeners.add(fn);
+  return () => settingsListeners.delete(fn);
+}
+
 export function saveSettings(settings) {
-  writeJson(SETTINGS, settings, 0o644);
+  // 0600: it can hold search API keys (braveSearchKey, tavilyKey, serperKey).
+  writeJson(SETTINGS, settings, 0o600);
+  for (const fn of settingsListeners) { try { fn(settings); } catch { /* a listener never breaks a save */ } }
 }
 
 /**

package/src/errors.js

@@ -17,6 +17,10 @@ const CATALOG = {
   plan_limit_reached: { title: 'Monthly allowance used', hint: 'It resets at the start of your next period, or upgrade on the website. /usage shows where you are.' },
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },
   context_too_long: { title: 'Conversation too long', hint: 'Run /compact, or start a new session.' },
+  request_too_large: { title: 'Request too large', hint: 'Usually images: remove some, or run /compact to drop old ones. Images over 3.5 MB are shrunk automatically.' },
+  daily_limit_reached: { title: 'Daily limit reached', hint: 'Your plan\'s daily allowance resets tomorrow. /usage shows where you are.' },
+  token_expired: { title: 'Signed out', hint: 'Type /login to sign in again (or run `jaitus login`).' },
+  refresh_race: { title: 'Sign-in was being renewed', hint: 'Try again.' },
   content_blocked: { title: 'Request refused', hint: 'Rephrase the request and try again.' },
   bad_request: { title: 'Request not accepted', hint: 'Try again; if it repeats, run /debug and contact support.' },
   model_unavailable: { title: 'Model unavailable', hint: 'Run /model to pick another.' },