@maka/maka-cli 5.175.1 → 5.177.0

package/bundle/typescript/src/commands/game/sideQuest/ui.js

@@ -1,5 +1,6 @@
 import blessed from 'blessed';
 import { capitalCase } from 'change-case';
+import * as path from 'path';
 import Game from './game.js';
 import { Player, Room, } from './models/_index.js';
 import { Logger } from './utilities/logger.js';
@@ -9,7 +10,8 @@ import { attachInputHistory } from './utilities/input-history.js';
 import { TERMINAL_RESET_SEQUENCE } from './utilities/terminal-reset.js';
 import { readSave } from './utilities/persistence.js';
 import { requireCatalog, CatalogUnavailableError } from './utilities/catalog.js';
-import { authToken } from './utilities/cloud-saves.js';
+import { requireHubSeed, HubSeedUnavailableError } from './utilities/hub-seed.js';
+import { authToken, setCloudSessionId } from './utilities/cloud-saves.js';
 import { AI } from '../../../tools/ai/ai.class.js';
 import { acquireSessionLock, releaseSessionLock } from './utilities/session-lock.js';
 import { SAVE_VERSION } from './types/save-file.js';
@@ -141,6 +143,12 @@ export async function main(playerName, sceneSeed, options) {
     });
     // Initialize Logger
     const gameLog = Logger.getInstance(options.logFilePath, screen);
+    // The launcher's session id is the log directory's name; every push
+    // from this child names it (x-session-id) so a slot a browser hub
+    // holds open on the site refuses us (2026-09-12).
+    if (options.logFilePath) {
+        setCloudSessionId(path.basename(path.dirname(options.logFilePath)));
+    }
     // THE CATALOG GATE, child side (see sideQuest.sub.cmd.ts for the why).
     // The parent already refreshed and cached; this is the cheap /version
     // probe plus the insistence that SOMETHING is loadable before a Player
@@ -161,6 +169,28 @@ export async function main(playerName, sceneSeed, options) {
         }
         throw e;
     }
+    // THE HUB GATE, child side (2026-09-12): the launcher already fetched
+    // and cached; this is the cheap stamp probe plus the insistence that a
+    // hub is held. The seed the child PLAYS is the one in launch.json (the
+    // launcher's served copy) -- this only refuses a boot with no hub.
+    if (sceneSeed.hub === true) {
+        try {
+            const hub = await requireHubSeed({ token: authToken() });
+            gameLog.write(`Hub seed: ${hub.decision} -- "${hub.seed.name}" v${hub.stamp.version} (${hub.stamp.id}, ${hub.origin}).`);
+        }
+        catch (e) {
+            if (e instanceof HubSeedUnavailableError) {
+                try {
+                    screen.destroy();
+                }
+                catch { /* the terminal is what matters */ }
+                process.stderr.write(`${TERMINAL_RESET_SEQUENCE}${e.message}
+`);
+                process.exit(1);
+            }
+            throw e;
+        }
+    }
     // NOTHING prints through blessed but blessed (player report: the
     // SDK's ddp-client vomited raw "stream error ..." lines across a live
     // session while the server bounced). Once the screen owns the
@@ -223,8 +253,10 @@ export async function main(playerName, sceneSeed, options) {
             outfitArchetype(player, archetype);
             player.gender = options.gender;
         }
-        // Create the game instance
-        const game = await Game.getInstance(player, resumeSave?.hubSeed ?? sceneSeed, resumeSave);
+        // Create the game instance. A resume plays the SERVED hub seed
+        // (sceneSeed, from launch.json) with the save's overlay over it --
+        // never the copy an older save embedded (2026-09-12).
+        const game = await Game.getInstance(player, sceneSeed, resumeSave);
         const ready = await game.init(options, screen);
         // The quit seal (player ruling: autosave on quit). A clean exit --
         // the quit verb, double-ESC, the C-c binding below -- all funnel

package/bundle/typescript/src/commands/game/sideQuest/utilities/catalog.js

@@ -1,9 +1,8 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import * as http from 'http';
-import * as https from 'https';
 import { Logger } from './logger.js';
+import { siteGet as transportGet } from './site-transport.js';
 import { Item } from '../models/item.js';
 import { Category, Size, Rating } from '../types/shared/item-enum.js';
 import { isGearRow, } from './catalog-data.js';
@@ -47,9 +46,6 @@ export const ROLE_DOMAINS = {
     'Data Broker': ['Cyberdeck', 'Software', 'Commlink', 'Electronics', 'Glasses', 'FakeSIN', 'License', 'Credstick'],
     'Vendor': ['Food', 'Drink', 'Clothing', 'Boots', 'Gloves', 'Hat', 'Mask', 'Wristband'],
 };
-const DEV = process.env.MAKA_DEV === 'True';
-const HOSTNAME = DEV ? 'localhost' : 'www.maka-cli.com';
-const PORT = DEV ? Number(process.env.MAKA_DEV_PORT ?? 3000) : 443;
 const TIMEOUT_MS = 8000;
 /**
  * THE CACHE FILE, and an escape hatch that exists because I poisoned it.
@@ -179,22 +175,12 @@ export function applyLiveCatalog(items, version) {
  * persistence -> player -> catalog: a runtime import cycle, which in
  * this repo means 'Cannot access X before initialization' and a couple
  * of hundred red suites. The caller already holds the token.
+ *
+ * The socket itself lives in site-transport.ts since 2026-09-12, shared
+ * with the hub seed fetcher (hub-seed.ts) -- one host rule, one header.
  */
 async function siteGet(apiPath, token) {
-    return new Promise((resolve, reject) => {
-        const mod = DEV ? http : https;
-        const req = mod.request({
-            hostname: HOSTNAME, port: PORT, path: apiPath, method: 'GET', timeout: TIMEOUT_MS,
-            headers: token === undefined ? {} : { 'x-auth-token': token },
-        }, res => {
-            let body = '';
-            res.on('data', c => { body += c; });
-            res.on('end', () => resolve({ statusCode: res.statusCode ?? 0, body }));
-        });
-        req.on('timeout', () => req.destroy(new Error('timeout')));
-        req.on('error', reject);
-        req.end();
-    });
+    return transportGet(apiPath, token, TIMEOUT_MS);
 }
 /** Fire-and-forget refresh from the site -- call once at session start;
  *  the promise resolves when the live list (or a fallback) is settled. */

package/bundle/typescript/src/commands/game/sideQuest/utilities/cloud-saves.js

@@ -66,6 +66,7 @@ function request(method, apiPath, token, body) {
             timeout: TIMEOUT_MS,
             headers: {
                 'x-auth-token': token,
+                ...(cloudSessionId && method === 'POST' ? { 'x-session-id': cloudSessionId } : {}),
                 ...(payload !== undefined
                     ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
                     : {}),
@@ -152,6 +153,17 @@ function noteUnauthorized() {
         logger.write('Cloud sync off: 401 from maka-cli.com (token expired or logged out).');
     }
 }
+/**
+ * THIS PROCESS'S SESSION ID, sent as x-session-id on every push so the
+ * site's lease check (game-saves-v1-rest-api.ts) can tell OUR push from
+ * a stranger's: a slot leased to a browser hub refuses a push that names
+ * a different session, and a push that names none is let through for
+ * old clients' sake. Set once by the launcher (its timestamp session id).
+ */
+let cloudSessionId;
+export function setCloudSessionId(id) {
+    cloudSessionId = id;
+}
 /**
  * Mirrors a freshly-written local save to the cloud. Fire-and-forget
  * from the save beats (`void pushSave(...)`): on success the local file

package/bundle/typescript/src/commands/game/sideQuest/utilities/hub-seed.js

@@ -0,0 +1,284 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { Logger } from './logger.js';
+import { siteGet } from './site-transport.js';
+import { parseCatalogVersion, isCacheStale, isUnverifiedRefusal, } from './catalog.js';
+/**
+ * THE HUB SEED'S DELIVERY CHAIN (2026-09-12, mjmcee: "migrate the hub
+ * seed from local to the server"). The same shape as the catalog's
+ * (catalog.ts), for the same reason: a rule that lives in two places
+ * drifts, and the shipped scene2.json was the second place.
+ *
+ * maka-cli.com's GameHubSeeds collection is the ONLY source of the hub
+ * (Tacoma Purple Haze). It is fetched with the account's token and
+ * cached at ~/.meteor/.maka/side-quest-hub.json; offline or unreachable,
+ * the cache serves. THERE IS NO SHIPPED COPY: a machine with no cache and
+ * no connection has no hub, and requireHubSeed() says so before the game
+ * starts rather than inventing a district.
+ *
+ * THE SEED IS STATIC AND AUTHORED, never generated, and the hub is solo
+ * -- each runner's world is this seed plus their own overlay from the
+ * save. Every save records WHICH seed its overlay was captured against
+ * (hubSeedRef: id, version, contentHash -- refOf below) but the game
+ * always plays the LATEST served seed; applyHubOverlay (persistence.ts)
+ * is name-keyed and tolerant, and that tolerance is the drift contract.
+ *
+ * The version/staleness discipline is catalog.ts's, reused rather than
+ * copied: parseCatalogVersion (an allow-list, so an unversioned payload
+ * never poisons a cache), isCacheStale (server ahead, or same version
+ * with a different fingerprint), and the decision vocabulary. The one
+ * addition is 'no-route': the site is mid-deploy and has no hub route
+ * yet -- unlike the catalog there is no older list route to fall back
+ * to, so it refuses (with a cache, it plays from the cache).
+ */
+// A FUNCTION, NOT A CONST: read at call time so a harness that sets
+// MAKA_HUB_CACHE after this module loads is honoured (catalog.ts learned
+// this the hard way when a bench poisoned the developer's real cache).
+function cachePath() {
+    return process.env.MAKA_HUB_CACHE
+        ?? path.join(os.homedir(), '.meteor', '.maka', 'side-quest-hub.json');
+}
+export const HUB_STAMP_PATH = '/api/v1/game-hub/version';
+export const HUB_SEED_PATH = '/api/v1/game-hub/seed';
+const TIMEOUT_MS = 8000;
+let liveSource;
+let resolved;
+let diskCacheDisabled = false;
+function readCache() {
+    if (diskCacheDisabled)
+        return undefined;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachePath(), 'utf8'));
+        if (parsed?.seed && typeof parsed.seed === 'object' && Array.isArray(parsed.seed.rooms))
+            return parsed;
+    }
+    catch { /* no cache */ }
+    return undefined;
+}
+function writeCache(seed, stamp) {
+    try {
+        fs.mkdirSync(path.dirname(cachePath()), { recursive: true });
+        fs.writeFileSync(cachePath(), JSON.stringify({
+            id: stamp.id, version: stamp.version, contentHash: stamp.contentHash,
+            fetchedAt: new Date().toISOString(), seed,
+        }), 'utf8');
+    }
+    catch (err) {
+        Logger.getInstance().write(`hub seed cache write failed: ${err}`);
+    }
+}
+function hashOf(raw) {
+    return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
+}
+function idOf(raw) {
+    return typeof raw === 'string' && raw.trim() !== '' ? raw : undefined;
+}
+/** The seed with its stamp written onto it, so buildSaveFile can derive
+ *  the save's hubSeedRef from the seed it is playing (refOf). */
+function stamped(seed, stamp) {
+    return { ...seed, id: stamp.id, version: stamp.version, contentHash: stamp.contentHash };
+}
+/**
+ * RECORD WHAT ARRIVED -- from the network, or from a test. Separated
+ * from the fetch so the wiring is reachable without a socket.
+ */
+export function applyLiveHubSeed(seed, stamp) {
+    liveSource = { stamp: { ...stamp }, seed: stamped(seed, stamp), origin: 'live' };
+    resolved = undefined;
+}
+/** The whole seed from the site. Resolves when the live seed (or the
+ *  decision to serve the cache) is settled; never throws. */
+export async function refreshHubSeed(token) {
+    const logger = Logger.getInstance();
+    try {
+        const res = await siteGet(HUB_SEED_PATH, token, TIMEOUT_MS);
+        if (res.statusCode !== 200)
+            throw new Error(`status ${res.statusCode}`);
+        const parsed = JSON.parse(res.body);
+        const seed = parsed?.seed;
+        if (!seed || typeof seed !== 'object' || !Array.isArray(seed.rooms) || seed.rooms.length === 0) {
+            throw new Error('empty hub seed payload');
+        }
+        const version = parseCatalogVersion(parsed.version);
+        const id = idOf(parsed.id);
+        if (version === undefined || id === undefined) {
+            // Loud, and NOT cached: a seed that cannot be compared cannot be
+            // shown to be newer than the cache, so it is served this session
+            // and fetched again next boot.
+            logger.write(`Hub seed: maka-cli.com sent "${seed.name}" with no usable stamp `
+                + `(id ${JSON.stringify(parsed.id)}, version ${JSON.stringify(parsed.version)}) -- served, not cached.`);
+            applyLiveHubSeed(seed, { id: id ?? 'unknown', version: version ?? 0, contentHash: hashOf(parsed.contentHash) });
+            return;
+        }
+        const stamp = { id, version, contentHash: hashOf(parsed.contentHash) };
+        applyLiveHubSeed(seed, stamp);
+        writeCache(seed, stamp);
+        logger.write(`Hub seed: "${seed.name}" v${version} (${id}) from maka-cli.com.`);
+    }
+    catch (err) {
+        resolved = undefined;
+        const cache = readCache();
+        logger.write(cache
+            ? `Hub seed: offline -- cache holds "${cache.seed.name}" (v${cache.version}). (${err.message})`
+            : `Hub seed: offline and no cache on this machine -- NO hub to serve. (${err.message})`);
+    }
+}
+/** The cache's own stamp, for the staleness comparison. */
+export function hubCacheStamp(readCacheFn = readCache) {
+    const cached = readCacheFn();
+    const version = parseCatalogVersion(cached?.version);
+    const id = idOf(cached?.id);
+    if (!cached || version === undefined || id === undefined)
+        return undefined;
+    return { id, version, contentHash: hashOf(cached.contentHash) };
+}
+/**
+ * WHAT `maka play` CALLS. Two gates, in order -- signed in, then not
+ * stale -- and both the probe and the download are injectable so a test
+ * can SEE that nothing was downloaded.
+ */
+export async function ensureHubSeed(input) {
+    const logger = Logger.getInstance();
+    const probe = input.probe ?? (() => siteGet(HUB_STAMP_PATH, input.token, TIMEOUT_MS));
+    const download = input.download ?? (() => refreshHubSeed(input.token));
+    const readCacheFn = input.readCacheFn ?? readCache;
+    if (input.token === undefined) {
+        const cached = hubCacheStamp(readCacheFn);
+        logger.write(cached
+            ? `Hub seed: not signed in -- serving the cached v${cached.version} (${cached.id}); no fetch.`
+            : 'Hub seed: not signed in and no cache -- NO hub to serve.');
+        return 'logged-out';
+    }
+    let stamp;
+    try {
+        stamp = await probe();
+    }
+    catch (err) {
+        logger.write(`Hub seed: could not reach maka-cli.com for a version check (${err.message}).`);
+        return 'offline';
+    }
+    if (stamp.statusCode === 404) {
+        // Unlike the catalog there is no older route to fall back to: a
+        // 404 here is a site mid-deploy (or a hub id the box never seeded).
+        // The cache, if any, plays; nothing is invented.
+        logger.write('Hub seed: maka-cli.com has no hub route yet -- serving the cache, if any.');
+        return 'no-route';
+    }
+    if (isUnverifiedRefusal(stamp.statusCode, stamp.body)) {
+        logger.write('Hub seed: maka-cli.com refused this account (403, email not verified).');
+        return 'unverified';
+    }
+    if (stamp.statusCode === 401 || stamp.statusCode === 403) {
+        logger.write(`Hub seed: maka-cli.com refused the session (${stamp.statusCode}) -- "maka login" to receive hub updates.`);
+        return 'unauthorized';
+    }
+    if (stamp.statusCode !== 200) {
+        logger.write(`Hub seed: version check returned status ${stamp.statusCode}.`);
+        return 'offline';
+    }
+    let server;
+    try {
+        const parsed = JSON.parse(stamp.body);
+        const version = parseCatalogVersion(parsed?.version);
+        const id = idOf(parsed?.id);
+        if (version !== undefined && id !== undefined)
+            server = { id, version, contentHash: hashOf(parsed?.contentHash) };
+    }
+    catch { /* handled below */ }
+    if (!server || server.version === 0) {
+        // An unseeded box (version 0) or a stamp that cannot be compared.
+        // Same rule as 404: nothing to order with, nothing invented.
+        logger.write('Hub seed: the version route sent no usable stamp (unseeded box?) -- serving the cache, if any.');
+        return 'no-route';
+    }
+    const cached = hubCacheStamp(readCacheFn);
+    const verdict = cached && cached.id !== server.id
+        ? { stale: true, why: `the server hosts "${server.id}", the cache holds "${cached.id}"` }
+        : isCacheStale(cached, { version: server.version, contentHash: server.contentHash });
+    if (!verdict.stale) {
+        logger.write(`Hub seed: ${verdict.why} -- nothing to download.`);
+        return 'fresh';
+    }
+    logger.write(`Hub seed: refreshing -- ${verdict.why}.`);
+    await download();
+    return 'refreshed';
+}
+/** Highest version wins; on a tie the fresher origin (live over cache). */
+export function chooseHubSeed(live, cache) {
+    let best;
+    for (const candidate of [cache, live]) {
+        if (candidate && (best === undefined || candidate.stamp.version >= best.stamp.version))
+            best = candidate;
+    }
+    return best;
+}
+/** The best hub seed held right now, or undefined when none is. */
+export function loadHubSeed(readCacheFn = readCache) {
+    if (resolved)
+        return resolved.seed;
+    const cached = readCacheFn();
+    const cacheStamp = hubCacheStamp(() => cached);
+    resolved = chooseHubSeed(liveSource, cached && cacheStamp ? { stamp: cacheStamp, seed: stamped(cached.seed, cacheStamp), origin: 'cache' } : undefined);
+    return resolved?.seed;
+}
+export function hubSeedStatus(readCacheFn = readCache) {
+    loadHubSeed(readCacheFn);
+    return resolved ? { origin: resolved.origin, stamp: { ...resolved.stamp }, name: resolved.seed.name } : undefined;
+}
+/** Drop every memo and take the machine's cache out of the contest. */
+export function resetHubSeedForTest() {
+    liveSource = undefined;
+    resolved = undefined;
+    diskCacheDisabled = true;
+}
+export class HubSeedUnavailableError extends Error {
+    decision;
+    constructor(decision, message) {
+        super(message);
+        this.decision = decision;
+        this.name = 'HubSeedUnavailableError';
+    }
+}
+const HUB_REFUSALS = {
+    'logged-out': 'The side quest needs your home district from maka-cli.com, and there is no cached copy on this machine. '
+        + 'Sign in with "maka login" and connect once; the cached hub then lets you play offline.',
+    'unverified': 'Your email isn\'t verified yet. Run "maka register --resend-verification", click the link in the email, then relaunch.',
+    'unauthorized': 'maka-cli.com refused this session, and there is no cached hub on this machine. Run "maka login", then relaunch.',
+    'offline': 'Could not reach maka-cli.com for your home district, and there is no cached copy on this machine. '
+        + 'Connect once while signed in; after that the cache plays offline.',
+    'no-route': 'maka-cli.com does not serve the hub yet -- the site is mid-deploy. Give it a few minutes and relaunch.',
+};
+/**
+ * THE BOOT GATE: ensureHubSeed, then insist that a seed is loadable.
+ * Throws HubSeedUnavailableError with a player-facing message otherwise
+ * -- or for 'unverified' regardless of the cache, as the catalog does.
+ */
+export async function requireHubSeed(input) {
+    const decision = await ensureHubSeed(input);
+    const status = hubSeedStatus(input.readCacheFn);
+    const seed = loadHubSeed(input.readCacheFn);
+    if (decision === 'unverified' || !status || !seed) {
+        const message = HUB_REFUSALS[decision]
+            ?? `Your home district could not be loaded (${decision}). Connect to maka-cli.com while signed in and try again.`;
+        throw new HubSeedUnavailableError(decision, message);
+    }
+    return { decision, seed, stamp: status.stamp, origin: status.origin };
+}
+/**
+ * WHAT A SAVE RECORDS ABOUT ITS HUB: the stamp of the seed the overlay
+ * was captured against. Undefined for an unstamped seed (a hand-written
+ * fixture, a scene handed straight to Game.getInstance) -- the caller
+ * decides whether that is worth a log line. While the embedded copy is
+ * still dual-written (engine 1.51.0) nothing is lost either way.
+ */
+export function hubSeedRefOf(seed) {
+    if (!seed)
+        return undefined;
+    const id = idOf(seed.id);
+    const version = parseCatalogVersion(seed.version);
+    if (id === undefined || version === undefined)
+        return undefined;
+    return { id, version, contentHash: hashOf(seed.contentHash) ?? '' };
+}
+//# sourceMappingURL=hub-seed.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/site-transport.js

@@ -0,0 +1,61 @@
+import * as http from 'http';
+import * as https from 'https';
+/**
+ * ONE TRANSPORT TO maka-cli.com (2026-09-12).
+ *
+ * The same twenty lines -- the MAKA_DEV host rule, the x-auth-token
+ * header, a short timeout, a status-and-body promise -- were copied into
+ * cloud-saves.ts, catalog.ts, social.ts, session-telemetry.ts and
+ * backlog.ts, so a transport-level fix landed five times or not at all.
+ * The hub seed fetcher (hub-seed.ts) would have been copy #6; instead it
+ * and catalog.ts share this one. The other four are NOT migrated here
+ * (deliberately: each carries its own retry/queue semantics worth a
+ * separate pass), and they still work exactly as they did.
+ *
+ * THE TOKEN IS PASSED IN, never sourced here, and this module imports
+ * nothing from the game. Reading the token would mean importing
+ * cloud-saves.ts, and catalog -> cloud-saves -> persistence -> player ->
+ * catalog is a runtime import cycle ('Cannot access X before
+ * initialization', a couple of hundred red suites). Every caller already
+ * holds the token.
+ *
+ * STATUS IS REPORTED, NOT THROWN. A stamp probe has to tell a 404 (no
+ * such route) from a 401 (a stale token) from a dead socket, and those
+ * are three different decisions; only the socket failing rejects.
+ */
+const DEV = process.env.MAKA_DEV === 'True';
+const HOSTNAME = DEV ? 'localhost' : 'www.maka-cli.com';
+const PORT = DEV ? Number(process.env.MAKA_DEV_PORT ?? 3000) : 443;
+export function siteRequest(method, apiPath, token, body, timeoutMs = 8000) {
+    return new Promise((resolve, reject) => {
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        const mod = DEV ? http : https;
+        const req = mod.request({
+            hostname: HOSTNAME,
+            port: PORT,
+            path: apiPath,
+            method,
+            timeout: timeoutMs,
+            headers: {
+                ...(token === undefined ? {} : { 'x-auth-token': token }),
+                ...(payload !== undefined
+                    ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
+                    : {}),
+            },
+        }, res => {
+            let data = '';
+            res.on('data', chunk => { data += chunk; });
+            res.on('end', () => resolve({ statusCode: res.statusCode ?? 0, body: data }));
+        });
+        req.on('timeout', () => req.destroy(new Error('timeout')));
+        req.on('error', reject);
+        if (payload !== undefined)
+            req.write(payload);
+        req.end();
+    });
+}
+/** One GET, status reported rather than thrown. */
+export function siteGet(apiPath, token, timeoutMs = 8000) {
+    return siteRequest('GET', apiPath, token, undefined, timeoutMs);
+}
+//# sourceMappingURL=site-transport.js.map

package/bundle/typescript/src/commands/game/sideQuest.sub.cmd.js

@@ -441,7 +441,7 @@ const ShadowrunCommand = Command.create({
     }
     // Lazy game-graph load (see the comment at the imports above). One
     // parallel block so the handler body below is otherwise untouched.
-    const [{ SceneSeedGenerator }, { ARCHETYPES, getArchetype, outfitArchetype }, { Player }, { Room }, { Logger }, { savesDir, savePathFor, listSaves, deleteSave, readSave, writeSaveAtomic }, { isLockHeld }, { SAVE_VERSION }, { authToken, fetchSummaries, fetchSave, pushSave, deleteCloudSave, reconcile },] = await Promise.all([
+    const [{ SceneSeedGenerator }, { ARCHETYPES, getArchetype, outfitArchetype }, { Player }, { Room }, { Logger }, { savesDir, savePathFor, listSaves, deleteSave, readSave, writeSaveAtomic }, { isLockHeld }, { SAVE_VERSION }, { authToken, fetchSummaries, fetchSave, pushSave, deleteCloudSave, reconcile, setCloudSessionId },] = await Promise.all([
         import('./sideQuest/factories/scene-seed-generator.js'),
         import('./sideQuest/archetypes.js'),
         import('./sideQuest/models/player.js'),
@@ -453,13 +453,19 @@ const ShadowrunCommand = Command.create({
         import('./sideQuest/utilities/cloud-saves.js'),
     ]);
     const shadowrunConfig1 = require('./sideQuest/scenes/scene1.json');
-    const shadowrunConfig2 = require('./sideQuest/scenes/scene2.json');
+    // THE HUB IS NOT A FILE ANY MORE (2026-09-12): scene2.json left the
+    // package. Tacoma Purple Haze is served by maka-cli.com and cached
+    // like the catalog -- see the hub-seed gate below, which sets this.
+    let hostedHub;
     try {
         const makaDir = this.fsi.getGlobalMakaDir();
         // Each play session gets its own directory (timestamp-named) instead of
         // appending to one ever-growing log file. Generated AI scenes are saved
         // alongside the log for that same session -- see SceneSeedGenerator.
         const sessionId = new Date().toISOString().replace(/[:.]/g, '-');
+        // Every push this process makes names its session, so a slot held
+        // open by a browser hub on the site refuses it (2026-09-12).
+        setCloudSessionId(sessionId);
         const sessionDir = path.join(makaDir, 'side-quest-sessions', sessionId);
         const logFilePath = path.join(sessionDir, 'game.log');
         // PLAY-SESSION RECORDING CONSENT (opt-in ruling 2026-08-24): the
@@ -582,6 +588,27 @@ const ShadowrunCommand = Command.create({
                 throw e;
             }
         }
+        // THE HUB GATE (2026-09-12), the catalog's twin: the home district
+        // is served by maka-cli.com and cached on this machine; with neither
+        // there is no hub to start in, and a game that invented one would be
+        // the second source of truth the migration removed. A resume plays
+        // the LATEST served seed too -- the save's overlay is laid over it
+        // by name -- so this runs before the Continue menu as well.
+        {
+            const { requireHubSeed, HubSeedUnavailableError } = await import('./sideQuest/utilities/hub-seed.js');
+            try {
+                const hub = await requireHubSeed({ token: authToken() });
+                hostedHub = hub.seed;
+                Logger.getInstance().write(`Hub seed: ${hub.decision} -- serving "${hub.seed.name}" v${hub.stamp.version} (${hub.stamp.id}, ${hub.origin}).`);
+            }
+            catch (e) {
+                if (e instanceof HubSeedUnavailableError) {
+                    Log.error(e.message);
+                    process.exit(1);
+                }
+                throw e;
+            }
+        }
         // WHO GETS OFFERED THE SMOKE-TEST SCENE (playtest 2026-08-27:
         // "let's remove Seattle Underground for non playtesters"). Fired
         // HERE, as early as the login is known, and awaited much later at
@@ -597,6 +624,9 @@ const ShadowrunCommand = Command.create({
         // only people who are supposed to see it.
         const playtesterProbe = (await import('./sideQuest/utilities/playtester.js'))
             .probePlaytesterStanding({ anonymous: !authToken() });
+        // Slots the site says are LIVE somewhere else (a browser hub holds
+        // the lease) -- filled from the summaries below, read at the menu.
+        const leasedSlugs = new Map();
         if (authToken()) {
             const fsMod = await import('fs');
             // Tombstones first: a runner who died offline still owes the
@@ -613,6 +643,9 @@ const ShadowrunCommand = Command.create({
             const deadSlugs = new Set(tombstones.map(t => t.replace(/\.dead$/, '')));
             const cloud = await fetchSummaries();
             if (cloud.ok) {
+                for (const c of cloud.saves)
+                    if (c.leasedBy)
+                        leasedSlugs.set(c.slug, c.leasedBy);
                 const cloudSlugs = new Set(cloud.saves.map(c => c.slug));
                 for (const c of cloud.saves) {
                     if (c.version !== SAVE_VERSION || deadSlugs.has(c.slug))
@@ -756,6 +789,17 @@ const ShadowrunCommand = Command.create({
             }
             resumeSavePath = pick;
             resumeSave = liveSlots.find(r => r.filePath === resumeSavePath).save;
+            // LIVE SOMEWHERE ELSE (2026-09-12): the site leases a slot to a
+            // browser hub session; a terminal must not play the same life at
+            // the same time. Listed, so the player sees the runner exists;
+            // refused, so they leave the hub there first.
+            const heldElsewhere = leasedSlugs.get(path.basename(resumeSavePath, '.json'));
+            if (heldElsewhere) {
+                Log.error(`${resumeSave.playerName} is live on maka-cli.com right now (a browser session holds the slot). Leave the hub there first, then continue here.`);
+                resumeSave = undefined;
+                resumeSavePath = undefined;
+                continue menu;
+            }
             // One terminal per runner (see utilities/session-lock.ts): a
             // slot with a live session refuses here, at the menu, instead
             // of after the screen has already flashed up. The game process
@@ -1057,7 +1101,7 @@ const ShadowrunCommand = Command.create({
         // joins the list only for play-testers (below), and remains the
         // generation-failure fallback for everyone.
         const choices = [
-            { name: shadowrunConfig2.name, value: shadowrunConfig2 },
+            { name: hostedHub.name, value: hostedHub },
         ];
         // SEATTLE UNDERGROUND IS A SMOKE TEST, not content, and it sat in
         // this menu next to Tacoma Purple Haze as though it were a job you
@@ -1083,10 +1127,13 @@ const ShadowrunCommand = Command.create({
         if (gameOptions.useAi && AI.canGenerate()) {
             choices.push({ name: 'Generate a new Run (AI)', value: GENERATE_NEW_RUN });
         }
-        // Resuming skips the scene pick: the save EMBEDS its hub seed, so an
-        // old runner's world never depends on today's scene2.json.
+        // Resuming skips the scene pick: the runner's home is the hub
+        // maka-cli.com serves TODAY (the gate above), never the copy an
+        // older save embedded -- the save's overlay is laid over the served
+        // seed by name (persistence.ts applyHubOverlay), which is how a hub
+        // edit reaches a returning runner without a CLI release.
         let sideQuestAnswer = resumeSave
-            ? resumeSave.hubSeed
+            ? hostedHub
             : await Actions.select({
                 message: 'Which Run would you like to play?',
                 name: 'sideQuestAnswer',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.175.1",
+  "version": "5.177.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",