jaitus 0.3.18 → 0.3.20

package/src/brand.js

@@ -1,232 +1,233 @@
-// ─── Jaitus terminal identity ─────────────────────────────────────────────────
-// A coding session should look like a tool, not a launch screen. The product mark is
-// intentionally one compact coral token beside the Jaitus name; the web logo remains
-// the right place for the detailed mark, while a terminal needs recognition without
-// stealing the first screen from the work.
-
-import { c, columns, colorLevel, unicode, visibleWidth } from './ui.js';
-
-export function badge() {
-  // JAITUS_ASCII forces plain text so the mark never renders as tofu.
-  if (process.env.JAITUS_ASCII) return '[J]';
-  const level = colorLevel();
-  if (level >= 3) return '\x1b[48;2;255;107;74m\x1b[97m J \x1b[0m';
-  if (level >= 2) return '\x1b[48;5;208m\x1b[97m J \x1b[0m';
-  if (level === 1) return '\x1b[41m\x1b[97m J \x1b[0m';
-  return '[J]';
-}
-
-export function wordmark(version = '') {
-  return `${badge()} ${c.brand(c.bold('JAITUS'))}${version ? ` ${c.dim(`v${version}`)}` : ''}`;
-}
-
-// The Jaitus J alone as mascot art — no disc, no block. Sampled once from
-// the checked-in logo pixels (white-J bbox) into quadrant cells: hard-edged
-// vertices and corners, single brand ink, small and condensed.
-const MASCOT_ART = [
-  "..████▌.",
-  "......▟█",
-  "██..▟█▛▀",
-  "▀█████▌.",
-];
-// Full J for the banner showcase: same geometry, full height.
-const MARK_LARGE = [
-  "...▐███████...",
-  "...▐███████...",
-  "...▝██████▛...",
-  "..........▐███",
-  "..........▐███",
-  "▄▄▄▖...▄▄▄▟▀▀▀",
-  "███▌...████...",
-  "███▌...████...",
-  "▜██▙▄▄▄████...",
-  ".▀█████████...",
-  "..▝████████...",
-];
-/**
- * The mascot J as raw rows, for the app view to ink itself.
- *
- * Deliberately used in preference to downsampling the real badge at small sizes. A
- * 125×125 photograph reduced to eight cells is a coral blob — the white J inside it
- * lands on about two pixels and disappears. These quadrant cells were drawn for this
- * size, so the letterform survives. The photographic mark is for somewhere it has room.
- */
-export function MASCOT_ROWS() {
-  return MASCOT_ART.map((row) => row.replace(/\./g, ' '));
-}
-
-/** Mascot rows in the brand ink (pad to equal width for text lockups).
- * Dots in the grid are transparent cells, never printed. */
-export function renderMascot() {
-  const clean = MASCOT_ART.map((r) => r.replace(/\./g, ' '));
-  const width = Math.max(...clean.map((r) => [...r].length));
-  return clean.map((r) => `  ${c.brand(r + ' '.repeat(Math.max(0, width - [...r].length)))}`);
-}
-/** Full-height mark for `banner`: the complete J geometry, same ink. */
-export function renderMarkLarge() {
-  const clean = MARK_LARGE.map((r) => r.replace(/\./g, ' '));
-  const width = Math.max(...clean.map((r) => [...r].length));
-  return clean.map((r) => `  ${c.brand(r + ' '.repeat(Math.max(0, width - [...r].length)))}`);
-}
-// The JAITUS name as pure-ASCII block letters for terminals that render
-// nothing else (classic conhost raster fonts). 7 rows, 45 columns, only `#`
-// and spaces — the grand opening where block pixels would be tofu.
-const ASCII_GRAND = [
-  '      ###   ###   ##### ####### ##   ##  ######',
-  '      ###  ## ##  ##### ####### ##   ## ##',
-  '      ### ##   ## #####   ###   ##   ## ##',
-  '      ### ####### #####   ###   ##   ##  ######',
-  '  ##  ### ##   ## #####   ###   ##   ##      ##',
-  '  ##  ### ##   ## #####   ###   ##   ##      ##',
-  '   ###### ##   ## #####   ###    #####  ######',
-];
-/** ASCII grand logo rows (unstyled plain text — color never reaches these terminals). */
-export function renderAsciiGrand() {
-  return ASCII_GRAND.map((r) => `  ${r.replace(/\s+$/, '')}`);
-}
-// Fresh-session home mark in the opencode idiom: the name as 4-row block
-// letters, left half muted, right half bright, centered — the whole welcome.
-// ASCII terminals get the plain wordmark line instead of tofu.
-const HOME_LOGO_LEFT = [
-  '  █   ▀▀   █  ',
-  '  █  █  █     ',
-  '  █  █▀▀█  █  ',
-  '▀▀▀  ▀  █  █  ',
-];
-const HOME_LOGO_RIGHT = [
-  ' █   █  █  ▀▀ ',
-  '███  █  █ █   ',
-  ' █   █  █  ▀▀█',
-  ' █   ▀▀▀▀  ▀▀█',
-];
-/**
- * The same block letters as data, for the app view.
- *
- * The app renders them through a real per-character gradient, which cannot be done
- * with a pre-coloured string: the escape codes would have to be shredded mid-frame.
- * Kept here beside the art so the two surfaces can never drift apart.
- */
-export function HOME_LOGO_ROWS() {
-  return HOME_LOGO_LEFT.map((left, i) => ({ left, right: HOME_LOGO_RIGHT[i] }));
-}
-
-/** Centered two-tone JAITUS block rows for a fresh fullscreen session.
- * Both halves wear the brand coral (plain left, bold right) — the opencode
- * idiom in Jaitus ink. A full reset closes each row so no attribute leaks. */
-export function renderHomeLogo({ version = '', width = 80 } = {}) {
-  if (!unicode() || width < 40) {
-    const line = `JAITUS${version ? ` v${version}` : ''}`;
-    const pad = Math.max(0, Math.floor((width - visibleWidth(line)) / 2));
-    return [`${' '.repeat(pad)}${c.bold(line)}`];
-  }
-  const pad = Math.max(0, Math.floor((width - 29) / 2));
-  const end = colorLevel() > 0 ? '\x1b[0m' : '';
-  return HOME_LOGO_LEFT.map((l, i) => `${' '.repeat(pad)}${c.brand(l)} ${c.bold(c.brand(HOME_LOGO_RIGHT[i]))}${end}`);
-}
-/** Rotating startup tips — every one names a real command. */
-const STARTUP_TIPS = [
-  '/research digs up sources with citations',
-  '/code-review --fix ships cleaner code',
-  '/rewind un-breaks the timeline',
-  '/btw asks off the record',
-  '/branch tries the other way',
-  '/test --fix repairs failures',
-  '/explain reads the code for you',
-  '/commit writes the message',
-];
-export function startupTip() {
-  const day = Math.floor(Date.now() / 86400000);
-  return STARTUP_TIPS[day % STARTUP_TIPS.length];
-}
-/** Compact classic open: codex-style session header. Lowercase wordmark,
- * model, approval posture, directory, account — one block, pure ASCII,
- * instant. Returns plain-text lines. */
-export function renderClassicOpen({ version, model, approval, cwd, account, session, narrow }) {
-  const meta = [
-    `jaitus v${version}`,
-    `model      ${model}`,
-    `approval   ${approval}`,
-    `directory  ${cwd}`,
-    ...(account ? [`account    ${account} - session ${session}`] : [`session    ${session}`]),
-  ];
-  if (narrow) return [...meta.map((m) => `  ${m}`), `  Tip: ${startupTip()}`];
-  return [...meta.map((m) => `  ${m}`), `  Tip: ${startupTip()}`];
-}
-export function logoCard(version = '') {
-  if (process.env.JAITUS_ASCII || !unicode()) {
-    const inner = 40;
-    const bar = `  +${'-'.repeat(inner)}+`;
-    const row = (text) => `  |${text}${' '.repeat(Math.max(0, inner - visibleWidth(text)))}|`;
-    return [
-      bar,
-      row(`  ${c.brand(c.bold('J A I T U S'))}`),
-      row(`  a coding agent in your terminal  ${c.dim(`v${version}`)}`),
-      bar,
-    ];
-  }
-  return [
-    ...renderMarkLarge(),
-    `  ${c.brand(c.bold('JAITUS'))}  ${c.dim(`a coding agent in your terminal  v${version}`)}`,
-  ];
-}
-
-export function bannerLines({ version = '', width = columns() } = {}) {
-  const suffix = width >= 44 ? `  ${c.dim('coding agent')}` : '';
-  return [`  ${wordmark(version)}${suffix}`];
-}
-
-export async function banner(opts = {}) {
-  if (!process.stdout.isTTY && !opts.force) return;
-  if (process.env.JAITUS_NO_BANNER && !opts.force) return;
-  // `jaitus banner --image`: the README block-letter mark is ALWAYS printed,
-  // because a sixel-only path goes invisible on terminals that misreport the
-  // DA capability (seen on conhost: probe says yes, pixels never land, and the
-  // user sees the same quiet line as before). Real pixels go first when the
-  // probe positively confirms sixel, then the block letters guarantee ink.
-  if (opts.image) {
-    let sixelSeq = '';
-    try {
-      const { sixelSupported } = await import('./terminal.js');
-      if (sixelSupported()) {
-        const { markSixel } = await import('./sixel.js');
-        sixelSeq = markSixel({}) || '';
-      }
-    } catch { sixelSeq = ''; }
-    if (sixelSeq) process.stdout.write(`\n${sixelSeq}\n`);
-    for (const line of logoCard(opts.version || '')) process.stdout.write(`${line}\n`);
-    process.stdout.write('\n');
-    return;
-  }
-  // One-shot wordmark shimmer on interactive start: a light sweep across the
-  // brand row (~600 ms), once, only when the terminal animates. Skipped for
-  // --image, non-TTY, reduced motion, and the /banner re-draw (opts.force).
-  // The sweep paints per-character from the ANSI-stripped text — spreading the
-  // styled string would shred escape sequences mid-frame.
-  if (!opts.image && !opts.force && process.stdout.isTTY && !process.env.JAITUS_NO_ANIMATION && colorLevel() > 0 && unicode()) {
-    const styled = bannerLines(opts);
-    const plainText = (styled[0] || '').replace(/\x1b\[[0-9;]*m/g, '');
-    const chars = [...plainText];
-    const sweep = async () => {
-      for (let pos = -3; pos <= chars.length + 3; pos++) {
-        const frame = chars.map((ch, idx) => {
-          const d = Math.abs(idx - pos);
-          if (d === 0) return c.bold(`\x1b[97m${ch}\x1b[0m`);
-          if (d <= 2) return c.shimmer(ch);
-          return c.brand(ch);
-        }).join('');
-        process.stdout.write(`\r${frame}`);
-        await new Promise((r) => setTimeout(r, 24));
-      }
-      process.stdout.write(`\r${styled.join('\n')}\n\n`);
-    };
-    try { await sweep(); } catch { process.stdout.write(`${styled.join('\n')}\n\n`); }
-  } else {
-    process.stdout.write(`${bannerLines(opts).join('\n')}\n\n`);
-  }
-}
-
-// Kept as a small pure helper for the classic renderer and external integrations.
-// It is deliberately not a welcome card.
-export function welcomeLines({ version = '' } = {}) {
-  return [`  ${wordmark(version)}`];
-}
+// ─── Jaitus terminal identity ─────────────────────────────────────────────────
+// A coding session should look like a tool, not a launch screen. The product mark is
+// intentionally one compact mint token beside the Jaitus name; the web logo remains
+// the right place for the detailed mark, while a terminal needs recognition without
+// stealing the first screen from the work.
+
+import { c, columns, colorLevel, unicode, visibleWidth } from './ui.js';
+
+export function badge() {
+  // JAITUS_ASCII forces plain text so the mark never renders as tofu.
+  if (process.env.JAITUS_ASCII) return '[J]';
+  const level = colorLevel();
+  // Dark ink on mint, like the logo: white on mint would fail contrast.
+  if (level >= 3) return '\x1b[48;2;61;242;176m\x1b[38;2;3;20;13m J \x1b[0m';
+  if (level >= 2) return '\x1b[48;5;85m\x1b[38;5;16m J \x1b[0m';
+  if (level === 1) return '\x1b[42m\x1b[30m J \x1b[0m';
+  return '[J]';
+}
+
+export function wordmark(version = '') {
+  return `${badge()} ${c.brand(c.bold('JAITUS'))}${version ? ` ${c.dim(`v${version}`)}` : ''}`;
+}
+
+// The Jaitus J alone as mascot art — no disc, no block. Sampled once from
+// the checked-in logo pixels (white-J bbox) into quadrant cells: hard-edged
+// vertices and corners, single brand ink, small and condensed.
+const MASCOT_ART = [
+  "..████▌.",
+  "......▟█",
+  "██..▟█▛▀",
+  "▀█████▌.",
+];
+// Full J for the banner showcase: same geometry, full height.
+const MARK_LARGE = [
+  "...▐███████...",
+  "...▐███████...",
+  "...▝██████▛...",
+  "..........▐███",
+  "..........▐███",
+  "▄▄▄▖...▄▄▄▟▀▀▀",
+  "███▌...████...",
+  "███▌...████...",
+  "▜██▙▄▄▄████...",
+  ".▀█████████...",
+  "..▝████████...",
+];
+/**
+ * The mascot J as raw rows, for the app view to ink itself.
+ *
+ * Deliberately used in preference to downsampling the real badge at small sizes. A
+ * 125×125 photograph reduced to eight cells is a mint blob — the white J inside it
+ * lands on about two pixels and disappears. These quadrant cells were drawn for this
+ * size, so the letterform survives. The photographic mark is for somewhere it has room.
+ */
+export function MASCOT_ROWS() {
+  return MASCOT_ART.map((row) => row.replace(/\./g, ' '));
+}
+
+/** Mascot rows in the brand ink (pad to equal width for text lockups).
+ * Dots in the grid are transparent cells, never printed. */
+export function renderMascot() {
+  const clean = MASCOT_ART.map((r) => r.replace(/\./g, ' '));
+  const width = Math.max(...clean.map((r) => [...r].length));
+  return clean.map((r) => `  ${c.brand(r + ' '.repeat(Math.max(0, width - [...r].length)))}`);
+}
+/** Full-height mark for `banner`: the complete J geometry, same ink. */
+export function renderMarkLarge() {
+  const clean = MARK_LARGE.map((r) => r.replace(/\./g, ' '));
+  const width = Math.max(...clean.map((r) => [...r].length));
+  return clean.map((r) => `  ${c.brand(r + ' '.repeat(Math.max(0, width - [...r].length)))}`);
+}
+// The JAITUS name as pure-ASCII block letters for terminals that render
+// nothing else (classic conhost raster fonts). 7 rows, 45 columns, only `#`
+// and spaces — the grand opening where block pixels would be tofu.
+const ASCII_GRAND = [
+  '      ###   ###   ##### ####### ##   ##  ######',
+  '      ###  ## ##  ##### ####### ##   ## ##',
+  '      ### ##   ## #####   ###   ##   ## ##',
+  '      ### ####### #####   ###   ##   ##  ######',
+  '  ##  ### ##   ## #####   ###   ##   ##      ##',
+  '  ##  ### ##   ## #####   ###   ##   ##      ##',
+  '   ###### ##   ## #####   ###    #####  ######',
+];
+/** ASCII grand logo rows (unstyled plain text — color never reaches these terminals). */
+export function renderAsciiGrand() {
+  return ASCII_GRAND.map((r) => `  ${r.replace(/\s+$/, '')}`);
+}
+// Fresh-session home mark in the opencode idiom: the name as 4-row block
+// letters, left half muted, right half bright, centered — the whole welcome.
+// ASCII terminals get the plain wordmark line instead of tofu.
+const HOME_LOGO_LEFT = [
+  '  █   ▀▀   █  ',
+  '  █  █  █     ',
+  '  █  █▀▀█  █  ',
+  '▀▀▀  ▀  █  █  ',
+];
+const HOME_LOGO_RIGHT = [
+  ' █   █  █  ▀▀ ',
+  '███  █  █ █   ',
+  ' █   █  █  ▀▀█',
+  ' █   ▀▀▀▀  ▀▀█',
+];
+/**
+ * The same block letters as data, for the app view.
+ *
+ * The app renders them through a real per-character gradient, which cannot be done
+ * with a pre-coloured string: the escape codes would have to be shredded mid-frame.
+ * Kept here beside the art so the two surfaces can never drift apart.
+ */
+export function HOME_LOGO_ROWS() {
+  return HOME_LOGO_LEFT.map((left, i) => ({ left, right: HOME_LOGO_RIGHT[i] }));
+}
+
+/** Centered two-tone JAITUS block rows for a fresh fullscreen session.
+ * Both halves wear the brand mint (plain left, bold right) — the opencode
+ * idiom in Jaitus ink. A full reset closes each row so no attribute leaks. */
+export function renderHomeLogo({ version = '', width = 80 } = {}) {
+  if (!unicode() || width < 40) {
+    const line = `JAITUS${version ? ` v${version}` : ''}`;
+    const pad = Math.max(0, Math.floor((width - visibleWidth(line)) / 2));
+    return [`${' '.repeat(pad)}${c.bold(line)}`];
+  }
+  const pad = Math.max(0, Math.floor((width - 29) / 2));
+  const end = colorLevel() > 0 ? '\x1b[0m' : '';
+  return HOME_LOGO_LEFT.map((l, i) => `${' '.repeat(pad)}${c.brand(l)} ${c.bold(c.brand(HOME_LOGO_RIGHT[i]))}${end}`);
+}
+/** Rotating startup tips — every one names a real command. */
+const STARTUP_TIPS = [
+  '/research digs up sources with citations',
+  '/code-review --fix ships cleaner code',
+  '/rewind un-breaks the timeline',
+  '/btw asks off the record',
+  '/branch tries the other way',
+  '/test --fix repairs failures',
+  '/explain reads the code for you',
+  '/commit writes the message',
+];
+export function startupTip() {
+  const day = Math.floor(Date.now() / 86400000);
+  return STARTUP_TIPS[day % STARTUP_TIPS.length];
+}
+/** Compact classic open: a one-block session header. Lowercase wordmark,
+ * model, approval posture, directory, account — one block, pure ASCII,
+ * instant. Returns plain-text lines. */
+export function renderClassicOpen({ version, model, approval, cwd, account, session, narrow }) {
+  const meta = [
+    `jaitus v${version}`,
+    `model      ${model}`,
+    `approval   ${approval}`,
+    `directory  ${cwd}`,
+    ...(account ? [`account    ${account} - session ${session}`] : [`session    ${session}`]),
+  ];
+  if (narrow) return [...meta.map((m) => `  ${m}`), `  Tip: ${startupTip()}`];
+  return [...meta.map((m) => `  ${m}`), `  Tip: ${startupTip()}`];
+}
+export function logoCard(version = '') {
+  if (process.env.JAITUS_ASCII || !unicode()) {
+    const inner = 40;
+    const bar = `  +${'-'.repeat(inner)}+`;
+    const row = (text) => `  |${text}${' '.repeat(Math.max(0, inner - visibleWidth(text)))}|`;
+    return [
+      bar,
+      row(`  ${c.brand(c.bold('J A I T U S'))}`),
+      row(`  a coding agent in your terminal  ${c.dim(`v${version}`)}`),
+      bar,
+    ];
+  }
+  return [
+    ...renderMarkLarge(),
+    `  ${c.brand(c.bold('JAITUS'))}  ${c.dim(`a coding agent in your terminal  v${version}`)}`,
+  ];
+}
+
+export function bannerLines({ version = '', width = columns() } = {}) {
+  const suffix = width >= 44 ? `  ${c.dim('coding agent')}` : '';
+  return [`  ${wordmark(version)}${suffix}`];
+}
+
+export async function banner(opts = {}) {
+  if (!process.stdout.isTTY && !opts.force) return;
+  if (process.env.JAITUS_NO_BANNER && !opts.force) return;
+  // `jaitus banner --image`: the README block-letter mark is ALWAYS printed,
+  // because a sixel-only path goes invisible on terminals that misreport the
+  // DA capability (seen on conhost: probe says yes, pixels never land, and the
+  // user sees the same quiet line as before). Real pixels go first when the
+  // probe positively confirms sixel, then the block letters guarantee ink.
+  if (opts.image) {
+    let sixelSeq = '';
+    try {
+      const { sixelSupported } = await import('./terminal.js');
+      if (sixelSupported()) {
+        const { markSixel } = await import('./sixel.js');
+        sixelSeq = markSixel({}) || '';
+      }
+    } catch { sixelSeq = ''; }
+    if (sixelSeq) process.stdout.write(`\n${sixelSeq}\n`);
+    for (const line of logoCard(opts.version || '')) process.stdout.write(`${line}\n`);
+    process.stdout.write('\n');
+    return;
+  }
+  // One-shot wordmark shimmer on interactive start: a light sweep across the
+  // brand row (~600 ms), once, only when the terminal animates. Skipped for
+  // --image, non-TTY, reduced motion, and the /banner re-draw (opts.force).
+  // The sweep paints per-character from the ANSI-stripped text — spreading the
+  // styled string would shred escape sequences mid-frame.
+  if (!opts.image && !opts.force && process.stdout.isTTY && !process.env.JAITUS_NO_ANIMATION && colorLevel() > 0 && unicode()) {
+    const styled = bannerLines(opts);
+    const plainText = (styled[0] || '').replace(/\x1b\[[0-9;]*m/g, '');
+    const chars = [...plainText];
+    const sweep = async () => {
+      for (let pos = -3; pos <= chars.length + 3; pos++) {
+        const frame = chars.map((ch, idx) => {
+          const d = Math.abs(idx - pos);
+          if (d === 0) return c.bold(`\x1b[97m${ch}\x1b[0m`);
+          if (d <= 2) return c.shimmer(ch);
+          return c.brand(ch);
+        }).join('');
+        process.stdout.write(`\r${frame}`);
+        await new Promise((r) => setTimeout(r, 24));
+      }
+      process.stdout.write(`\r${styled.join('\n')}\n\n`);
+    };
+    try { await sweep(); } catch { process.stdout.write(`${styled.join('\n')}\n\n`); }
+  } else {
+    process.stdout.write(`${bannerLines(opts).join('\n')}\n\n`);
+  }
+}
+
+// Kept as a small pure helper for the classic renderer and external integrations.
+// It is deliberately not a welcome card.
+export function welcomeLines({ version = '' } = {}) {
+  return [`  ${wordmark(version)}`];
+}

package/src/commands/doctor.js

@@ -14,6 +14,7 @@ import { c, out, table, heading, present, colorLevel, glyph } from '../ui.js';
 import { endpoints, loadCredentials, loadSettings, HOME, version } from '../config.js';
 import { signedIn, accessToken } from '../session.js';
 import { checkRegistry, isNewer } from './update.js';
+import { freeAllowance } from '../planView.js';
 
 const TIMEOUT_MS = 8000;
 
@@ -77,9 +78,9 @@ export default async function doctor(argv = [], { json = false } = {}) {
     }
   }
 
-  // ── The gateway ───────────────────────────────────────────────────────────────
+  // ── The server ────────────────────────────────────────────────────────────────
   const { baseUrl, siteUrl } = endpoints();
-  add('Gateway', PASS, baseUrl);
+  add('Server', PASS, baseUrl);
 
   let reachable = false;
   try {
@@ -91,18 +92,18 @@ export default async function doctor(argv = [], { json = false } = {}) {
       const body = await res.json().catch(() => ({}));
       const ids = (body?.data || []).map((m) => m.id);
       add('Reachable', PASS, `HTTP ${res.status}`);
-      add('Models', ids.length ? PASS : WARN, ids.length ? ids.join(', ') : 'the gateway advertised none',
-        ids.length ? null : 'Nothing to run against. This is a gateway configuration problem, not a local one.');
+      add('Models', ids.length ? PASS : WARN, ids.length ? ids.join(', ') : 'Jaitus sent no model list',
+        ids.length ? null : 'Nothing to run against. This is a problem on the Jaitus side, not on your computer.');
     } else if (res.status === 401 || res.status === 403) {
       add('Reachable', PASS, `HTTP ${res.status}`);
       add('Session accepted', FAIL, 'Jaitus did not accept this device\'s session',
         'Run `jaitus login` again — this device may have been signed out from the website.');
     } else {
-      add('Reachable', WARN, `HTTP ${res.status}`, 'The gateway answered but not with a model list.');
+      add('Reachable', WARN, `HTTP ${res.status}`, 'Jaitus answered, but not with a model list.');
     }
   } catch (e) {
     add('Reachable', FAIL, describeNetworkError(e, baseUrl),
-      'Check your connection, and whether a proxy or firewall is between you and the gateway.');
+      'Check your connection, and whether a proxy or firewall is between you and Jaitus.');
   }
 
   // ── The account ───────────────────────────────────────────────────────────────
@@ -112,11 +113,11 @@ export default async function doctor(argv = [], { json = false } = {}) {
       const body = await res.json().catch(() => ({}));
       const u = body.user || body.data || {};
       if (res.ok && (u.email || u.id)) {
-        const plan = u.isPaid ? (u.planStatus?.name || 'paid') : `free · ${u.freeRequestsUsed ?? 0} of ${u.freeRequestLimit ?? '?'} prompts used`;
+        const plan = u.isPaid ? (u.planStatus?.name || 'paid') : `free · ${freeAllowance(u).text} used`;
         add('Account', PASS, `${u.email || 'signed in'} (${plan})`);
       } else {
         add('Account', WARN, body?.message || `HTTP ${res.status}`,
-          'The key works for the gateway but the account endpoint did not answer.');
+          'You are signed in, but your account details did not load. Try again in a minute.');
       }
     } catch (e) {
       add('Account', WARN, e.message);
@@ -126,7 +127,7 @@ export default async function doctor(argv = [], { json = false } = {}) {
   // ── The terminal ──────────────────────────────────────────────────────────────
   const settings = loadSettings();
   add('Model', settings.model ? PASS : PASS,
-    settings.model || 'not pinned — whatever the gateway lists first');
+    settings.model || 'automatic — Jaitus picks the model for each request');
   add('Website', PASS, siteUrl);
 
   // ── Is there a newer one ──────────────────────────────────────────────────────
@@ -155,7 +156,7 @@ export default async function doctor(argv = [], { json = false } = {}) {
     // Labeled swatches: if brand and error reds are indistinguishable on this
     // console, this row shows exactly which token renders wrong.
     out('');
-    out(`  ${c.dim('colors:')} level ${colorLevel()} · TERM=${process.env.TERM || '?'}${process.env.WT_SESSION ? ' · WT' : ''}${process.env.TERM_PROGRAM ? ` · ${process.env.TERM_PROGRAM}` : ''} · theme ${loadSettings().theme || 'auto'}`);
+    out(`  ${c.dim('colours:')} level ${colorLevel()} · TERM=${process.env.TERM || '?'}${process.env.WT_SESSION ? ' · WT' : ''}${process.env.TERM_PROGRAM ? ` · ${process.env.TERM_PROGRAM}` : ''} · theme ${loadSettings().theme || 'auto'}`);
     out(`  ${c.dim('brand')} ${c.brand('[Ja]')}  ${c.dim('accent')} ${c.accent('[Te]')}  ${c.dim('ok')} ${c.green('[✓]')}  ${c.dim('warn')} ${c.yellow('[!]')}  ${c.dim('error')} ${c.red('[✗]')}`);
     if (failed.length || warned.length) {
       out('');

package/src/commands/login.js

@@ -1,7 +1,7 @@
 // ─── jaitus login ───────────────────────────────────────────────────────────────
 //
 // The loopback-redirect flow from RFC 8252 (OAuth 2.0 for Native Apps) with PKCE
-// (RFC 7636), which is what `gh auth login`, Codex and the cloud CLIs use:
+// (RFC 7636), which is what `gh auth login` and the cloud CLIs use:
 //
 //   1. Start an HTTP server on a random port, bound to 127.0.0.1 only, and make a PKCE
 //      verifier that never leaves this process.
@@ -49,7 +49,7 @@ const PAGE = (title, body, accent) => `<!doctype html><meta charset="utf-8">
     body{background:#0b0f16;color:#e6edf6} h1{color:#fff} p{color:#94a3b8}
   }
 </style>
-<div class="card"><div class="dot">${accent === '#ff6b4a' ? '✓' : '✕'}</div>
+<div class="card"><div class="dot">${accent === '#1fc48a' ? '✓' : '✕'}</div>
 <h1>${title}</h1><p>${body}</p></div>`;
 
 /** Wait for the browser to come back with a code. Resolves { code } or rejects. */
@@ -98,7 +98,7 @@ function awaitCallback(server, expectedState) {
         return reject(new Error('No code returned.'));
       }
 
-      finish(200, PAGE('You‘re signed in', 'You can close this tab and go back to your terminal.', '#ff6b4a'));
+      finish(200, PAGE("You're signed in to Jaitus", 'You can close this tab and go back to your terminal.', '#1fc48a'));
       resolve({ code });
     });
   });

package/src/commands/logout.js

@@ -21,7 +21,7 @@ export default async function logout() {
     ok('Signed out of this device.');
   } else {
     ok('Signed out here.');
-    warn(`Could not reach Jaitus to end the session on the server. It will expire on its own, or sign it out at ${endpoints().siteUrl}/gateway.`);
+    warn(`Could not reach Jaitus to end the session on the server. It will expire on its own, or sign it out under Signed-in devices on your dashboard (${endpoints().siteUrl}/gateway).`);
   }
   return 0;
 }

package/src/commands/update.js

@@ -83,13 +83,22 @@ export async function cachedLatest({ now = Date.now(), file = CHECK_FILE, check
   return latest || null;
 }
 
-/** One line for the app to show when a newer version is out, or null. */
+/**
+ * One line for the app to show when a newer version is out, or null. Only a global npm
+ * install (with auto-update left on) updates itself as it starts; every other copy is
+ * told the command that gets the new version, the same advice autoUpdate() prints.
+ */
 export async function updateNotice(opts = {}) {
   if (!updateCheckEnabled(opts.env)) return null;
   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 start jaitus again: it updates itself as it starts.`;
+  const head = `Jaitus v${latest} is out — you have v${current}.`;
+  const how = await (opts.method || (() => installMethod()))().catch(() => 'other');
+  const env = opts.env || process.env;
+  if (how === 'npm-global' && !env.JAITUS_NO_AUTOUPDATE) return `${head} Quit and start jaitus again: it updates itself as it starts.`;
+  if (how === 'npx') return `${head} Start it with npx jaitus@latest.`;
+  return `${head} Update it with npm install -g jaitus@latest.`;
 }
 
 function run(cmd, args, { capture = false } = {}) {