@nonbot/cli 0.10.14 → 0.10.15

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 What changed for the person running the CLI, newest first. Update with
 `npm i -g @nonbot/cli@latest`.
 
+## 0.10.15 (2026-11-11)
+
+- New: `nonbot logout` signs you out on this machine and stops the daemon.
+- New: `nonbot update` installs the latest version. The daemon's update notice now points at it.
+- The daemon's startup list now says how to stop it (Ctrl-C in its window, or `nonbot daemon stop`) and how to sign out.
+- `nonbot doctor` is easier to read: grouped sections, bare version numbers, no wrapped lines, no rows for retired MCP servers, and a short list of commands at the end. If Run is switched off for your account, it now says so and links to where you switch it on, instead of showing "HTTP 403".
+- `nonbot doctor` now finds the non.bot MCP in a project's `.mcp.json` and in Claude Desktop, not only in `~/.claude.json`, and shows its version and how it is installed (npx, remote, global or a source checkout).
+- New: `nonbot update mcp` shows the non.bot MCP's version and updates it. A global install is updated with npm. The npx setup updates itself each time Claude Code starts it and the remote server is always current, so for those it tells you what to do instead of running anything.
+- The non.bot block wordmark is back with a shaded aqua → violet → orchid gradient, on the daemon and on the bare `nonbot` screen. The dot takes the same gradient as the letters beside it.
+- Typing `nonbot` alone shows the wordmark and a short start-here list (login · daemon · doctor · logout · update). `nonbot --help` is grouped, fits 80 columns, and no longer lists the commands only Claude Code runs.
+
 ## 0.10.14 (2026-11-11)
 
 - The README now lists what the daemon sends from your machine and who can read it.

package/README.md

@@ -58,10 +58,10 @@ nonbot daemon
 ```
 
 `nonbot doctor` is the one-stop health check and the first thing to run when something
-looks off. It reports your platform, login state, server reachability, the last daemon
-heartbeat, which provider CLIs are on `PATH`, which terminal will be launched and whether
-its launcher binary exists, the macOS Automation state for iTerm, and the MCP servers
-and skill bundles the agents expect.
+looks off. It reports your login, server reachability, whether the Run app is on for
+your account, the last daemon heartbeat, which agent CLIs are installed, which terminal
+Runs open in, the macOS Automation state for iTerm, and whether the `nonbot` MCP server
+is set up in Claude Code — then lists how to start, stop and sign out.
 
 Non-interactive login (for CI or scripting):
 
@@ -73,11 +73,13 @@ nonbot login --token "$NONBOT_PAT"
 
 ```
 nonbot login            Log in with a Personal Access Token
+nonbot logout           Sign out on this machine and stop the daemon
 nonbot daemon           Run the poll loop and launch terminals (the main command)
 nonbot run <id>         Launch a single Run by id, then exit
 nonbot status           Show login + daemon status
 nonbot doctor           Health check — platform, auth, server, providers, terminal, MCP
 nonbot logs             Show recent local Run launches
+nonbot update           Install the latest version (npm i -g @nonbot/cli@latest)
 nonbot profiles         List configured accounts
 nonbot choir <session>  Coordinated-run engine — one agent per git worktree, merged back by hand
 nonbot run-mcp          Per-pane MCP server over stdio (launched by .mcp.json, not by hand)
@@ -95,7 +97,7 @@ nonbot --version        Print the version
 | `--profile <name>` | Use a named account instead of the default (works anywhere in the command) |
 | `daemon --install` / `--uninstall` | Run the daemon automatically at login (macOS launchd / Linux systemd user unit; not available on Windows) |
 | `daemon --cloud` | Containerized runner mode — see **Cloud runners** below |
-| `daemon stop` | Stop the local daemon; `--machine <id>` / `--all` stop daemons on other machines |
+| `daemon stop` | Stop the local daemon from another terminal (or press Ctrl-C in the daemon's own window); `--machine <id>` / `--all` stop daemons on other machines |
 
 ## Cost ceilings
 

package/dist/commands/daemon.js

@@ -572,6 +572,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
         ['LISTENING', `${hostUrl}/api/cli/activations/pending`],
         ['PROFILE', profileName],
         ['LANDING', terminalLabel],
+        ['STOP', 'Ctrl-C in this window  ·  or  nonbot daemon stop  from another terminal'],
+        ['SIGN OUT', 'nonbot logout  ·  signs out on this machine and stops the daemon'],
     ];
     const LABEL_WIDTH = 9;
     for (const [k, v] of ctxRows) {

package/dist/commands/doctor.js

@@ -3,66 +3,16 @@ import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { loadAuth } from '../lib/auth.js';
+import { scanMcpConfigs, describeNonbotMcp } from '../lib/mcp-config.js';
+import { nonbotMcpStatuses, mcpRow } from '../lib/mcp-status.js';
 import { resolveTerminal } from '../lib/terminal.js';
 import { VERSION } from '../version.js';
-import { header, statusRow, errorBlock } from '../lib/output.js';
+import { header, statusRow, errorBlock, isTTY, ANSI } from '../lib/output.js';
 const HEARTBEAT_FRESH_MS = 35_000;
 const PROVIDER_CLIS = ['claude', 'codex', 'gemini'];
-const NONBOT_MCP_ADD_HINT = 'claude mcp add nonbot -e NON_BOT_API_TOKEN=pat_<token> -- npx -y @nonbot/mcp';
-const EXPECTED_MCPS = [
-    {
-        name: 'nonbot',
-        required: true,
-        present: '@nonbot/mcp',
-        absent: `not configured in ~/.claude.json — ${NONBOT_MCP_ADD_HINT}`,
-    },
-    {
-        name: 'portfolio-mcp',
-        required: false,
-        present: 'legacy — superseded by @nonbot/mcp',
-        absent: 'optional — not configured (legacy, superseded by @nonbot/mcp)',
-    },
-    {
-        name: 'context-graph',
-        required: false,
-        present: 'legacy — superseded by @nonbot/mcp',
-        absent: 'optional — not configured (legacy, superseded by @nonbot/mcp)',
-    },
-    {
-        name: 'jobshop-mcp',
-        required: false,
-        present: 'optional — JobShop is hidden for launch',
-        absent: 'optional — not configured (JobShop is hidden for launch)',
-    },
-];
+export const NONBOT_MCP_ADD_HINT = 'claude mcp add nonbot -- npx -y @nonbot/mcp';
+const LEGACY_MCPS = ['portfolio-mcp', 'context-graph', 'jobshop-mcp'];
 const EXPECTED_SKILLS = [];
-function readConfiguredMcpNames() {
-    const out = new Set();
-    try {
-        const path = join(homedir(), '.claude.json');
-        if (!existsSync(path))
-            return out;
-        const json = JSON.parse(readFileSync(path, 'utf-8'));
-        const projects = json?.projects && typeof json.projects === 'object' ? json.projects : null;
-        if (projects) {
-            for (const proj of Object.values(projects)) {
-                const servers = proj?.mcpServers;
-                if (servers && typeof servers === 'object') {
-                    for (const name of Object.keys(servers))
-                        out.add(name);
-                }
-            }
-        }
-        const top = json?.mcpServers;
-        if (top && typeof top === 'object') {
-            for (const name of Object.keys(top))
-                out.add(name);
-        }
-    }
-    catch {
-    }
-    return out;
-}
 function isSkillInstalled(skillName) {
     const base = join(homedir(), '.claude');
     const candidates = [];
@@ -136,7 +86,12 @@ function probe(cmd, args, interpret = (out) => ({
 function defaultCheckBinary(bin) {
     if (bin.startsWith('mcp:')) {
         const name = bin.slice('mcp:'.length);
-        return { installed: readConfiguredMcpNames().has(name) };
+        const scan = scanMcpConfigs();
+        if (name === 'nonbot') {
+            const first = scan.nonbot[0];
+            return first ? { installed: true, version: describeNonbotMcp(first) } : { installed: false };
+        }
+        return scan.names.has(name) ? { installed: true, version: scan.where.get(name) } : { installed: false };
     }
     if (bin.startsWith('skill:')) {
         const name = bin.slice('skill:'.length);
@@ -160,6 +115,15 @@ function defaultCheckBinary(bin) {
         return { installed: false };
     }
 }
+export function bareVersion(raw) {
+    if (!raw)
+        return '';
+    const first = raw.split('\n')[0].trim();
+    const m = first.match(/\d+(?:\.\d+)+[0-9A-Za-z.+-]*/);
+    if (m)
+        return m[0];
+    return first.length > 40 ? first.slice(0, 39) + '…' : first;
+}
 export async function runDoctorCommand(args = [], deps = {}) {
     void args;
     const log = deps.log ?? ((s) => process.stdout.write(s));
@@ -169,46 +133,42 @@ export async function runDoctorCommand(args = [], deps = {}) {
     const now = deps.now ?? (() => Date.now());
     const checkBinary = deps.checkBinary ?? defaultCheckBinary;
     let exitCode = 0;
+    const row = (sig, label, detail = '') => log(statusRow(sig, label, detail, { labelWidth: LABEL_WIDTH }) + '\n');
+    const errRow = (sig, label, detail = '') => errLog(statusRow(sig, label, detail, { labelWidth: LABEL_WIDTH, stream: process.stderr }) + '\n');
+    const hint = (text) => log(' '.repeat(HINT_INDENT) + paintDim(text) + '\n');
+    const section = (title) => log('\n' + paintSection(title) + '\n');
     log(header('non.bot doctor', `v${VERSION}  ·  ${process.platform}/${process.arch}`) + '\n');
-    log('\n');
     const auth = await loader();
     if (!auth) {
+        log('\n');
         log(errorBlock('Not logged in', 'Run `nonbot login` to authenticate.'));
         return 1;
     }
-    log(statusRow('✓', 'Auth', `logged in as ${auth.email}`) + '\n');
-    let serverOk = false;
+    section('ACCOUNT');
+    row('✓', 'Signed in', auth.email);
+    const headers = {
+        Authorization: `Bearer ${auth.pat}`,
+        'X-Requested-With': 'ConradPM-Native',
+        'X-CLI-Version': VERSION,
+    };
     try {
-        const res = await fetchImpl(`${auth.baseUrl}/api/auth/me`, {
-            headers: {
-                Authorization: `Bearer ${auth.pat}`,
-                'X-Requested-With': 'ConradPM-Native',
-                'X-CLI-Version': VERSION,
-            },
-        });
+        const res = await fetchImpl(`${auth.baseUrl}/api/auth/me`, { headers });
         if (res.ok) {
-            serverOk = true;
-            log(statusRow('✓', 'Server reachable', `${auth.baseUrl} · PAT valid`) + '\n');
+            row('✓', 'Server', `${auth.baseUrl} · token accepted`);
         }
         else if (res.status === 401) {
-            errLog(statusRow('✗', 'Server', `PAT rejected (HTTP 401) — re-run: nonbot login`, { stream: process.stderr }) + '\n');
+            errRow('✗', 'Server', 'token rejected (HTTP 401) — sign in again: nonbot login');
             exitCode = 1;
         }
         else {
-            log(statusRow('⚠', 'Server', `returned HTTP ${res.status} for /api/auth/me`) + '\n');
+            row('⚠', 'Server', `${auth.baseUrl} answered HTTP ${res.status}`);
         }
     }
     catch (e) {
-        log(statusRow('⚠', 'Server', `Could not reach ${auth.baseUrl}: ${e.message}`) + '\n');
+        row('⚠', 'Server', `Could not reach ${auth.baseUrl} (${e.message})`);
     }
     try {
-        const res = await fetchImpl(`${auth.baseUrl}/api/cli/daemon-status`, {
-            headers: {
-                Authorization: `Bearer ${auth.pat}`,
-                'X-Requested-With': 'ConradPM-Native',
-                'X-CLI-Version': VERSION,
-            },
-        });
+        const res = await fetchImpl(`${auth.baseUrl}/api/cli/daemon-status`, { headers });
         if (res.ok) {
             const body = (await res.json());
             const last = body.lastSeenAt ?? body.lastHeartbeatAt;
@@ -216,86 +176,140 @@ export async function runDoctorCommand(args = [], deps = {}) {
                 (typeof last === 'number' && now() - last <= HEARTBEAT_FRESH_MS);
             if (fresh) {
                 const detail = typeof last === 'number'
-                    ? `last heartbeat ${Math.round((now() - last) / 1000)}s ago`
-                    : 'connected';
-                log(statusRow('✓', 'Daemon running', detail) + '\n');
+                    ? `running · last heartbeat ${Math.round((now() - last) / 1000)}s ago`
+                    : 'running';
+                row('✓', 'Daemon', detail);
             }
             else {
-                log(statusRow('✗', 'Daemon not running', 'no recent heartbeat — start with: nonbot daemon') + '\n');
+                row('✗', 'Daemon', 'not running — start it: nonbot daemon');
             }
         }
         else if (res.status === 401) {
-            log(statusRow('⚠', 'Daemon status unknown', '(auth rejected)') + '\n');
+            row('⚠', 'Daemon', 'status unknown (auth rejected)');
+        }
+        else if (res.status === 403) {
+            let gate = {};
+            try {
+                gate = (await res.json());
+            }
+            catch {
+            }
+            const storeUrl = `${auth.baseUrl}/whygraph/store?tab=apps&app=${gate.app ?? 'run'}`;
+            if (gate.error === 'app_disabled') {
+                row('✗', 'Run app', 'switched off — the daemon gets no runs until it is on');
+                hint(`turn it on: ${storeUrl}`);
+            }
+            else if (gate.error === 'app_not_installed') {
+                row('✗', 'Run app', 'not added — the daemon gets no runs until it is');
+                hint(`add it: ${storeUrl}`);
+            }
+            else {
+                row('⚠', 'Daemon', 'status unknown (HTTP 403)');
+            }
         }
         else {
-            log(statusRow('⚠', 'Daemon status unknown', `(HTTP ${res.status})`) + '\n');
+            row('⚠', 'Daemon', `status unknown (HTTP ${res.status})`);
         }
     }
     catch (e) {
-        log(statusRow('⚠', 'Daemon status unknown', e.message) + '\n');
+        row('⚠', 'Daemon', `status unknown (${e.message})`);
     }
-    for (const bin of PROVIDER_CLIS) {
-        const r = checkBinary(bin);
-        if (r.installed) {
-            log(statusRow('✓', bin, r.version ? `(${r.version})` : '') + '\n');
-        }
-        else {
-            log(statusRow('⚠', bin, 'not on PATH') + '\n');
-        }
+    section('AGENTS');
+    const providers = PROVIDER_CLIS.map((bin) => ({ bin, r: checkBinary(bin) }));
+    const anyProvider = providers.some((p) => p.r.installed);
+    for (const { bin, r } of providers) {
+        if (r.installed)
+            row('✓', bin, bareVersion(r.version));
+        else if (anyProvider)
+            row('ℹ', bin, 'not installed (optional)');
+        else
+            row('⚠', bin, 'not on PATH');
     }
+    if (!anyProvider)
+        hint('Runs need one of these — install Claude Code: npm i -g @anthropic-ai/claude-code');
+    section('TERMINAL');
     const profile = resolveTerminal(undefined);
     const { cmd } = profile.launch('/tmp/nonbot-doctor-probe.sh');
     const launcher = checkBinary(cmd);
     if (launcher.installed) {
-        log(statusRow('✓', 'Terminal', `${profile.displayName} (launches via "${cmd}")`) + '\n');
+        row('✓', 'Opens runs in', `${profile.displayName} · via ${cmd}`);
     }
     else {
-        log(statusRow('⚠', 'Terminal', `${profile.displayName} — launcher "${cmd}" not found on PATH`) + '\n');
+        row('⚠', 'Terminal', `${profile.displayName} — launcher "${cmd}" not found on PATH`);
     }
     if (process.platform === 'win32') {
         const bash = checkBinary('bash');
-        if (bash.installed) {
-            log(statusRow('✓', 'Windows via WSL or Git Bash', 'bash found on PATH — Run scripts are #!/bin/bash') + '\n');
-        }
-        else {
-            log(statusRow('⚠', 'Windows via WSL or Git Bash', 'bash not found on PATH — install WSL or Git Bash; Run scripts are #!/bin/bash') + '\n');
-        }
+        if (bash.installed)
+            row('✓', 'bash', 'found · Windows via WSL or Git Bash — runs are #!/bin/bash');
+        else
+            row('⚠', 'bash', 'not found · Windows via WSL or Git Bash — runs are #!/bin/bash');
     }
     if (process.platform === 'darwin') {
         const running = checkBinary('iterm-running');
-        if (running.installed) {
-            log(statusRow('✓', 'iTerm running', '') + '\n');
-        }
-        else {
-            log(statusRow('⚠', 'iTerm not running', 'to start iTerm:  open -a iTerm') + '\n');
-        }
-        const appl = checkBinary('iterm-applescript');
-        if (appl.installed) {
-            log(statusRow('✓', 'iTerm AppleScript reachable', appl.version ?? '') + '\n');
+        if (!running.installed) {
+            row('ℹ', 'iTerm', 'not running — only needed if runs open in iTerm');
         }
         else {
-            log(statusRow('⚠', 'iTerm AppleScript', appl.version ? `probe failed: ${appl.version}` : 'probe failed') + '\n');
-            log('      ' + 'System Settings → Privacy & Security → Automation → allow your terminal to control iTerm.' + '\n');
+            const appl = checkBinary('iterm-applescript');
+            if (appl.installed) {
+                const v = bareVersion(appl.version);
+                row('✓', 'iTerm', v ? `${v} · running · AppleScript reachable` : 'running · AppleScript reachable');
+            }
+            else {
+                row('⚠', 'iTerm', appl.version ? `AppleScript blocked: ${appl.version}` : 'AppleScript blocked');
+                hint('System Settings → Privacy & Security → Automation → allow your terminal to control iTerm');
+            }
         }
     }
-    for (const mcp of EXPECTED_MCPS) {
-        const r = checkBinary(`mcp:${mcp.name}`);
-        if (r.installed) {
-            log(statusRow('✓', `MCP ${mcp.name}`, mcp.present) + '\n');
-        }
-        else {
-            log(statusRow(mcp.required ? '⚠' : 'ℹ', `MCP ${mcp.name}`, mcp.absent) + '\n');
+    section('CLAUDE CODE');
+    const statusSource = deps.nonbotMcp ?? (deps.checkBinary ? null : () => nonbotMcpStatuses({ fetchImpl: deps.fetchImpl }));
+    const statuses = statusSource ? await statusSource().catch(() => []) : null;
+    const nonbotMcp = statuses ? { installed: statuses.length > 0 } : checkBinary('mcp:nonbot');
+    if (statuses && statuses.length > 0) {
+        const r = mcpRow(statuses[0]);
+        row(r.sigil, 'nonbot MCP', r.detail);
+        if (r.hint)
+            hint(r.hint);
+    }
+    else if (nonbotMcp.installed) {
+        const how = nonbotMcp.version ?? 'configured (@nonbot/mcp)';
+        row(/pinned/.test(how) ? '⚠' : '✓', 'nonbot MCP', how);
+    }
+    else {
+        row('⚠', 'nonbot MCP', 'not set up — runs cannot report back without it');
+        hint(`add it: ${NONBOT_MCP_ADD_HINT}`);
+    }
+    for (const name of LEGACY_MCPS) {
+        const legacy = checkBinary(`mcp:${name}`);
+        if (legacy.installed) {
+            row('ℹ', name, legacy.version ? `retired — safe to delete from ${legacy.version}` : 'retired — safe to remove');
         }
     }
     for (const name of EXPECTED_SKILLS) {
         const r = checkBinary(`skill:${name}`);
-        if (r.installed) {
-            log(statusRow('✓', `Skill ${name}`, '') + '\n');
-        }
-        else {
-            log(statusRow('⚠', `Skill ${name}`, 'not installed under ~/.claude/skills/') + '\n');
-        }
+        if (r.installed)
+            row('✓', `Skill ${name}`);
+        else
+            row('⚠', `Skill ${name}`, 'not installed under ~/.claude/skills/');
     }
-    void serverOk;
+    section('COMMANDS');
+    log(commandRow('nonbot daemon', 'start listening for runs'));
+    log(commandRow('Ctrl-C', 'stop the daemon (in its window)'));
+    log(commandRow('nonbot daemon stop', 'stop it from any other terminal'));
+    log(commandRow('nonbot logout', 'sign out on this machine and stop the daemon'));
     return exitCode;
 }
+const LABEL_WIDTH = 14;
+const HINT_INDENT = 3 + 1 + 2 + LABEL_WIDTH + 1;
+function paintDim(s) {
+    return isTTY(process.stdout) ? `${ANSI.dim}${s}${ANSI.reset}` : s;
+}
+function paintSection(title) {
+    return isTTY(process.stdout) ? `   ${ANSI.bold}${title}${ANSI.reset}` : `   ${title}`;
+}
+function commandRow(cmd, what) {
+    const padded = cmd.padEnd(LABEL_WIDTH + 6, ' ');
+    if (!isTTY(process.stdout))
+        return `      ${padded}${what}\n`;
+    return `      ${ANSI.cyan}${padded}${ANSI.reset}${ANSI.dim}${what}${ANSI.reset}\n`;
+}

package/dist/commands/logout.js

@@ -0,0 +1,78 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { loadAuth, clearAuth, getActiveProfile } from '../lib/auth.js';
+import { readPidFile, stopDaemonLocally } from '../lib/daemon-lifecycle.js';
+import { header, statusRow } from '../lib/output.js';
+function defaultDaemonRunning() {
+    const pid = readPidFile();
+    if (pid !== null) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+        }
+    }
+    try {
+        const r = nodeSpawnSync('tmux', ['has-session', '-t', 'nonbot'], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+        return r.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runLogoutCommand(args = [], deps = {}) {
+    void args;
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const loader = deps.loadAuth ?? loadAuth;
+    const clear = deps.clearAuth ?? clearAuth;
+    const daemonRunning = deps.daemonRunning ?? defaultDaemonRunning;
+    const stopDaemon = deps.stopDaemon ?? ((l, e) => stopDaemonLocally({ log: l, errLog: e }));
+    const profile = getActiveProfile();
+    log(header('non.bot logout', profile === 'default' ? '' : `profile ${profile}`) + '\n\n');
+    const auth = await loader();
+    const running = daemonRunning();
+    if (!auth && !running) {
+        log(statusRow('✓', 'Already signed out', 'nothing saved on this machine, no daemon running') + '\n');
+        return 0;
+    }
+    let exitCode = 0;
+    if (auth) {
+        try {
+            await clear();
+            log(statusRow('✓', 'Signed out', `${auth.email} · token removed from this machine`) + '\n');
+        }
+        catch (e) {
+            errLog(statusRow('✗', 'Sign-out failed', `could not remove the saved token: ${e.message}`, { stream: process.stderr }) + '\n');
+            exitCode = 1;
+        }
+    }
+    else {
+        log(statusRow('✓', 'Signed out', 'no token was saved on this machine') + '\n');
+    }
+    if (running) {
+        const said = [];
+        const code = await stopDaemon((s) => said.push(s), (s) => said.push(s));
+        if (code === 0) {
+            log(statusRow('✓', 'Daemon stopped', '') + '\n');
+        }
+        else {
+            const why = said.join(' ').replace(/\s+/g, ' ').replace(/^[✓✗⚠]\s*/, '').trim();
+            errLog(statusRow('⚠', 'Daemon still running', why || 'stop it with Ctrl-C in its window', { stream: process.stderr }) + '\n');
+            exitCode = 1;
+        }
+    }
+    else {
+        log(statusRow('✓', 'Daemon', 'was not running') + '\n');
+    }
+    if (auth) {
+        log('\n');
+        log(statusRow('ℹ', 'Token', `still exists on non.bot — delete it for good at ${auth.baseUrl}/settings/connections`) + '\n');
+        log(statusRow('ℹ', 'Sign back in', 'nonbot login') + '\n');
+    }
+    return exitCode;
+}

package/dist/commands/update.js

@@ -0,0 +1,157 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { dirname, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VERSION } from '../version.js';
+import { fetchLatestVersion, compareVersions } from '../lib/update-check.js';
+import { readPidFile } from '../lib/daemon-lifecycle.js';
+import { header, statusRow } from '../lib/output.js';
+import { nonbotMcpStatuses, mcpRow, globalMcpIsLinked } from '../lib/mcp-status.js';
+export const UPDATE_INSTALL_ARGS = ['install', '-g', '@nonbot/cli@latest'];
+function defaultEntryPath() {
+    const here = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(here);
+    }
+    catch {
+        return here;
+    }
+}
+export function isLinkedCheckout(entry) {
+    const marker = `${sep}node_modules${sep}@nonbot${sep}cli${sep}`;
+    return !entry.split('/').join(sep).includes(marker);
+}
+function checkoutRoot(entry) {
+    let d = dirname(entry);
+    while (d !== dirname(d)) {
+        if (d.endsWith(`${sep}dist`))
+            return dirname(d);
+        d = dirname(d);
+    }
+    return dirname(entry);
+}
+function defaultRunNpm(args) {
+    const r = nodeSpawnSync('npm', [...args], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+    });
+    if (r.error)
+        return 127;
+    return r.status ?? 1;
+}
+function defaultDaemonRunning() {
+    const pid = readPidFile();
+    if (pid === null)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runUpdateCommand(args = [], deps = {}) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const positional = args.filter((a) => !a.startsWith('-'));
+    if (positional[0] === 'mcp')
+        return runUpdateMcpCommand(args.slice(1), deps);
+    if (positional.length > 0) {
+        errLog(`nonbot update: unknown target "${positional[0]}". Try: nonbot update  (this CLI)  ·  nonbot update mcp  (the non.bot MCP)\n`);
+        return 1;
+    }
+    const current = deps.current ?? VERSION;
+    const fetchLatest = deps.fetchLatest ?? (() => fetchLatestVersion());
+    const entry = (deps.entryPath ?? defaultEntryPath)();
+    const runNpm = deps.runNpm ?? defaultRunNpm;
+    const daemonRunning = deps.daemonRunning ?? defaultDaemonRunning;
+    const force = args.includes('--force');
+    log(header('non.bot update', `v${current}`) + '\n\n');
+    const latest = await fetchLatest();
+    if (!latest) {
+        errLog(statusRow('⚠', 'Registry', 'could not read the latest version from npm — check your connection', { stream: process.stderr }) + '\n');
+        errLog(`   or install it directly:  npm ${UPDATE_INSTALL_ARGS.join(' ')}\n`);
+        return 1;
+    }
+    if (compareVersions(latest, current) <= 0) {
+        log(statusRow('✓', 'Up to date', `v${current} is the latest`) + '\n');
+        return 0;
+    }
+    log(statusRow('ℹ', 'Update', `v${current} → v${latest}`) + '\n');
+    if (isLinkedCheckout(entry) && !force) {
+        const root = checkoutRoot(entry);
+        log(statusRow('⚠', 'Linked copy', `this nonbot runs from a source checkout: ${root}`) + '\n');
+        log(`   update the checkout:      cd ${root} && git pull && npm run build\n`);
+        log(`   or replace the link with the published v${latest}:  nonbot update --force\n`);
+        return 0;
+    }
+    log(`\n   npm ${UPDATE_INSTALL_ARGS.join(' ')}\n\n`);
+    const code = runNpm(UPDATE_INSTALL_ARGS);
+    log('\n');
+    if (code !== 0) {
+        errLog(statusRow('✗', 'Update failed', `npm exited ${code} — see its output above`, { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    log(statusRow('✓', 'Updated', `v${latest} installed`) + '\n');
+    if (daemonRunning()) {
+        log(statusRow('ℹ', 'Daemon', 'still running the old version — restart it to use the new one:') + '\n');
+        log('   Ctrl-C in its window (or: nonbot daemon stop), then: nonbot daemon\n');
+    }
+    return 0;
+}
+export const MCP_INSTALL_ARGS = ['install', '-g', '@nonbot/mcp@latest'];
+export async function runUpdateMcpCommand(args = [], deps = {}) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const statusesOf = deps.mcpStatuses ?? (() => nonbotMcpStatuses());
+    const runNpm = deps.runNpm ?? defaultRunNpm;
+    const linked = deps.globalMcpLinked ?? (() => globalMcpIsLinked());
+    const force = args.includes('--force');
+    const W = 14;
+    const row = (sig, label, detail = '') => log(statusRow(sig, label, detail, { labelWidth: W }) + '\n');
+    const hint = (text) => log(' '.repeat(3 + 1 + 2 + W + 1) + text + '\n');
+    const statuses = await statusesOf();
+    const latest = statuses.find((s) => s.latest)?.latest ?? null;
+    log(header('non.bot update mcp', latest ? `v${latest} on npm` : 'npm not reachable') + '\n\n');
+    if (statuses.length === 0) {
+        row('⚠', 'nonbot MCP', 'not set up in Claude Code');
+        hint('add it: claude mcp add nonbot -- npx -y @nonbot/mcp');
+        return 0;
+    }
+    let changed = false;
+    let failed = false;
+    let globalDone = false;
+    for (const s of statuses) {
+        const r = mcpRow(s);
+        row(r.sigil, 'nonbot MCP', r.detail);
+        hint(`in ${s.entry.source}`);
+        const behind = !!(s.installed && s.latest && compareVersions(s.latest, s.installed) > 0);
+        if (s.entry.kind === 'global' && (behind || !s.installed) && !globalDone) {
+            globalDone = true;
+            if (linked() && !force) {
+                hint('the global @nonbot/mcp is linked to a source checkout — left alone (nonbot update mcp --force replaces it)');
+                continue;
+            }
+            log(`\n   npm ${MCP_INSTALL_ARGS.join(' ')}\n\n`);
+            const code = runNpm(MCP_INSTALL_ARGS);
+            log('\n');
+            if (code === 0) {
+                row('✓', 'Updated', latest ? `@nonbot/mcp v${latest} installed` : '@nonbot/mcp installed');
+                changed = true;
+            }
+            else {
+                errLog(statusRow('✗', 'Update failed', `npm exited ${code} — see its output above`, { labelWidth: W, stream: process.stderr }) + '\n');
+                failed = true;
+            }
+        }
+        else if (r.hint) {
+            hint(r.hint);
+        }
+    }
+    if (changed) {
+        log('\n');
+        row('ℹ', 'Load it', 'restart Claude Code, or run /mcp → Reconnect');
+    }
+    return failed ? 1 : 0;
+}

package/dist/index.js

@@ -6,95 +6,159 @@ import { runDaemonCommand } from './commands/daemon.js';
 import { runLoginCommand } from './commands/login.js';
 import { runRunCommand } from './commands/run.js';
 import { runDoctorCommand } from './commands/doctor.js';
+import { runLogoutCommand } from './commands/logout.js';
+import { runUpdateCommand } from './commands/update.js';
 import { runLogsCommand } from './commands/logs.js';
 import { runProfilesCommand } from './commands/profiles.js';
 import { runChoirCommand } from './commands/choir.js';
 import { runRunMcpCommand } from './commands/run-mcp.js';
 import { runRunPromptHookCommand } from './commands/run-prompt-hook.js';
 import { setActiveProfile } from './lib/auth.js';
-import { header, kvRow, ANSI, isTTY } from './lib/output.js';
+import { header, kvRow, ANSI, isTTY, wordmarkArt, WORDMARK_WIDTH } from './lib/output.js';
 const COMMANDS = [
     {
         name: 'login',
-        description: 'Paste a PAT from /settings/connections; saves to ~/.config/nonbot/auth.json.',
+        description: 'Sign in with a token from non.bot Settings → Connections',
+        group: 'start',
         run: (args) => runLoginCommand(args),
     },
+    {
+        name: 'logout',
+        description: 'Sign out on this machine and stop the daemon',
+        group: 'start',
+        run: (args) => runLogoutCommand(args),
+    },
     {
         name: 'daemon',
-        description: 'Long-running listener — polls /api/cli/activations/pending every 2s. `nonbot daemon stop` stops it (local; --machine <id> / --all go remote); `nonbot daemon attach` reattaches a lost tmux window.',
+        description: 'Listen for runs from non.bot; each opens a terminal here',
+        group: 'start',
         run: (args) => runDaemonCommand(args),
     },
+    {
+        name: 'update',
+        description: 'Install the latest version · update mcp: the non.bot MCP',
+        usage: 'update [mcp]',
+        group: 'start',
+        run: (args) => runUpdateCommand(args),
+    },
+    {
+        name: 'status',
+        description: 'Who is signed in and whether the daemon is connected',
+        group: 'check',
+        run: (args) => runStatusCommand(args),
+    },
+    {
+        name: 'doctor',
+        description: 'Health check: account, agents, terminal, Claude Code',
+        group: 'check',
+        run: (args) => runDoctorCommand(args),
+    },
+    {
+        name: 'logs',
+        description: 'Runs launched on this machine (--limit <n>, --json, -f)',
+        group: 'check',
+        run: (args) => runLogsCommand(args),
+    },
     {
         name: 'run',
-        description: 'One-shot: fire a single activation by id. Usage: nonbot run <activation-id>',
+        usage: 'run <id>',
+        description: 'Launch one run by id, then exit',
+        group: 'more',
         run: (args) => runRunCommand(args),
     },
     {
         name: 'choir',
-        description: 'Coordinated-run engine: launch a fleet — one agent per git worktree, merged back by hand. Usage: nonbot choir <session> [--panes N] [--base <b>] [--join <mode>]',
+        description: 'Coordinated-run engine — one agent per git worktree',
+        usage: 'choir <session>',
+        group: 'more',
         run: (args) => runChoirCommand(args),
     },
+    {
+        name: 'profiles',
+        description: 'List signed-in accounts (pick one with --profile <name>)',
+        group: 'more',
+        run: (args) => runProfilesCommand(args),
+    },
+    {
+        name: 'test',
+        description: 'Print a local diagnostic banner (no server needed)',
+        group: 'more',
+        run: () => runTestCommand(),
+    },
     {
         name: 'run-mcp',
         description: 'Per-pane fleet MCP server over stdio. Launched by .mcp.json — not run by hand.',
+        group: 'hidden',
         run: () => runRunMcpCommand(),
     },
     {
         name: 'choir-mcp',
         description: 'Deprecated alias for run-mcp.',
+        group: 'hidden',
         run: () => runRunMcpCommand(),
     },
     {
         name: 'run-prompt-hook',
         description: "Claude Code Notification-hook handler — surfaces a Run's mid-run prompt. Not run by hand.",
+        group: 'hidden',
         run: () => runRunPromptHookCommand(),
     },
-    {
-        name: 'status',
-        description: 'Report login state + last daemon heartbeat.',
-        run: (args) => runStatusCommand(args),
-    },
-    {
-        name: 'doctor',
-        description: 'Health check — auth, server, daemon, provider CLIs, terminal.',
-        run: (args) => runDoctorCommand(args),
-    },
-    {
-        name: 'logs',
-        description: 'Local activation history. Flags: --limit <n>, --json, --follow/-f.',
-        run: (args) => runLogsCommand(args),
-    },
-    {
-        name: 'profiles',
-        description: 'List multi-account auth profiles; marks the active one.',
-        run: (args) => runProfilesCommand(args),
-    },
-    {
-        name: 'test',
-        description: 'Print the diagnostic banner locally — no server roundtrip.',
-        run: () => runTestCommand(),
-    },
 ];
 function printVersion() {
     process.stdout.write(VERSION + '\n');
 }
 function printHelp() {
     const tty = isTTY(process.stdout);
+    const head = (t) => (tty ? `   ${ANSI.bold}${t}${ANSI.reset}` : `   ${t}`);
+    const KEY = 18;
     const lines = [];
-    lines.push(header('nonbot', `non.bot CLI host  ·  v${VERSION}`));
+    lines.push(header('nonbot', `non.bot CLI  ·  v${VERSION}`));
+    lines.push('');
+    lines.push(kvRow('Usage', 'nonbot <command> [args]', { keyWidth: KEY }));
+    const section = (title, group) => {
+        lines.push('');
+        lines.push(head(title));
+        for (const cmd of COMMANDS.filter((c) => c.group === group)) {
+            lines.push(kvRow(cmd.usage ?? cmd.name, cmd.description, { keyWidth: KEY }));
+        }
+    };
+    section('Get started', 'start');
+    lines.push('');
+    lines.push(head('Stop the daemon'));
+    lines.push(kvRow('Ctrl-C', 'in the daemon\'s window', { keyWidth: KEY }));
+    lines.push(kvRow('daemon stop', 'from another terminal (--machine <id> / --all)', { keyWidth: KEY }));
+    lines.push(kvRow('daemon attach', 'bring back a closed daemon window', { keyWidth: KEY }));
+    section('Check', 'check');
+    section('More', 'more');
     lines.push('');
-    lines.push(tty ? `   ${ANSI.cyan}Usage${ANSI.reset}      ${ANSI.dim}nonbot <command> [args]${ANSI.reset}` : '   Usage      nonbot <command> [args]');
+    lines.push(head('Flags'));
+    lines.push(kvRow('--profile <name>', 'use a named account (works with any command)', { keyWidth: KEY }));
+    lines.push(kvRow('-v, --version', 'print the version', { keyWidth: KEY }));
+    lines.push(kvRow('-h, --help', 'print this help', { keyWidth: KEY }));
     lines.push('');
-    lines.push(tty ? `   ${ANSI.cyan}Commands${ANSI.reset}` : '   Commands');
-    const w = COMMANDS.reduce((m, c) => Math.max(m, c.name.length), 0);
-    for (const cmd of COMMANDS) {
-        lines.push(kvRow(cmd.name, cmd.description, { keyWidth: w }));
+    process.stdout.write(lines.join('\n') + '\n');
+}
+function printQuickStart() {
+    const KEY = 8;
+    const lines = [];
+    const cols = process.stdout.columns ?? 0;
+    if (cols === 0 || cols >= WORDMARK_WIDTH + 4) {
+        lines.push('');
+        lines.push(wordmarkArt({ indent: '  ' }));
+        lines.push('');
+        lines.push(kvRow('', `the non.bot CLI · v${VERSION}`, { keyWidth: KEY }));
     }
+    else {
+        lines.push(header('non.bot CLI', `v${VERSION}`));
+    }
+    lines.push('');
+    lines.push(kvRow('login', 'sign in', { keyWidth: KEY }));
+    lines.push(kvRow('daemon', 'listen for runs — Ctrl-C stops it', { keyWidth: KEY }));
+    lines.push(kvRow('doctor', 'check that everything is set up', { keyWidth: KEY }));
+    lines.push(kvRow('logout', 'sign out and stop the daemon', { keyWidth: KEY }));
+    lines.push(kvRow('update', 'install the latest version', { keyWidth: KEY }));
     lines.push('');
-    lines.push(tty ? `   ${ANSI.cyan}Flags${ANSI.reset}` : '   Flags');
-    lines.push(kvRow('--profile <name>', 'Use a named auth profile (multi-account). Default: "default".', { keyWidth: 18 }));
-    lines.push(kvRow('-v, --version', 'Print CLI version and exit.', { keyWidth: 18 }));
-    lines.push(kvRow('-h, --help', 'Print this help and exit.', { keyWidth: 18 }));
+    lines.push(kvRow('', 'type nonbot <command> · nonbot --help lists everything', { keyWidth: KEY }));
     lines.push('');
     process.stdout.write(lines.join('\n') + '\n');
 }
@@ -131,7 +195,7 @@ async function main(argv) {
         }
     }
     if (args.length === 0) {
-        printHelp();
+        printQuickStart();
         return 0;
     }
     const first = args[0];

package/dist/lib/mcp-config.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve, isAbsolute } from 'node:path';
+function defaultReadFile(path) {
+    try {
+        return existsSync(path) ? readFileSync(path, 'utf-8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tilde(path, home) {
+    return path.startsWith(home) ? '~' + path.slice(home.length) : path;
+}
+export function classifyServer(name, server, baseDir) {
+    const args = Array.isArray(server.args) ? server.args.filter((a) => typeof a === 'string') : [];
+    const command = typeof server.command === 'string' ? server.command : '';
+    const url = typeof server.url === 'string' ? server.url : '';
+    if (/(^|\/\/|\.)mcp\.non\.bot\b/.test(url) || args.some((a) => /mcp\.non\.bot/.test(a))) {
+        return { kind: 'remote' };
+    }
+    const spec = args.find((a) => /^@nonbot\/mcp(@[^\s]+)?$/.test(a));
+    if (spec) {
+        const at = spec.indexOf('@', 1);
+        const version = at > 0 ? spec.slice(at + 1) : undefined;
+        return { kind: 'npx', pinned: version && version !== 'latest' ? version : undefined };
+    }
+    if (basename(command) === 'nonbot-mcp' || basename(command) === 'nonbot-mcp.cmd') {
+        return { kind: 'global' };
+    }
+    const script = [command, ...args].find((a) => /nonbot-mcp[\\/]+dist[\\/]+stdio\.js$/.test(a));
+    if (script) {
+        const abs = isAbsolute(script) ? script : resolve(baseDir, script);
+        return { kind: 'checkout', checkoutDir: dirname(dirname(abs)) };
+    }
+    if (name === 'nonbot')
+        return { kind: 'unknown' };
+    return null;
+}
+function serversIn(json) {
+    const servers = json?.mcpServers;
+    if (!servers || typeof servers !== 'object')
+        return [];
+    return Object.entries(servers).filter(([, v]) => v !== null && typeof v === 'object');
+}
+function parse(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export function scanMcpConfigs(deps = {}) {
+    const home = deps.home ?? homedir();
+    const cwd = deps.cwd ?? process.cwd();
+    const platform = deps.platform ?? process.platform;
+    const read = deps.readFile ?? defaultReadFile;
+    const names = new Set();
+    const where = new Map();
+    const nonbot = [];
+    const seenFiles = new Set();
+    const take = (source, json, baseDir) => {
+        for (const [name, server] of serversIn(json)) {
+            names.add(name);
+            if (!where.has(name))
+                where.set(name, source);
+            const c = classifyServer(name, server, baseDir);
+            if (c)
+                nonbot.push({ source, name, ...c });
+        }
+    };
+    const claudeJsonPath = join(home, '.claude.json');
+    const claudeJson = parse(read(claudeJsonPath));
+    const projectDirs = [];
+    if (claudeJson) {
+        take('~/.claude.json', claudeJson, home);
+        if (claudeJson.projects && typeof claudeJson.projects === 'object') {
+            for (const [dir, proj] of Object.entries(claudeJson.projects)) {
+                take(`~/.claude.json (${tilde(dir, home)})`, proj, dir);
+                projectDirs.push(dir);
+            }
+        }
+    }
+    const mcpJsonDirs = [];
+    for (let d = resolve(cwd);; d = dirname(d)) {
+        mcpJsonDirs.push(d);
+        if (d === dirname(d) || d === home)
+            break;
+    }
+    mcpJsonDirs.push(...projectDirs);
+    for (const dir of mcpJsonDirs) {
+        const file = join(dir, '.mcp.json');
+        if (seenFiles.has(file))
+            continue;
+        seenFiles.add(file);
+        const json = parse(read(file));
+        if (json)
+            take(tilde(file, home), json, dir);
+    }
+    if (platform === 'darwin') {
+        const desktop = join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        const json = parse(read(desktop));
+        if (json)
+            take('Claude Desktop', json, home);
+    }
+    return { names, where, nonbot };
+}
+export function describeNonbotMcp(e, home = homedir()) {
+    switch (e.kind) {
+        case 'remote':
+            return 'remote (mcp.non.bot) · always current';
+        case 'npx':
+            return e.pinned ? `npx, pinned to ${e.pinned} · gets no updates` : 'npx @nonbot/mcp · updates itself';
+        case 'global':
+            return 'global install · update: npm i -g @nonbot/mcp';
+        case 'checkout':
+            return `source checkout ${e.checkoutDir ? tilde(e.checkoutDir, home) : ''}`.trim();
+        default:
+            return 'configured';
+    }
+}

package/dist/lib/mcp-status.js

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync, readdirSync, lstatSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fetchLatestVersion, compareVersions, parseSemver } from './update-check.js';
+import { scanMcpConfigs, describeNonbotMcp } from './mcp-config.js';
+export const MCP_LATEST_URL = 'https://registry.npmjs.org/@nonbot/mcp/latest';
+export const MCP_REMOTE_URL = 'https://mcp.non.bot/';
+function readVersion(pkgJsonPath) {
+    try {
+        if (!existsSync(pkgJsonPath))
+            return null;
+        const v = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')).version;
+        return parseSemver(v) ? String(v) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function defaultGlobalRoot(execPath = process.execPath, platform = process.platform) {
+    return platform === 'win32'
+        ? join(dirname(execPath), 'node_modules')
+        : join(dirname(dirname(execPath)), 'lib', 'node_modules');
+}
+export function globalMcpIsLinked(globalRoot = defaultGlobalRoot()) {
+    try {
+        return lstatSync(join(globalRoot, '@nonbot', 'mcp')).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function npxCachedMcpVersion(env = process.env, home = homedir()) {
+    const root = join(env.npm_config_cache || join(home, '.npm'), '_npx');
+    let best = null;
+    let dirs = [];
+    try {
+        dirs = readdirSync(root);
+    }
+    catch {
+        return null;
+    }
+    for (const hash of dirs) {
+        const v = readVersion(join(root, hash, 'node_modules', '@nonbot', 'mcp', 'package.json'));
+        if (v && (best === null || compareVersions(v, best) > 0))
+            best = v;
+    }
+    return best;
+}
+export async function remoteMcpVersion(fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(MCP_REMOTE_URL, {
+            headers: { Accept: 'text/html' },
+            signal: AbortSignal.timeout(3_000),
+        });
+        if (!res.ok)
+            return null;
+        const m = /version\s+(\d{1,6}\.\d{1,6}\.\d{1,6})\b/.exec(await res.text());
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function installedMcpVersion(entry, deps = {}) {
+    switch (entry.kind) {
+        case 'checkout':
+            return entry.checkoutDir ? readVersion(join(entry.checkoutDir, 'package.json')) : null;
+        case 'npx':
+            return entry.pinned && parseSemver(entry.pinned) ? entry.pinned : npxCachedMcpVersion(deps.env, deps.home);
+        case 'global':
+            return readVersion(join(deps.globalRoot ?? defaultGlobalRoot(), '@nonbot', 'mcp', 'package.json'));
+        case 'remote':
+            return remoteMcpVersion(deps.fetchImpl);
+        default:
+            return null;
+    }
+}
+export async function nonbotMcpStatuses(deps = {}) {
+    const entries = scanMcpConfigs(deps).nonbot;
+    if (entries.length === 0)
+        return [];
+    const [latest, installed] = await Promise.all([
+        fetchLatestVersion({ url: MCP_LATEST_URL, fetchImpl: deps.fetchImpl }),
+        Promise.all(entries.map((e) => installedMcpVersion(e, deps))),
+    ]);
+    return entries.map((entry, i) => ({ entry, installed: installed[i] ?? null, latest }));
+}
+export function mcpRow(s, home = homedir()) {
+    const how = describeNonbotMcp(s.entry, home);
+    const v = s.installed ? `v${s.installed} · ` : '';
+    const behind = !!(s.installed && s.latest && compareVersions(s.latest, s.installed) > 0);
+    const e = s.entry;
+    if (e.kind === 'npx' && e.pinned) {
+        return {
+            sigil: '⚠',
+            detail: `${v}npx, pinned · gets no updates`,
+            hint: 'unpin it: claude mcp remove nonbot && claude mcp add nonbot -- npx -y @nonbot/mcp',
+        };
+    }
+    if (!behind) {
+        if (e.kind === 'npx' && !s.installed) {
+            return { sigil: '✓', detail: `npx @nonbot/mcp · fetches ${s.latest ? `v${s.latest}` : 'the latest'} on first start` };
+        }
+        return { sigil: '✓', detail: `${v}${how}` };
+    }
+    const out = `v${s.installed} · ${shortKind(e.kind)} · v${s.latest} is out`;
+    switch (e.kind) {
+        case 'npx':
+            return { sigil: 'ℹ', detail: out, hint: 'restart Claude Code (or /mcp → Reconnect) and npx fetches it' };
+        case 'global':
+            return { sigil: '⚠', detail: out, hint: 'update it: nonbot update mcp' };
+        case 'checkout':
+            return {
+                sigil: 'ℹ',
+                detail: out,
+                hint: `update the checkout: cd ${e.checkoutDir ? tildePath(e.checkoutDir, home) : '<checkout>'} && git pull && npm run build`,
+            };
+        default:
+            return { sigil: 'ℹ', detail: out };
+    }
+}
+function shortKind(kind) {
+    return kind === 'npx' ? 'npx @nonbot/mcp' : kind === 'checkout' ? 'source checkout' : kind === 'global' ? 'global install' : kind;
+}
+function tildePath(p, home) {
+    return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}

package/dist/lib/output.js

@@ -144,11 +144,40 @@ const WORDMARK_LINES = [
 export const WORDMARK_WIDTH = 63;
 export const WORDMARK_HEIGHT = 6;
 export const WORDMARK_DOT_COLS = [31, 32, 33];
+export const WORDMARK_GRADIENT_STOPS = [
+    [0x5e, 0xd8, 0xf0],
+    [0x6c, 0x8c, 0xff],
+    [0x9b, 0x6c, 0xf0],
+    [0xe0, 0x7a, 0xd8],
+];
+const WORDMARK_SHEEN = [0.24, 0.15, 0.07, 0, 0, 0];
+const WORDMARK_SHADOW = 0.55;
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+export function wordmarkCellColor(col, row, shadow = false) {
+    const span = WORDMARK_WIDTH - 1 + (WORDMARK_HEIGHT - 1) * 1.5;
+    const t = Math.min(1, Math.max(0, (col + row * 1.5) / span));
+    const stops = WORDMARK_GRADIENT_STOPS;
+    const seg = Math.min(stops.length - 2, Math.floor(t * (stops.length - 1)));
+    const local = t * (stops.length - 1) - seg;
+    const a = stops[seg];
+    const b = stops[seg + 1];
+    let rgb = [lerp(a[0], b[0], local), lerp(a[1], b[1], local), lerp(a[2], b[2], local)];
+    if (shadow) {
+        rgb = [rgb[0] * WORDMARK_SHADOW, rgb[1] * WORDMARK_SHADOW, rgb[2] * WORDMARK_SHADOW];
+    }
+    else {
+        const sheen = WORDMARK_SHEEN[row] ?? 0;
+        rgb = [lerp(rgb[0], 255, sheen), lerp(rgb[1], 255, sheen), lerp(rgb[2], 255, sheen)];
+    }
+    return [Math.round(rgb[0]), Math.round(rgb[1]), Math.round(rgb[2])];
+}
 function hexFg(hex) {
     const n = parseInt(hex.slice(1), 16);
     return `\x1b[38;2;${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}m`;
 }
-function paintWordmarkLine(line, stream = process.stdout) {
+function paintWordmarkLine(line, row, stream = process.stdout) {
     if (!isTTY(stream))
         return line;
     const chars = Array.from(line);
@@ -159,11 +188,16 @@ function paintWordmarkLine(line, stream = process.stdout) {
             out += ' ';
             continue;
         }
-        const colour = WORDMARK_DOT_COLS.includes(i) ? BRAND.blue : BRAND.cream;
-        out += BRAND.bold + colour + ch + BRAND.reset;
+        const [r, g, b] = wordmarkCellColor(i, row, ch !== '█');
+        out += `${BRAND.bold}\x1b[38;2;${r};${g};${b}m${ch}${BRAND.reset}`;
     }
     return out;
 }
+export function wordmarkArt(opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const indent = opts.indent ?? '';
+    return WORDMARK_LINES.map((line, row) => indent + paintWordmarkLine(line, row, stream)).join('\n');
+}
 export function terminalWidth(width) {
     const cols = width ?? (process.stdout && process.stdout.columns) ?? 80;
     const min = WORDMARK_WIDTH + 6;
@@ -180,7 +214,7 @@ function trackedCaps(s) {
 export function wordmark(version, opts = {}) {
     const stream = opts.stream ?? process.stdout;
     const state = opts.state;
-    const headLines = WORDMARK_LINES.map((line) => paintWordmarkLine(line, stream));
+    const headLines = WORDMARK_LINES.map((line, row) => paintWordmarkLine(line, row, stream));
     const parts = [c.cyan(trackedCaps('DAEMON'), stream)];
     if (version) {
         parts.push(c.muted('·', stream));
@@ -207,7 +241,7 @@ export function renderWordmarkWithBadge(opts = {}) {
         red: (s) => c.red(s, stream),
         muted: (s) => c.muted(s, stream),
     };
-    const lines = WORDMARK_LINES.map((wm) => paintWordmarkLine(wm, stream));
+    const lines = WORDMARK_LINES.map((wm, row) => paintWordmarkLine(wm, row, stream));
     lines.push('');
     lines.push(`  ${dotColored[color]('●')}  ${dotColored[color](label)}`);
     for (const s of sublines) {
@@ -360,7 +394,7 @@ export function compactMasthead(version, opts = {}) {
     const badgeColor = opts.badgeColor ?? 'green';
     const badgeLabel = opts.badgeLabel ?? 'CONNECTED';
     const dotGlyph = asciiOnly() ? '*' : '●';
-    const brand = `${c.bold(c.cream('non.bot', stream), stream)}${c.blue('.', stream)}`;
+    const brand = c.bold(c.cream('non.bot', stream), stream);
     const badge = colorize(`${dotGlyph} ${badgeLabel}`, badgeColor, stream);
     const sep = c.muted('·', stream);
     const tail = [c.muted(`daemon ${version}`, stream), sep, c.muted(state, stream)].join(' ');

package/dist/lib/update-check.js

@@ -35,7 +35,7 @@ export function isNewerVersion(latest, current) {
     return compareVersions(latest, current) > 0;
 }
 export function updateAvailableLine(current, latest) {
-    return `Update available: @nonbot/cli ${current} → ${latest}  (npm i -g @nonbot/cli)`;
+    return `Update available: @nonbot/cli ${current} → ${latest}  (run: nonbot update)`;
 }
 export async function fetchLatestVersion(opts = {}) {
     const fetchImpl = opts.fetchImpl ?? fetch;

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.10.14';
+export const VERSION = '0.10.15';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.10.14",
+  "version": "0.10.15",
   "type": "module",
   "description": "The local host for non.bot ▶ Run — opens a terminal on your machine and starts the work in your linked repo.",
   "license": "UNLICENSED",