fraim-framework 2.0.200 → 2.0.201

package/dist/src/ai-hub/desktop-main.js

@@ -11,6 +11,9 @@ const server_1 = require("./server");
 const cert_store_1 = require("./cert-store");
 const office_sideload_1 = require("./office-sideload");
 const remote_hub_gateway_1 = require("./remote-hub-gateway");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const version_utils_1 = require("../cli/utils/version-utils");
+const hub_runtime_file_1 = require("./hub-runtime-file");
 // ---------------------------------------------------------------------------
 // State
 // ---------------------------------------------------------------------------
@@ -176,6 +179,19 @@ function buildTrayMenu(hubUrl) {
                 }
             },
         },
+        {
+            // #755: surface the running build version so staleness is diagnosable at a glance.
+            label: 'About FRAIM Hub',
+            click: () => {
+                void electron_1.dialog.showMessageBox({
+                    type: 'info',
+                    title: 'About FRAIM Hub',
+                    message: 'FRAIM Hub',
+                    detail: `Version ${(0, version_utils_1.getFraimVersion)()}\nIdentity: ~/.fraim/config.json\nLocal server: ${hubUrl}`,
+                    buttons: ['OK'],
+                });
+            },
+        },
         { type: 'separator' },
         {
             label: 'Word Add-in',
@@ -354,6 +370,19 @@ async function launchDesktopShell(options) {
         },
     });
     await server.start(httpPort);
+    // #755: record the live instance so `fraim hub` can detect a stale build and
+    // replace it instead of re-focusing an outdated process.
+    try {
+        (0, hub_runtime_file_1.writeHubRuntimeFile)((0, project_fraim_paths_1.getUserFraimDirPath)(), {
+            pid: process.pid,
+            port: httpPort,
+            version: (0, version_utils_1.getFraimVersion)(),
+            startedAt: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        console.warn('[fraim] could not write hub-runtime.json:', err);
+    }
     ensureWordSideload(options.projectPath, httpPort);
     const hubUrl = `http://127.0.0.1:${httpPort}/ai-hub/`;
     createTray(hubUrl);
@@ -394,6 +423,12 @@ async function bootstrap() {
     });
     electron_1.app.on('before-quit', () => {
         isQuitting = true;
+        // #755: clear the runtime file so a later `fraim hub` doesn't treat a
+        // cleanly-exited instance as live.
+        try {
+            (0, hub_runtime_file_1.removeHubRuntimeFile)((0, project_fraim_paths_1.getUserFraimDirPath)());
+        }
+        catch { /* best-effort */ }
         void stopServerOnce();
     });
     // Keep app alive when all windows are closed — server must keep serving

package/dist/src/ai-hub/hub-latest-version.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLatestPublishedVersion = getLatestPublishedVersion;
+exports.__resetLatestVersionCache = __resetLatestVersionCache;
+const https_1 = __importDefault(require("https"));
+// Issue #755: best-effort "latest published fraim version" for the Hub's
+// update-available nudge. Cached in-process (1h TTL) and never throws — returns
+// null when offline or the registry is unreachable, so the nudge simply hides.
+const TTL_MS = 60 * 60 * 1000;
+const REGISTRY_URL = 'https://registry.npmjs.org/fraim/latest';
+let cache = { value: null, at: 0 };
+async function getLatestPublishedVersion() {
+    const now = Date.now();
+    if (cache.at !== 0 && now - cache.at < TTL_MS)
+        return cache.value;
+    const value = await fetchNpmLatest();
+    // Only cache successful lookups; a failed fetch retries next call rather than
+    // caching a null for an hour.
+    if (value !== null)
+        cache = { value, at: now };
+    return value ?? cache.value;
+}
+/** Test-only: reset the module cache. */
+function __resetLatestVersionCache() {
+    cache = { value: null, at: 0 };
+}
+function fetchNpmLatest() {
+    return new Promise((resolve) => {
+        const req = https_1.default.get(REGISTRY_URL, { timeout: 4000 }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                return resolve(null);
+            }
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try {
+                    const version = JSON.parse(body).version;
+                    resolve(typeof version === 'string' ? version : null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}

package/dist/src/ai-hub/hub-launch-decision.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideHubLaunch = decideHubLaunch;
+const semver = __importStar(require("semver"));
+function decideHubLaunch(input) {
+    const { running, pidAlive, cliVersion, restart, noRestart } = input;
+    if (!running || !pidAlive) {
+        return { action: 'launch-fresh', reason: 'no live Hub instance is running' };
+    }
+    if (noRestart) {
+        return { action: 'focus-existing', reason: '--no-restart: keeping the running instance' };
+    }
+    if (restart) {
+        return { action: 'replace', reason: '--restart: replacing the running instance' };
+    }
+    // Only treat as stale when BOTH versions are valid semver and the running one is
+    // strictly older. On any uncertainty (unknown/unparseable version) do not kill —
+    // conservative default is to focus the existing instance.
+    const comparable = !!semver.valid(running.version) && !!semver.valid(cliVersion);
+    if (comparable && semver.lt(running.version, cliVersion)) {
+        return { action: 'replace', reason: `running ${running.version} is older than ${cliVersion}; replacing with the newer build` };
+    }
+    return { action: 'focus-existing', reason: `running ${running.version} is current or not comparable to ${cliVersion}` };
+}

package/dist/src/ai-hub/hub-runtime-file.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hubRuntimeFilePath = hubRuntimeFilePath;
+exports.writeHubRuntimeFile = writeHubRuntimeFile;
+exports.readHubRuntimeFile = readHubRuntimeFile;
+exports.removeHubRuntimeFile = removeHubRuntimeFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Issue #755: the running desktop Hub writes ~/.fraim/hub-runtime.json so the
+// `fraim hub` CLI can discover a live instance (pid/port/version) before deciding
+// whether to replace a stale build. `fraimDir` is injected (never hard-coded to
+// the real ~/.fraim) so tests isolate via a temp directory.
+const RUNTIME_FILE = 'hub-runtime.json';
+function hubRuntimeFilePath(fraimDir) {
+    return path_1.default.join(fraimDir, RUNTIME_FILE);
+}
+function writeHubRuntimeFile(fraimDir, info) {
+    fs_1.default.mkdirSync(fraimDir, { recursive: true });
+    fs_1.default.writeFileSync(hubRuntimeFilePath(fraimDir), JSON.stringify(info, null, 2));
+}
+function readHubRuntimeFile(fraimDir) {
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(hubRuntimeFilePath(fraimDir), 'utf8'));
+        if (typeof parsed.pid !== 'number' || typeof parsed.port !== 'number' || typeof parsed.version !== 'string') {
+            return null;
+        }
+        return { pid: parsed.pid, port: parsed.port, version: parsed.version, startedAt: String(parsed.startedAt ?? '') };
+    }
+    catch {
+        return null;
+    }
+}
+function removeHubRuntimeFile(fraimDir) {
+    try {
+        fs_1.default.rmSync(hubRuntimeFilePath(fraimDir), { force: true });
+    }
+    catch {
+        /* no-op: absent file is fine */
+    }
+}

package/dist/src/ai-hub/server.js

@@ -63,6 +63,9 @@ const remote_hub_gateway_1 = require("./remote-hub-gateway");
 const managed_browser_1 = require("./managed-browser");
 const managed_agent_paths_1 = require("../cli/utils/managed-agent-paths");
 const user_config_1 = require("../cli/utils/user-config");
+const version_utils_1 = require("../cli/utils/version-utils");
+const hub_latest_version_1 = require("./hub-latest-version");
+const semver = __importStar(require("semver"));
 let personaHiringModule;
 let managerHiringModule;
 function loadPersonaHiringModule() {
@@ -1409,6 +1412,9 @@ class AiHubServer {
         return {
             title: 'AI Hub',
             remoteBaseUrl: (0, remote_hub_gateway_1.resolveFraimRemoteUrl)(),
+            // #755: the running build version, so the account menu can show it and flag
+            // when a newer version is available (see GET /api/ai-hub/version for `latest`).
+            version: (0, version_utils_1.getFraimVersion)(),
             project,
             // Issue #750: `apiKey` is no longer a persisted AiHubPreferences field —
             // it is overlaid on the wire response only, freshly resolved from
@@ -1932,15 +1938,7 @@ class AiHubServer {
         // passes raw invocation syntax.
         const explicit = (0, manager_turns_1.extractExplicitFraimInvocation)(instructions);
         const effectiveJobId = explicit?.jobId || coachingJobId || run.jobId;
-        // #730: the manager thread shows the coaching turn with high fidelity — the
-        // correct FRAIM command in front plus what the manager actually said — built
-        // from the shared normalizer, exactly like the start path. With no
-        // instructions (e.g. a plain coaching-template click) buildManagerMessage
-        // collapses to just the invocation. The employee additionally receives the
-        // communication-style note (and, per #732 below, a lighter same-job payload);
-        // those operational details stay out of the visible bubble.
         const userText = (explicit?.remainder || instructions || '').trim();
-        const display = (0, manager_turns_1.buildManagerMessage)(run.hostId, effectiveJobId, 'continue', instructions);
         // Issue #732: a plain continue of the SAME active real job must not re-load
         // the job via get_fraim_job on every coaching turn — the host session is
         // resumed with the job already in context, so re-fetching is wasted latency
@@ -1949,9 +1947,26 @@ class AiHubServer {
         // template or an explicit /fraim <other>). Freeform/adhoc runs keep the
         // existing buildManagerMessage path (which already emits no invocation).
         const switchesJob = effectiveJobId !== run.jobId;
-        const message = (switchesJob || run.jobId === '__freeform__')
-            ? (0, manager_turns_1.buildManagerMessage)(run.hostId, effectiveJobId, 'continue', instructions) + (0, manager_turns_1.buildCommunicationStyleNote)()
-            : (0, manager_turns_1.buildSameJobContinueMessage)(userText) + (0, manager_turns_1.buildCommunicationStyleNote)();
+        const showsInvocation = switchesJob || run.jobId === '__freeform__';
+        // Issue #756: the manager bubble must MIRROR what actually happens. A
+        // same-job coaching continue resumes the active job WITHOUT re-invoking it
+        // (the `message` below carries no `/fraim`), so the bubble shows only what
+        // the manager SAID — never a `/fraim <same-job>` line, which reads as a full
+        // re-run of the active job Y and misled managers into thinking coaching
+        // restarts the workflow. Only a real job SWITCH actually issues an
+        // invocation, so only then does the bubble lead with the command. This still
+        // upholds the #730 guarantee: the manager's coaching text is never dropped,
+        // and when a command IS issued it appears in front of that text.
+        // The invocation form (`/fraim <job>` + words) is built once and reused for
+        // both the bubble and the agent payload when a command is actually issued.
+        const invocationForm = showsInvocation
+            ? (0, manager_turns_1.buildManagerMessage)(run.hostId, effectiveJobId, 'continue', instructions)
+            : null;
+        // Bubble: the command form for a real switch, else the manager's own words.
+        const display = invocationForm ?? userText;
+        // Agent payload: the same command form for a switch, else a lightweight
+        // same-job continue; the communication-style note is agent-only.
+        const message = (invocationForm ?? (0, manager_turns_1.buildSameJobContinueMessage)(userText)) + (0, manager_turns_1.buildCommunicationStyleNote)();
         return { message, display };
     }
     async computePersonas(apiKey) {
@@ -2370,6 +2385,15 @@ class AiHubServer {
             this.preferencesStore.save({ ...prefs, personaKey: personaKey ?? null });
             return res.json({ ok: true });
         });
+        // #755: running build version + best-effort latest published version, so the
+        // account menu can show the version and flag when an update is available. The
+        // `fraim hub` CLI also queries this to confirm a running instance's version.
+        this.app.get('/api/ai-hub/version', async (_req, res) => {
+            const version = (0, version_utils_1.getFraimVersion)();
+            const latest = await (0, hub_latest_version_1.getLatestPublishedVersion)();
+            const updateAvailable = !!(latest && semver.valid(version) && semver.valid(latest) && semver.gt(latest, version));
+            return res.json({ version, latest, updateAvailable });
+        });
         this.app.post('/api/ai-hub/project-path/pick', async (_req, res) => {
             try {
                 const projectPath = await this.folderPicker();

package/dist/src/cli/commands/hub.js

@@ -45,6 +45,14 @@ const git_utils_1 = require("../../core/utils/git-utils");
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+const http_1 = __importDefault(require("http"));
+// #755: light, server-free modules — safe to import eagerly in the packed client
+// (unlike ai-hub/server, which is lazy-required per #422).
+const hub_launch_decision_1 = require("../../ai-hub/hub-launch-decision");
+const hub_runtime_file_1 = require("../../ai-hub/hub-runtime-file");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const version_utils_1 = require("../utils/version-utils");
 function resolveElectronBinary() {
     try {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -97,18 +105,116 @@ function openBrowser(url) {
     const child = (0, child_process_1.spawn)('xdg-open', [url], { detached: true, stdio: 'ignore' });
     child.unref();
 }
+// #755: version-aware kill-and-replace. Electron's single-instance lock otherwise
+// re-focuses a stale running build instead of launching a newly-released one.
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // EPERM => the process exists but we can't signal it (still "alive").
+        return !!(e && e.code === 'EPERM');
+    }
+}
+function killPid(pid) {
+    try {
+        if (process.platform === 'win32') {
+            (0, child_process_1.execFileSync)('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+        }
+    }
+    catch {
+        /* already gone */
+    }
+}
+function isPortFree(port, timeoutMs = 500) {
+    return new Promise((resolve) => {
+        const sock = net_1.default.connect({ host: '127.0.0.1', port }, () => { sock.destroy(); resolve(false); });
+        sock.on('error', () => resolve(true));
+        sock.setTimeout(timeoutMs, () => { sock.destroy(); resolve(true); });
+    });
+}
+async function waitForPortFree(port, totalMs = 5000) {
+    const start = Date.now();
+    while (Date.now() - start < totalMs) {
+        if (await isPortFree(port))
+            return;
+        await new Promise((r) => setTimeout(r, 200));
+    }
+}
+/**
+ * Reconcile a running desktop Hub with the version about to launch. Replaces a
+ * stale/older instance (or any instance under --restart) so the new build takes
+ * over; keeps the running instance under --keep-running.
+ */
+/** Confirm the recorded port actually serves a FRAIM Hub, returning its authoritative version. */
+function fetchRunningHubVersion(port) {
+    return new Promise((resolve) => {
+        const req = http_1.default.get({ host: '127.0.0.1', port, path: '/api/ai-hub/version', timeout: 1000 }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                return resolve(null);
+            }
+            let body = '';
+            res.on('data', (c) => { body += c; });
+            res.on('end', () => { try {
+                resolve(JSON.parse(body).version ?? null);
+            }
+            catch {
+                resolve(null);
+            } });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
+async function reconcileRunningHub(flags) {
+    const running = (0, hub_runtime_file_1.readHubRuntimeFile)((0, project_fraim_paths_1.getUserFraimDirPath)());
+    // Confirm the recorded port genuinely serves a FRAIM Hub before trusting the file.
+    // This (a) prevents killing an unrelated process that reused a crashed Hub's pid,
+    // and (b) yields the authoritative running version (the file may be stale).
+    const confirmedVersion = running ? await fetchRunningHubVersion(running.port) : null;
+    const live = !!(running && confirmedVersion && isProcessAlive(running.pid));
+    const effective = live && running ? { ...running, version: confirmedVersion } : null;
+    const decision = (0, hub_launch_decision_1.decideHubLaunch)({
+        running: effective,
+        pidAlive: live,
+        cliVersion: (0, version_utils_1.getFraimVersion)(),
+        restart: flags.restart,
+        noRestart: flags.keepRunning,
+    });
+    if (decision.action === 'replace' && effective) {
+        console.log(`Replacing running Hub (v${effective.version}, pid ${effective.pid}) — ${decision.reason}`);
+        killPid(effective.pid);
+        await waitForPortFree(effective.port);
+    }
+    else if (decision.action === 'focus-existing' && effective) {
+        console.log(`A Hub (v${effective.version}) is already running — focusing it. Use --restart to replace it.`);
+    }
+}
 exports.hubCommand = new commander_1.Command('hub')
     .description('Start the AI Hub local companion for running FRAIM jobs through Codex or Claude Code')
     .option('--port <port>', 'Preferred local port for the hub', (value) => Number(value), 43091)
     .option('--project-path <path>', 'Initial project path for job discovery', process.cwd())
     .option('--no-open', 'Do not open the hub after startup')
     .option('--browser', 'Open in the default browser instead of the desktop shell')
+    .option('--restart', 'Replace any running Hub instance with this build (even at the same version)')
+    .option('--keep-running', 'Do not replace a running Hub; keep single-instance focus (default replaces only an older/stale instance)')
     .action(async (options) => {
     const { AiHubServer, findAvailablePort } = await Promise.resolve().then(() => __importStar(require('../../ai-hub/server')));
     const preferredPort = options.port || (0, git_utils_1.getPort)() + 100;
     const projectPath = path_1.default.resolve(options.projectPath || process.cwd());
     if (options.open) {
-        const openedDesktop = !options.browser && openDesktopWindow(projectPath, preferredPort);
+        const wantDesktop = !options.browser;
+        // #755: before spawning Electron (whose single-instance lock would re-focus a
+        // stale build), replace an older/forced running instance so the new build wins.
+        if (wantDesktop) {
+            await reconcileRunningHub({ restart: !!options.restart, keepRunning: !!options.keepRunning });
+        }
+        const openedDesktop = wantDesktop && openDesktopWindow(projectPath, preferredPort);
         if (!openedDesktop) {
             const port = await findAvailablePort(preferredPort);
             const server = new AiHubServer({ projectPath });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.200",
+  "version": "2.0.201",
   "description": "FRAIM: AI Workforce Infrastructure — the organizational capability that turns AI agents into an accountable workforce, their operators into capable AI managers, and executives into leaders with clear optics on AI proficiency.",
   "main": "index.js",
   "bin": {

package/public/ai-hub/index.html

@@ -59,7 +59,12 @@
           <span class="am-switch" aria-hidden="true"><span class="am-switch-knob"></span></span>
         </button>
         <div class="am-div"></div>
+        <div class="am-update" id="am-update" hidden>
+          <span class="am-ico">⬆️</span>
+          <div><div class="am-label">Update available</div><div class="am-sub" id="am-update-sub"></div></div>
+        </div>
         <button class="am-foot" id="am-signout" type="button"><span class="am-ico">⏻</span><span>Sign out</span></button>
+        <div class="am-version" id="am-version" title="Running FRAIM Hub build"></div>
       </div>
     </div>
   </nav>

package/public/ai-hub/script.js

@@ -10876,6 +10876,30 @@ function tfPopulateAccountMenu() {
   if (emailEl) emailEl.textContent = id.notConnected ? 'Not connected — run `fraim setup`' : id.email;
   if (avEl) avEl.textContent = id.initials;
   if (avatarBtn) avatarBtn.textContent = id.initials;
+  tfPopulateVersionInfo(); // #755
+}
+
+// #755: show the running Hub build version and, when a newer version is published,
+// an update-available nudge. Running version is cheap (from bootstrap); the latest
+// check hits the server's cached /api/ai-hub/version (best-effort, hidden on failure).
+function tfPopulateVersionInfo() {
+  const versionEl = document.getElementById('am-version');
+  const running = (state.bootstrap && state.bootstrap.version) || '';
+  if (versionEl) versionEl.textContent = running ? `FRAIM Hub v${running}` : '';
+  const updateEl = document.getElementById('am-update');
+  const updateSub = document.getElementById('am-update-sub');
+  if (!updateEl) return;
+  fetch('/api/ai-hub/version')
+    .then((r) => (r.ok ? r.json() : null))
+    .then((info) => {
+      if (info && info.updateAvailable && info.latest) {
+        if (updateSub) updateSub.textContent = `v${info.latest} is available — quit the Hub (tray → Quit) and relaunch to update.`;
+        updateEl.hidden = false;
+      } else {
+        updateEl.hidden = true;
+      }
+    })
+    .catch(() => { /* offline / best-effort: leave the nudge hidden */ });
 }
 
 function tfRequestedConnectedSurface() {

package/public/ai-hub/styles.css

@@ -2783,6 +2783,13 @@ body.hub-shell { display: flex; flex-direction: column; height: 100vh; overflow:
 .am-div { height: 1px; background: var(--line); margin: 4px 0; }
 .am-foot { padding: 8px 16px; font-size: 13px; color: var(--muted); cursor: pointer; }
 .am-foot:hover { background: var(--bg); }
+/* #755: running-version footer + update-available nudge in the account menu */
+.am-version { padding: 6px 16px 10px; font-size: 10px; color: var(--muted); text-align: center; }
+#account-menu .am-update:not([hidden]) { display: grid; grid-template-columns: 30px 1fr; column-gap: 12px; align-items: start; }
+#account-menu .am-update { padding: 9px 16px; margin: 2px 8px 4px; background: var(--bg); border: 1px solid var(--line); border-radius: 8px; }
+#account-menu .am-update .am-ico { width: 30px; margin: 0; text-align: center; font-size: 16px; }
+.am-update .am-label { font-size: 13px; font-weight: 700; color: var(--text); }
+.am-update .am-sub { font-size: 11px; color: var(--muted); margin-top: 1px; }
 /* #700: theme toggle row + iOS-style switch */
 .am-theme { align-items: center; width: 100%; border: none; background: none; text-align: left; font: inherit; color: var(--text); }
 .am-theme .am-switch { box-sizing: border-box; margin-left: auto; align-self: center; width: 38px; height: 22px; border-radius: 999px; background: var(--soft); border: 1px solid var(--line); position: relative; flex-shrink: 0; transition: background .18s ease, border-color .18s ease; }