@@ -234,6 +234,7 @@ tsbb init                    Create .env, migrate and seed a new board
 tsbb serve [--port N]        Run the board (it migrates at boot)
 tsbb worker                  Run the mail worker separately
 tsbb status                  What this board is and how big it is
+tsbb update [--check]        Install the newest release, or just report it
 tsbb admin <email>           Make somebody an administrator
 tsbb invite <email>          Email somebody a sign-in link
 tsbb plugin ls|enable|disable
@@ -263,9 +264,37 @@ one with a fresh session secret and whatever you already had set.
 | `RESEND_API_KEY` / `SMTP_URL` | — | For the matching transport |
 | `TSBB_PLUGIN_DIR` | `./plugins` | Extra plugins, on top of the bundled ones |
 | `TSBB_WORKER` | in-process | Set to `external` to run the worker yourself |
+| `TSBB_UPDATES` | on | Set to `off` and the board never checks for a release |
+| `TSBB_RESTART` | `respawn` | `exit` under a supervisor that restarts the process itself |
+| `TSBB_UPDATE_REPO` | `profullstack/tsbb` | A fork that publishes its own releases |
 
 The worker runs inside the server by default, so email works from one command.
 
+## Updates
+
+A board keeps itself current. A minute after it starts, and every five minutes
+after that, it asks GitHub for the newest release; when there is one it fetches
+the tag, runs `pnpm install`, and restarts itself. The whole thing is the three
+commands you would otherwise type, and a self-hosted board that nobody types
+them for is how every forum ends up three years behind.
+
+It is on by default and an administrator can turn it off under **Board
+settings → Updates**. The overview page always shows what is running, what is
+out, and a **Check now** button; with automatic updates off it also offers
+**Update now**, and `tsbb update` does the same from a shell.
+
+Two things it will not do. It never touches a checkout with local changes —
+that is somebody's work, and it stops and says so. And it never updates a
+container: the Docker image has no `.git` to move, so a board on Railway, Fly
+or a plain `docker run` sees the notice and is updated by redeploying the image,
+which is how those platforms expect it anyway.
+
+On restart the board spawns a fresh copy of itself with the same command line
+and exits, so `pnpm start` in a terminal or under nohup carries on with the new
+code. Under systemd, pm2 or anything else that restarts a process when it
+exits, set `TSBB_RESTART=exit` and `Restart=always`, so the supervisor's copy
+is the only one.
+
 ## Layout
 
 ```
 
@@ -13,6 +13,7 @@ Running a board (these read the database beside you):
   tsbb worker                  Run the mail worker on its own
   tsbb migrate                 Apply pending migrations and stop
   tsbb status                  What this board is and how big it is
+  tsbb update [--check]        Install the newest release (or just say if there is one)
 
   tsbb admin <email>           Make somebody an administrator
   tsbb unadmin <email>         Take it away (never from the last one)
@@ -140,6 +141,12 @@ try {
       await status();
       process.exit(0);
     }
+    case 'update':
+    case 'upgrade': {
+      const { update } = await import('../src/commands.ts');
+      await update({ checkOnly: argv.includes('--check') });
+      process.exit(process.exitCode ?? 0);
+    }
     case 'admin': {
       const { promote } = await import('../src/commands.ts');
       if (!argv[1]) throw new Error('Which email address? Run: tsbb admin you@example.com');
 
@@ -176,6 +176,33 @@ export async function setPluginEnabled(slug: string, enabled: boolean): Promise<
   console.log(`${slug} is now ${enabled ? 'enabled' : 'disabled'}. Restart the board to apply it.`);
 }
 
+/**
+ * The same update the running board performs on its own, done by hand.
+ *
+ * Useful when automatic updates are off, when the board is not running, or
+ * when an operator wants to watch it happen. This changes what is on disk and
+ * says so; the board picks the new code up when it is next started.
+ */
+export async function update(options: { checkOnly?: boolean } = {}): Promise<void> {
+  const { applyUpdate, checkForUpdate } = await import('@tsbb/core');
+  const check = await checkForUpdate();
+  console.log(`  running   ${check.current}`);
+  console.log(`  latest    ${check.latest?.version ?? 'no release found'}`);
+  if (!check.available || !check.latest) {
+    console.log('  up to date');
+    return;
+  }
+  console.log(`  release   ${check.latest.url}`);
+  if (options.checkOnly) return;
+  if (check.kind !== 'git') {
+    console.error('  this board was not installed from a git checkout; update it by redeploying');
+    process.exitCode = 1;
+    return;
+  }
+  await applyUpdate(check.latest.version, { log: (line) => console.log(`  ${line}`) });
+  console.log(`  restart the board to run ${check.latest.version}`);
+}
+
 export async function status(): Promise<void> {
   const settings = await loadSettings();
   const counts = await one<{ users: number; topics: number; posts: number; pending: number }>(
 
@@ -6,6 +6,7 @@ import { loadSettings, pruneExpired } from '@tsbb/core';
 import { loadPlugins } from '@tsbb/plugin-host';
 import { startWorker } from '../../worker/src/index.ts';
 import { createApp } from './app.ts';
+import { registerServer, startUpdater } from './updates.ts';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = resolve(HERE, '../../..');
@@ -55,6 +56,12 @@ export async function boot(options: { port?: number; listen?: boolean } = {}) {
   const server = serve({ fetch: app.fetch, port }, (info) => {
     console.log(`[tsbb] listening on http://localhost:${info.port}  (base URL ${baseUrl})`);
   });
+
+  // The board checks for a new release once it is up, and installs it unless
+  // an administrator has said not to. See updates.ts for what "installs" means
+  // for a checkout versus a container.
+  registerServer(server as unknown as Parameters<typeof registerServer>[0]);
+  startUpdater();
   return { app, registry, baseUrl, server };
 }
 
 
@@ -23,6 +23,7 @@ import {
   toBool,
   updateFeedSource,
   updateForum,
+  updateState,
   userByUsername,
 } from '@tsbb/core';
 import { escapeHtml } from '@tsbb/markup';
@@ -41,6 +42,7 @@ import {
   TimeAgo,
 } from '@tsbb/ui';
 import { render, slot, type AppEnv, type Services } from '../context.ts';
+import { runUpdateCycle, updatesEnabled } from '../updates.ts';
 
 const NAV = [
   { href: '/admin', label: 'Overview' },
@@ -129,12 +131,20 @@ export function adminRoutes(services: Services) {
       'SELECT status, COUNT(*) AS n FROM email_queue GROUP BY status',
     );
     const registry = services.registry;
+    const updates = await updateState();
+    const updateNotice = c.req.query('updates');
 
     return page(
       c,
       'Overview',
       html`
         <div class="page-head"><h1 class="page-title">Overview</h1></div>
+        ${updateNotice === 'restarting'
+          ? Alert('The new version is installed and the board is restarting. Give it a few seconds, then reload.', {
+              variant: 'warning',
+              title: 'Updating',
+            })
+          : ''}
         ${Number(stats?.reports ?? 0) > 0
           ? Alert(html`<a href="/admin/moderation">${stats?.reports} reports are waiting.</a>`, {
               variant: 'warning',
@@ -148,6 +158,7 @@ export function adminRoutes(services: Services) {
               <div class="profile-stat"><strong>${stats?.topics ?? 0}</strong><span>topics</span></div>
               <div class="profile-stat"><strong>${stats?.posts ?? 0}</strong><span>posts</span></div>
             </div>`)}`)}
+          ${updatesCard(updates)}
           ${Card(html`${CardHeader('Mail queue', { description: 'The worker drains this every 15 seconds.' })}
             ${CardContent(
               mail.length
@@ -171,6 +182,23 @@ export function adminRoutes(services: Services) {
     );
   });
 
+  // --- Updates ------------------------------------------------------------
+  // "Check now" only asks; "Update now" installs and restarts. Both come back
+  // to the overview, which reads what the cycle recorded in settings, so a
+  // failure is shown where the button was rather than lost in a log.
+
+  app.post('/admin/updates/check', async (c) => {
+    if (!updatesEnabled()) return c.redirect('/admin', 303);
+    await runUpdateCycle({ apply: false }).catch(() => {});
+    return c.redirect('/admin', 303);
+  });
+
+  app.post('/admin/updates/apply', async (c) => {
+    if (!updatesEnabled()) return c.redirect('/admin', 303);
+    const outcome = await runUpdateCycle({ apply: true }).catch(() => 'failed');
+    return c.redirect(outcome.startsWith('updated') ? '/admin?updates=restarting' : '/admin', 303);
+  });
+
   // --- Board settings -----------------------------------------------------
 
   const SETTING_GROUPS: { title: string; keys: string[] }[] = [
@@ -195,6 +223,7 @@ export function adminRoutes(services: Services) {
       title: 'Feeds and search',
       keys: ['feeds.enabled', 'feeds.itemLimit', 'feeds.importEnabled', 'search.enabled', 'search.minLength'],
     },
+    { title: 'Updates', keys: ['updates.auto'] },
   ];
 
   const HELP: Record<string, string> = {
@@ -215,6 +244,8 @@ export function adminRoutes(services: Services) {
     'posts.editWindowMinutes': 'How long an author may edit their own post. 0 means forever.',
     'feeds.importEnabled':
       'Whether the worker fetches the RSS and Atom feeds that fill forums. Which feeds fill which forum is set on each forum under Forums.',
+    'updates.auto':
+      'When a new release is published the board fetches it, installs it and restarts itself, within five minutes. Off means the overview still says a new version exists, and you install it. A board running from a container is never updated this way: redeploy the image.',
   };
 
   app.get('/admin/settings', async (c) => {
@@ -909,6 +940,60 @@ function memberPostingField(current: string) {
   </div>`;
 }
 
+/**
+ * The overview's Updates card: what is running, what is out, and the buttons.
+ *
+ * It reads only what the last cycle recorded, never the network, so the
+ * overview stays fast and the same whichever process rendered it.
+ */
+function updatesCard(state: Awaited<ReturnType<typeof updateState>>) {
+  const enabled = updatesEnabled();
+  const actions = enabled
+    ? html`<div class="row">
+        <form method="post" action="/admin/updates/check">
+          ${Button('Check now', { type: 'submit', variant: 'outline', size: 'sm' })}
+        </form>
+        ${state.available && state.kind === 'git'
+          ? html`<form method="post" action="/admin/updates/apply">
+              ${Button(`Update to ${state.latestVersion}`, { type: 'submit', size: 'sm' })}
+            </form>`
+          : ''}
+      </div>`
+    : '';
+
+  return Card(html`${CardHeader('Updates', {
+      description: html`Running <strong>${state.current}</strong>. Automatic updates are
+        <a href="/admin/settings">${state.auto ? 'on' : 'off'}</a>.`,
+      actions,
+    })}
+    ${CardContent(html`
+      ${!enabled
+        ? html`<p class="small muted">Update checks are switched off in the environment (TSBB_UPDATES).</p>`
+        : state.checkedAt === null
+          ? html`<p class="small muted">Not checked yet. The board checks a minute after it starts, then every five minutes.</p>`
+          : state.available
+            ? Alert(
+                html`<a href="${state.latestUrl ?? '#'}">Version ${state.latestVersion}</a> is available.
+                  ${state.kind === 'git'
+                    ? state.auto
+                      ? 'It will be installed on the next check, or now with the button above.'
+                      : 'Install it with the button above, or run tsbb update on the server.'
+                    : 'This board runs from an image, so redeploy it to get the new version.'}`,
+                { variant: 'warning', title: 'A new version is out' },
+              )
+            : html`<p class="small muted">Up to date. Last checked ${TimeAgo(state.checkedAt)}.</p>`}
+      ${state.checkError
+        ? html`<div style="margin-top:.75rem">${Alert(state.checkError, { variant: 'destructive', title: 'The last check failed' })}</div>`
+        : ''}
+      ${state.applyError
+        ? html`<div style="margin-top:.75rem">${Alert(state.applyError, { variant: 'destructive', title: 'The last update failed' })}</div>`
+        : ''}
+      ${state.appliedVersion && state.appliedAt
+        ? html`<p class="small muted" style="margin-top:.75rem">Last updated to ${state.appliedVersion} ${TimeAgo(state.appliedAt)}.</p>`
+        : ''}
+    `)}`);
+}
+
 /** A board setting rendered from the type of its default value. */
 function settingField(key: string, value: unknown, help?: string) {
   const label = key.split('.').pop()?.replace(/([A-Z])/g, ' $1').replace(/^./, (m) => m.toUpperCase()) ?? key;
 
@@ -0,0 +1,111 @@
+import { spawn } from 'node:child_process';
+import type { Server } from 'node:http';
+import { applyUpdate, checkForUpdate, installKind, loadSettings } from '@tsbb/core';
+
+/*
+ * The board keeps itself current.
+ *
+ * A minute after boot, and every five minutes after that, it asks GitHub for
+ * the newest release. When there is one and the board runs from a git
+ * checkout with `updates.auto` left on, it fetches the tag, installs, and
+ * restarts itself. A container gets the check but not the apply — there is no
+ * checkout inside it to move — so the admin panel shows the new version and
+ * the operator redeploys.
+ *
+ * TSBB_UPDATES=off stops the check as well as the apply, for a board whose
+ * operator would rather it never phoned anywhere.
+ */
+
+const FIRST_CHECK_MS = 60_000;
+const INTERVAL_MS = 5 * 60_000;
+
+type Closable = Pick<Server, 'close' | 'closeAllConnections'>;
+
+let listening: Closable | null = null;
+let restarting = false;
+
+export function updatesEnabled(): boolean {
+  return !['off', '0', 'false'].includes(String(process.env.TSBB_UPDATES ?? '').toLowerCase());
+}
+
+/** Remember the listener so a restart can stop taking requests before it exits. */
+export function registerServer(server: Closable): void {
+  listening = server;
+}
+
+/**
+ * Hand the port to a fresh copy of this process and leave.
+ *
+ * The replacement is spawned detached with the same command line and
+ * environment, so `pnpm start` in a terminal, nohup, tmux and the like all
+ * carry on with the new code. Under a supervisor that restarts on exit
+ * (systemd with Restart=always, pm2, Docker) the exit alone is enough, and
+ * TSBB_RESTART=exit skips the spawn so the supervisor's copy is the only one.
+ */
+export function restartProcess(reason: string): void {
+  if (restarting) return;
+  restarting = true;
+  console.log(`[tsbb] restarting: ${reason}`);
+
+  const finish = () => {
+    if (String(process.env.TSBB_RESTART ?? 'respawn').toLowerCase() !== 'exit') {
+      const child = spawn(process.execPath, process.argv.slice(1), {
+        cwd: process.cwd(),
+        env: process.env,
+        detached: true,
+        stdio: 'inherit',
+      });
+      child.unref();
+    }
+    process.exit(0);
+  };
+
+  if (!listening) {
+    finish();
+    return;
+  }
+  // Stop accepting, let in-flight requests finish, then cut what is left.
+  const server = listening;
+  server.close(() => finish());
+  setTimeout(() => {
+    server.closeAllConnections?.();
+    finish();
+  }, 5_000).unref();
+}
+
+/**
+ * One check, and the apply if it is due. Returns what it did, for the log and
+ * for the admin "Check now" button, which runs exactly this.
+ */
+export async function runUpdateCycle(options: { apply?: boolean } = {}): Promise<string> {
+  const check = await checkForUpdate();
+  if (!check.available || !check.latest) return `up to date at ${check.current}`;
+
+  const settings = await loadSettings();
+  const auto = options.apply ?? settings['updates.auto'] !== false;
+  if (!auto) return `${check.latest.version} is available; automatic updates are off`;
+  if (installKind() !== 'git') return `${check.latest.version} is available; redeploy to get it`;
+
+  await applyUpdate(check.latest.version, { log: (line) => console.log(`[tsbb] update: ${line}`) });
+  restartProcess(`updated to ${check.latest.version}`);
+  return `updated to ${check.latest.version}, restarting`;
+}
+
+export function startUpdater(): void {
+  if (!updatesEnabled()) {
+    console.log('[tsbb] updates: off (TSBB_UPDATES)');
+    return;
+  }
+  const tick = async () => {
+    try {
+      const outcome = await runUpdateCycle();
+      console.log(`[tsbb] updates: ${outcome}`);
+    } catch (error) {
+      console.warn(`[tsbb] updates: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  setTimeout(() => {
+    void tick();
+    setInterval(() => void tick(), INTERVAL_MS).unref();
+  }, FIRST_CHECK_MS).unref();
+}