feat(tui): add /update command, surface auto-update in doctor, alias pythinker update

The welcome banner advertised /update but no such command existed. /update
(alias /upgrade) refreshes the CDN cache and starts the existing detached
background installer, ignoring the rollout hold and the auto_install
preference since the user explicitly asked; sources that cannot self-update
get a copyable command instead. pythinker doctor now reports the auto-update
state (on / off via tui.toml [upgrade].auto_install / disabled by
PYTHINKER_CODE_NO_AUTO_UPDATE), and 'pythinker update' aliases the existing
upgrade subcommand.

Author: elkaix

.changeset/tui-update-command.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": minor
+---
+
+Add the `/update` slash command (alias `/upgrade`) the welcome banner has been advertising: it checks the CDN for a newer version and installs it in the background, falling back to a copyable command for installs that cannot self-update (e.g. Homebrew). `pythinker doctor` now reports whether auto-update is on, off via `tui.toml [upgrade].auto_install`, or disabled by `PYTHINKER_CODE_NO_AUTO_UPDATE`.

apps/pythinker-code/src/cli/commands.ts

@@ -110,6 +110,7 @@ export function createProgram(
   registerMigrateCommand(program, onMigrate);
   program
     .command('upgrade')
+    .alias('update')
     .description('Upgrade Pythinker Code to the latest version.')
     .action(async () => {
       await onUpgrade();

apps/pythinker-code/src/cli/sub/doctor.ts

@@ -15,6 +15,7 @@ import { z } from 'zod';
 
 import { getTuiConfigPath, parseTuiConfig } from '#/tui/config';
 import { readUpdateCache } from '#/cli/update/cache';
+import { isAutoUpdateDisabledByEnv, shouldAutoInstallUpdates } from '#/cli/update/preflight';
 import { detectInstallSource } from '#/cli/update/source';
 import { getHostPackageRoot, getVersion } from '#/cli/version';
 
@@ -48,6 +49,7 @@ export interface DoctorRuntimeInfo {
   readonly update?: {
     readonly latest: string | null;
     readonly checkedAt: string | null;
+    readonly autoUpdate?: 'on' | 'off' | 'env-disabled';
   };
 }
 
@@ -164,11 +166,12 @@ function resolveDeps(deps: Partial<DoctorDeps> | DoctorDeps | undefined): Resolv
     runtimeInfo:
       deps?.runtimeInfo ??
       (async () => {
-        const [installSource, installations, ripgrep, update] = await Promise.all([
+        const [installSource, installations, ripgrep, update, autoInstall] = await Promise.all([
           detectInstallSource(),
           findPythinkerExecutables(),
           findExistingRg(resolvePythinkerHome()),
           readUpdateCache(),
+          shouldAutoInstallUpdates(),
         ]);
         return {
           version: getVersion(),
@@ -177,7 +180,11 @@ function resolveDeps(deps: Partial<DoctorDeps> | DoctorDeps | undefined): Resolv
           executable: process.execPath,
           installations,
           ripgrep,
-          update,
+          update: {
+            latest: update.latest,
+            checkedAt: update.checkedAt,
+            autoUpdate: isAutoUpdateDisabledByEnv() ? 'env-disabled' : autoInstall ? 'on' : 'off',
+          },
         };
       }),
   };
@@ -361,6 +368,13 @@ function formatRuntimeInfo(info: DoctorRuntimeInfo | undefined): string[] {
       ? []
       : [
           '  Update channel: CDN staged rollout',
+          ...(info.update.autoUpdate === undefined
+            ? []
+            : [
+                info.update.autoUpdate === 'env-disabled'
+                  ? '  Auto-update: disabled by PYTHINKER_CODE_NO_AUTO_UPDATE'
+                  : `  Auto-update: ${info.update.autoUpdate} (tui.toml [upgrade].auto_install)`,
+              ]),
           ...(info.update.latest === null
             ? ['  Latest cached version: unavailable']
             : [

apps/pythinker-code/src/cli/update/preflight.ts

@@ -19,6 +19,7 @@ import {
   type InstallPromptOptions,
 } from './prompt';
 import { refreshUpdateCache } from './refresh';
+import { selectUpdateTarget } from './select';
 import {
   appendRolloutDecisionLog,
   decidePassiveUpdateTarget,
@@ -34,6 +35,7 @@ import {
   type InstallSource,
   type UpdateDecision,
   type UpdateInstallState,
+  type UpdateCache,
   type UpdateManifest,
   type UpdatePreflightResult,
   type UpdateTarget,
@@ -432,13 +434,13 @@ async function showPendingBackgroundInstallNotice(
  * prompt. Migrated from pythinker-cli, where the variable gated all auto-update
  * behavior. Accepts the usual truthy values (`1`/`true`/`yes`/`on`).
  */
-function isAutoUpdateDisabledByEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+export function isAutoUpdateDisabledByEnv(env: NodeJS.ProcessEnv = process.env): boolean {
   const truthy = (value?: string): boolean =>
     ['1', 'true', 'yes', 'on'].includes((value ?? '').trim().toLowerCase());
   return truthy(env['PYTHINKER_CODE_NO_AUTO_UPDATE']) || truthy(env['PYTHINKER_CLI_NO_AUTO_UPDATE']);
 }
 
-async function shouldAutoInstallUpdates(): Promise<boolean> {
+export async function shouldAutoInstallUpdates(): Promise<boolean> {
   try {
     const config = await loadTuiConfig();
     return config.upgrade.autoInstall;
@@ -710,6 +712,77 @@ async function tryStartAutomaticBackgroundInstall(
   }
 }
 
+export type ManualUpdateResult =
+  | { readonly status: 'up-to-date' }
+  | { readonly status: 'check-failed'; readonly message: string }
+  | { readonly status: 'started'; readonly version: string }
+  | { readonly status: 'in-progress'; readonly version: string }
+  | { readonly status: 'manual'; readonly version: string; readonly command: string };
+
+/**
+ * Explicit user-requested update (TUI `/update`). Unlike the passive
+ * preflight it ignores the rollout delay and the `auto_install` preference —
+ * the user asked, so we install — but still reuses the background installer,
+ * its lock, and its failure bookkeeping. The env kill-switch is also ignored:
+ * it gates automatic behavior, not explicit requests (matching `pythinker upgrade`).
+ */
+export async function startManualUpdate(
+  currentVersion: string,
+  logger: UpdateLogger = log,
+): Promise<ManualUpdateResult> {
+  let cache: UpdateCache;
+  try {
+    cache = await refreshUpdateCache();
+  } catch (error) {
+    return { status: 'check-failed', message: formatErrorMessage(error) };
+  }
+  const target = selectUpdateTarget(currentVersion, cache.latest);
+  if (target === null) return { status: 'up-to-date' };
+
+  const platform = process.platform;
+  const source = await detectInstallSource().catch(() => 'unsupported' as const);
+  if (!canAutoInstall(source, platform)) {
+    return {
+      status: 'manual',
+      version: target.version,
+      command: installCommandFor(source, target.version, platform),
+    };
+  }
+
+  const installState = await readUpdateInstallState().catch(() => emptyUpdateInstallState());
+  if (hasFreshActiveInstall(installState)) {
+    return {
+      status: 'in-progress',
+      version: installState.active?.version ?? target.version,
+    };
+  }
+  // Repeated background failures fall back to the copyable command instead of
+  // claiming "started" for an install startBackgroundInstall would refuse.
+  if (failureAttemptsFor(installState, target) >= AUTO_INSTALL_FAILURE_PROMPT_THRESHOLD) {
+    return {
+      status: 'manual',
+      version: target.version,
+      command: installCommandFor(source, target.version, platform),
+    };
+  }
+
+  try {
+    await startBackgroundInstall(
+      installState,
+      currentVersion,
+      target,
+      source,
+      platform,
+      undefined,
+      logger,
+      rolloutTelemetryFor(resolveUpdateDeviceId(), target.version, cache.manifest, true),
+    );
+    return { status: 'started', version: target.version };
+  } catch (error) {
+    return { status: 'check-failed', message: formatErrorMessage(error) };
+  }
+}
+
 export function decideUpdateAction(
   target: UpdateTarget | null,
   isInteractive: boolean,

apps/pythinker-code/src/tui/commands/dispatch.ts

@@ -50,6 +50,7 @@ import { handleMemoryCommand } from './memory';
 import {
   handleDoctorCommand,
   handleFeedbackCommand,
+  handleUpdateCommand,
   handleHooksCommand,
   showMcpServers,
   showContextReport,
@@ -114,6 +115,7 @@ export { handleFastCommand } from './fast';
 export {
   handleDoctorCommand,
   handleFeedbackCommand,
+  handleUpdateCommand,
   handleHooksCommand,
   showMcpServers,
   showContextReport,
@@ -306,6 +308,9 @@ async function handleBuiltInSlashCommand(
     case 'doctor':
       await handleDoctorCommand(host, args);
       return;
+    case 'update':
+      await handleUpdateCommand(host, args);
+      return;
     case 'debug':
       await handleDebugCommand(host, args);
       return;

apps/pythinker-code/src/tui/commands/info.ts

@@ -9,6 +9,7 @@ import type {
 } from '@pythoughts/pythinker-code-sdk';
 
 import { handleDoctor } from '#/cli/sub/doctor';
+import { startManualUpdate } from '#/cli/update/preflight';
 import { PYTHINKER_CODE_CHANGELOG_URL } from '#/constant/app';
 import { openUrl } from '#/utils/open-url';
 import { buildMcpStatusReportLines } from '../components/messages/mcp-status-panel';
@@ -294,6 +295,42 @@ export async function handleHooksCommand(
   );
 }
 
+export async function handleUpdateCommand(
+  host: SlashCommandHost,
+  args: string,
+): Promise<void> {
+  if (args.trim().length > 0) {
+    host.showError('Usage: /update');
+    return;
+  }
+  host.showStatus('Checking for updates…');
+  const currentVersion = host.state.appState.version;
+  const result = await startManualUpdate(currentVersion);
+  switch (result.status) {
+    case 'up-to-date':
+      host.showNotice('Pythinker Code is up to date', `v${currentVersion}`);
+      return;
+    case 'started':
+      host.showNotice(
+        `Updating to v${result.version}`,
+        'Installing in the background — restart the CLI when it completes.',
+      );
+      return;
+    case 'in-progress':
+      host.showNotice(
+        `Update to v${result.version} already in progress`,
+        'Restart the CLI once it completes.',
+      );
+      return;
+    case 'manual':
+      host.showNotice(`Update available — v${result.version}`, `Run: ${result.command}`);
+      return;
+    case 'check-failed':
+      host.showError(`Update check failed: ${result.message}`);
+      return;
+  }
+}
+
 export async function handleDoctorCommand(
   host: SlashCommandHost,
   args: string,

apps/pythinker-code/src/tui/commands/registry.ts

@@ -249,6 +249,13 @@ export const BUILTIN_SLASH_COMMANDS = [
     priority: 60,
     availability: 'always',
   },
+  {
+    name: 'update',
+    aliases: ['upgrade'],
+    description: 'Update Pythinker Code to the latest version',
+    priority: 60,
+    availability: 'always',
+  },
   {
     name: 'debug',
     aliases: [],

apps/pythinker-code/test/cli/doctor.test.ts

@@ -47,6 +47,7 @@ function makeDeps(): {
         update: {
           latest: '1.3.0',
           checkedAt: '2026-07-29T12:00:00.000Z',
+          autoUpdate: 'on' as const,
         },
       }),
       exit: (code) => {
@@ -126,6 +127,7 @@ describe('pythinker doctor', () => {
         '  Package root: /opt/pythinker',
         '  Executable: /usr/local/bin/node',
         '  Update channel: CDN staged rollout',
+        '  Auto-update: on (tui.toml [upgrade].auto_install)',
         '  Latest cached version: 1.3.0 (checked 2026-07-29T12:00:00.000Z)',
       ].join('\n'),
     );