@songsid/agend 2.3.0-beta.2 → 2.3.0-beta.3

package/dist/fleet-manager.js

@@ -158,7 +158,7 @@ import { ReplyButtonsController } from "./reply-buttons-controller.js";
 import { parsePoll } from "./reply-polls.js";
 import { isUploadRequest, limitRequestReceive, publicAttachment, sweepOrphanedUploads, UPLOAD_REQUEST_TIMEOUT_MS, uploadLimits, WebFileLedger } from "./web-upload.js";
 import { REPLY_FILES_MAX_BYTES, snapshotReplyFile, sweepReplySnapshots, webFilesDir } from "./web-reply-files.js";
-import { cardPicture, handleViewRequest, humanCards, identityColors, isViewPath, profileIdentities, resolveInstanceIdentity } from "./view-api.js";
+import { cardPicture, handleViewRequest, humanCards, identityColors, isViewPath, personIdentityColour, profileIdentities, resolveInstanceIdentity, setPersonIdentityColour } from "./view-api.js";
 import { autoIdentityColor } from "./web-identity-color.js";
 import { AppearanceTools } from "./web-appearance-tools.js";
 import { cardVersion, resolveCard } from "./web-card.js";
@@ -178,7 +178,10 @@ import { runOnLoginShell } from "./login-shell.js";
 import { tightenInstanceDirs } from "./private-dir.js";
 import { decideSlash } from "./slash-authz.js";
 import { canonicalCommand, commandSpec, decideCommand, ruleFor } from "./command-table.js";
-import { runVisibilityCommand } from "./cross-instance-notice.js";
+import { crossInstanceVisibility, runVisibilityCommand } from "./cross-instance-notice.js";
+import { WebSettingsTools } from "./web-settings-tools.js";
+import { bindGuestRequest, guestRouteDecision } from "./web-guest-access.js";
+import { TrafficLog, trafficItem } from "./fleet-traffic.js";
 import { installedChannel, updateNoticeKey } from "./update-check.js";
 import { resolveInstalledAgend } from "./update-dispatch.js";
 import { resolveUpdateLaunch, openUpdateLog, updateLogPath, watchUpdateLaunch } from "./update-launch.js";
@@ -190,7 +193,7 @@ import { setLocale, detectLocale, getLocale, t } from "./locale.js";
 import { recentChatContext } from "./log-tail.js";
 import { describeSignalSource, recordInternalRequest, withOrigin } from "./fleet-control-audit.js";
 import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
-import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
+import { ClassicChannelManager, classicWebEchoOn, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
 import { KNOWN_BACKENDS, validateFleetConfig } from "./config-validator.js";
 import { isRemovedBackend, removedBackendMessage } from "./backend/removed.js";
@@ -209,6 +212,7 @@ import { NeedsYouHub } from "./needs-you-hub.js";
 import { WEB_CHAT_NOTICE, claimNotice, hasWebChat, releaseNotice, upgradeNoticesPath } from "./upgrade-notices.js";
 import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 import { buildOrgChart } from "./web-org.js";
+import { topMemoryHogs } from "./memory-hogs.js";
 import { GENERAL_POINTING_REFUSALS, SNOWFLAKE, hasPlaceRefs, placeRef, webRoute, webTextLinks, placeSuffix, renderPlaceRefs, stripPlaceRefs, topicUrl, worldPlaceOf } from "./topic-link.js";
 import { CacheService, cacheWindow } from "./cache-service.js";
 import { runWebCommand } from "./web-commands.js";
@@ -234,7 +238,7 @@ import { PROVIDER_SECRET_SPECS, providerSecretSpec, providerRegistryEnvKeys, isR
 /** A self-restart is a whole service restart; 120s is the apply budget, not this. */
 const SELF_RESTART_DEADLINE_MS = 300_000;
 import { APPLY_FLEET_TARGET, ApplyJobStore, viewOf, } from "./apply-job.js";
-import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
+import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
 import { carryClaudeConversation } from "./backend/claude-carry.js";
 import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
 import { classifyInstanceChange, CLASSIC_HOT_CONFIG_KEYS, HOT_INSTANCE_CONFIG_KEYS, hotConfigUpdate, } from "./instance-config-impact.js";
@@ -504,6 +508,8 @@ function emojiListFilter(opts) {
         withImageUrls: flag(opts.with_image_urls),
     };
 }
+/** #1920: a guest's scope until phase 2 derives one: nothing. */
+const NO_GUEST_SCOPE = new Set();
 export class FleetManager {
     dataDir;
     static signalTarget = null;
@@ -774,6 +780,8 @@ export class FleetManager {
     /** #1306: the preview listener (health_port + 1 by default), and whether it is listening. */
     previewListener = null;
     previewListening = false;
+    /** The preview listener could not open its port: "<port>: <error code>", for the page (#2061 follow-up); null otherwise. */
+    previewListenError = null;
     /** The ports the preview listener was started for, and the inputs it was built from (a reload compares them). */
     previewPorts = null;
     previewInputs = "";
@@ -806,6 +814,17 @@ export class FleetManager {
     startedAt = 0;
     stormOpenNotifyTimer = null;
     memoryLogAt = null;
+    /**
+     * #2015: while host memory is elevated or critical, the processes holding the most in the fleet's service and whose
+     * they are (an instance, the fleet, tmux), for the pressure log, /health and the dashboard — never chat (#1712).
+     * Rescanned at most once a minute (async, one at a time); cleared when pressure ends.
+     */
+    memoryTop = null;
+    memoryTopScan = { at: null, inFlight: false, loggedAt: null };
+    /** The scan (a seam for tests: they give it a fake /proc). */
+    memoryHogScan = topMemoryHogs;
+    /** The fleet's own tmux session exists (only then are its panes read: a fleet that never started has none). */
+    tmuxSessionEnsured = false;
     memoryDebugAt = null;
     memoryLogLevel = null;
     /** #1685: the host_memory value the last status frame carried, so a change re-sends the frame. */
@@ -1079,6 +1098,26 @@ export class FleetManager {
     get ownerCss() {
         return (this.ownerCssStore ??= new OwnerCssStore(this.dataDir, this.webPrefs));
     }
+    webSettingsToolsService;
+    /**
+     * #2056: Settings → Web appearance for a tool (General, a coordinator, full) — the page's own stores and checks, and the
+     * page's announcement after a change (web-settings-tools.ts).
+     */
+    get webSettings() {
+        return (this.webSettingsToolsService ??= new WebSettingsTools({
+            prefs: this.webPrefs, ownerCss: this.ownerCss, mods: this.mods, effects: this.effectService,
+            instances: () => [...Object.keys(this.fleetConfig?.instances ?? {}),
+                ...(this.classicChannels?.getAll() ?? []).map((ch) => ch.instanceName).filter((n) => !Object.hasOwn(this.fleetConfig?.instances ?? {}, n))],
+            colour: (name) => personIdentityColour(this.dataDir, name),
+            setColour: (name, patch) => { const w = setPersonIdentityColour(this.dataDir, name, patch); if (w.ok)
+                this.identityChanged(); return w; },
+            placements: (name) => this.themeStore.get(name).placements.effects.map((e) => (typeof e === "string" ? { id: e } : e)),
+            announce: () => { try {
+                this.emitSseEvent("status", this.getUiStatus());
+            }
+            catch { /* the next status frame carries it */ } },
+        }));
+    }
     get webPrefs() {
         // #1664: a favorite must be an instance of this fleet now — fleet.yaml's (own keys) or a ClassicBot room's.
         return (this.webPrefsStore ??= new WebPrefsStore(this.dataDir, {
@@ -1573,6 +1612,18 @@ export class FleetManager {
                 }
             }
         });
+        // #1918: the org canvas's traffic — from the row this listener's events already name, never a probe of its own.
+        // The row as it is now (it has already changed when the event comes): its state, not the event's, is the truth.
+        outbox.on("state", (event) => {
+            const row = event.deliveryId ? outbox.get(event.deliveryId) : undefined;
+            if (row)
+                this.publishTraffic(row);
+        });
+        outbox.on("consumed", (event) => {
+            const row = event.deliveryId ? outbox.get(event.deliveryId) : undefined;
+            if (row)
+                this.publishTraffic(row, "consumed");
+        });
         outbox.on("generation_recovered", () => this.scheduleDeliveryOutboxPump());
         this.replyObligationTimer = setInterval(() => measureSyncWork("fleet.replyObligationSweep", () => this.sweepReplyObligations()), REPLY_OBLIGATION_SWEEP_MS);
         this.replyObligationTimer.unref?.();
@@ -1594,6 +1645,40 @@ export class FleetManager {
         });
         this.scheduleDeliveryOutboxPump();
     }
+    /** #1918: cross-instance traffic, as the org canvas draws it (fleet-traffic.ts). */
+    trafficLog = new TrafficLog();
+    trafficMemo = null;
+    /** One delivery row's traffic item, kept for the snapshot and sent to the open pages when it is news. */
+    publishTraffic(row, state) {
+        try {
+            const item = trafficItem(row, this.fleetConfig, new Date().toISOString(), state);
+            const news = item ? this.trafficLog.note(item) : null;
+            if (news) {
+                this.trafficMemo = null;
+                this.emitSseEvent("traffic", news);
+            }
+        }
+        catch (err) {
+            this.logger.debug({ err }, "traffic: an item was not published");
+        }
+    }
+    /**
+     * GET /ui/traffic: what is in flight now (the outbox's pending rows) and what finished in the last two minutes, at
+     * most TRAFFIC_SNAPSHOT_MAX items. Worked out at most once every two seconds, so the public link's polling (or any
+     * number of pages) costs one indexed read per two seconds. Visibility is applied as of now.
+     */
+    trafficSnapshot() {
+        const nowMs = performance.now();
+        if (this.trafficMemo && nowMs - this.trafficMemo.atMs < 2_000)
+            return this.trafficMemo.value;
+        const now = new Date().toISOString();
+        const pending = (this.deliveryOutbox?.listPending() ?? [])
+            .map((r) => trafficItem(r, this.fleetConfig, r.createdAt ?? now)).filter((i) => i !== null);
+        const visible = (name) => crossInstanceVisibility(this.fleetConfig, name) !== "hidden";
+        const items = this.trafficLog.snapshot(pending).filter((i) => visible(i.from) && visible(i.to));
+        this.trafficMemo = { atMs: nowMs, value: { now, items } };
+        return this.trafficMemo.value;
+    }
     /** Synchronous SQLite admission; the caller may acknowledge only after this returns. */
     admitDurableDelivery(input) {
         const outbox = this.deliveryOutbox;
@@ -1606,6 +1691,8 @@ export class FleetManager {
         }
         const sourceKey = `mcp:${input.sourceInstance}:${input.operationId}:${input.targetInstance}:${input.targetSession ?? ""}:${input.kind}`;
         const admitted = outbox.admit({ ...input, sourceDaemonBootId, sourceKey });
+        if (admitted.inserted)
+            this.publishTraffic(admitted.delivery);
         if (admitted.inserted)
             this.logger.info({
                 deliveryId: admitted.delivery.deliveryId,
@@ -1979,17 +2066,58 @@ export class FleetManager {
                 this.logger.info({ hostMemory: snapshot }, "Host memory recovered");
             }
             this.memoryLogLevel = snapshot.level;
+            if (this.memoryTop) {
+                this.memoryTop = null;
+                this.memoryTopScan.loggedAt = null;
+                this.emitSseEvent("status", this.getUiStatus());
+            }
             return;
         }
+        if (snapshot.level === "elevated" || snapshot.level === "critical")
+            this.refreshMemoryTop(snapshot);
         if (changed || this.memoryLogAt === null || now - this.memoryLogAt >= 10 * 60_000) {
             this.memoryLogAt = now;
-            this.logger.warn({ hostMemory: snapshot }, snapshot.level === "critical"
+            this.logger.warn({ hostMemory: snapshot, ...(this.memoryTop ? { topProcesses: this.memoryTop.processes } : {}) }, snapshot.level === "critical"
                 ? "Host memory critical — deferring new CLI spawns"
                 : snapshot.level === "elevated" ? "Host memory pressure — slowing new CLI spawns"
                     : "Host memory sample unavailable — slowing new CLI spawns");
         }
         this.memoryLogLevel = snapshot.level;
     }
+    /**
+     * #2015: rescan the largest processes (at most once a minute, one at a time). The first result of an episode, and
+     * then at most every 10 minutes, is logged with the pressure; /health and the dashboard read the latest. Never chat.
+     */
+    refreshMemoryTop(snapshot) {
+        const scan = this.memoryTopScan;
+        const now = performance.now();
+        if (scan.inFlight || (scan.at !== null && now - scan.at < 60_000))
+            return;
+        scan.inFlight = true;
+        scan.at = now;
+        void (async () => {
+            const session = getTmuxSession();
+            const [tmuxServerPid, panes] = this.tmuxSessionEnsured
+                ? await Promise.all([TmuxManager.getServerPid(session), TmuxManager.listPanePids(session)])
+                : [null, []];
+            const processes = await this.memoryHogScan({
+                fleetPid: process.pid, tmuxServerPid, panes,
+                isInstance: name => this.daemons.has(name) || Object.hasOwn(this.fleetConfig?.instances ?? {}, name),
+            }, 3);
+            // Pressure may have ended while the scan ran: nothing is kept then.
+            if (this.shuttingDown || processes.length === 0 || this.hostMemoryIndicator() === null)
+                return;
+            const before = JSON.stringify(this.memoryTop?.processes ?? null);
+            this.memoryTop = { at: new Date().toISOString(), processes };
+            if (scan.loggedAt === null || performance.now() - scan.loggedAt >= 10 * 60_000) {
+                scan.loggedAt = performance.now();
+                this.logger.warn({ hostMemory: snapshot, topProcesses: processes }, "Host memory pressure — largest processes in the fleet");
+            }
+            if (JSON.stringify(processes) !== before)
+                this.emitSseEvent("status", this.getUiStatus());
+        })().catch(err => this.logger.debug({ err }, "Largest-process scan failed"))
+            .finally(() => { scan.inFlight = false; });
+    }
     /** Wire the one fleet-wide storm into notification and recovery surfaces. */
     bindStormWindowEvents() {
         this.stormWindow.on("opened", (snapshot) => {
@@ -3436,7 +3564,8 @@ export class FleetManager {
      * for `instance` (#1320 part B). Per entry: the channel's own adapter, no
      * thread, mention suppression on. Returns the number of channels posted
      * to. Failures are per-entry warn-and-continue — a failed echo never fails
-     * the web send. Entries without `web_echo: true` are never touched.
+     * the web send. Only entries classicWebEchoOn admits are touched (#2054: unset follows web.echo_to_channel; an explicit
+     * `web_echo: false` never echoes).
      *
      * Every copy is fenced at start time: an entry whose explicit world is
      * gone is skipped (only legacy adapterId-less entries fall back to the
@@ -3463,7 +3592,7 @@ export class FleetManager {
                 }
             }
             const entry = (this.classicChannels?.getAll() ?? [])
-                .find(candidate => candidate.instanceName === instance && candidate.webEcho === true
+                .find(candidate => candidate.instanceName === instance && classicWebEchoOn(candidate.webEcho, this.fleetConfig?.web?.echo_to_channel)
                 && !handled.has(`${candidate.channelId}#${candidate.adapterId ?? ""}`));
             if (!entry)
                 break;
@@ -6266,6 +6395,7 @@ export class FleetManager {
         const { getTmuxSocketName: getSocket } = await import("./paths.js");
         TmuxManager.setSocketName(getSocket());
         await TmuxManager.ensureSession(getTmuxSession());
+        this.tmuxSessionEnsured = true;
         // Pre-flight (advisory, fire-and-forget): warm the per-backend auth cache
         // before instances spawn, so a CLI that comes up on its sign-in screen gets
         // an instant 🔑 verdict instead of decaying into crash/MCP-died noise.
@@ -7089,7 +7219,8 @@ export class FleetManager {
             adapters: { total: this.adapterState.size, connected, states, details },
             startupComplete: this.startupComplete,
             memory: readFleetMemory(),
-            hostMemory,
+            hostMemory: this.memoryTop && (hostMemory.level === "elevated" || hostMemory.level === "critical")
+                ? { ...hostMemory, topProcesses: this.memoryTop.processes, topProcessesAt: this.memoryTop.at } : hostMemory,
             problems,
         };
     }
@@ -13034,11 +13165,12 @@ export class FleetManager {
             };
         };
         const choicesFromCache = (instance) => {
-            const cached = this.readCliEnv(this.backendNameForInstance(instance)); // the cached catalog only: never a probe here
+            const backend = this.backendNameForInstance(instance);
+            const cached = this.readCliEnv(backend, this.catalogProfile(backend, instance)); // the cached catalog only: never a probe here
             if (!cached?.models.length)
                 return null;
             const current = this.resolveInstanceModel(instance).model;
-            return { current, options: cached.models.map(o => ({ id: o.id, label: this.modelChoiceLabel(o, current) })) };
+            return { current, options: this.withCurrentModel(cached.models, current).map(o => ({ id: o.id, label: this.modelChoiceLabel(o, current) })) };
         };
         return runWebCommand({
             // Own entries only: a name like "__proto__" or "constructor" must not be found on the prototype (#1476 review).
@@ -15817,7 +15949,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** #1806: null on a switch INTO claude-code — the configured model then belongs to the backend being left. */
     configured = this.fleetConfig?.instances[instanceName]?.model ?? this.fleetConfig?.defaults?.model) {
         const aliases = ["default", "sonnet", "opus", "haiku", "opusplan", "Fable"];
-        const api = (this.readCliEnv("claude-code")?.apiModels ?? []).map(m => m.id);
+        const api = (this.readCliEnv("claude-code", this.catalogProfile("claude-code", instanceName))?.apiModels ?? []).map(m => m.id);
         const lower = model.trim().toLowerCase();
         const bare = lower.replace(/\[1m\]$/, "");
         const known = aliases.some(a => a.toLowerCase() === bare)
@@ -15845,13 +15977,22 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             : undefined;
         return classic ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
     }
-    cliEnvPath(backend) {
-        return join(getAgendHome(), "cli-env", `${backend.replace(/[^A-Za-z0-9._-]/g, "_")}.json`);
+    /**
+     * #2072: a catalog is the account's, so a credential profile has its own. Only claude-code's probe reads an account
+     * catalog through a profile's login (its `GET /v1/models` with the profile's token); other backends' probes read the
+     * process environment, so their catalog stays the backend's own.
+     */
+    catalogProfile(backend, instanceName) {
+        return backend === "claude-code" && instanceName ? this.credentialProfileOf(instanceName, backend) : null;
+    }
+    cliEnvPath(backend, profile = null) {
+        const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "_");
+        return join(getAgendHome(), "cli-env", profile ? `${safe(backend)}@${safe(profile)}.json` : `${safe(backend)}.json`);
     }
-    /** Read the cached CLI env for a backend, or null if missing/stale/unparseable. */
-    readCliEnv(backend) {
+    /** Read the cached CLI env for a backend (a credential profile's own, when given), or null if missing/stale/unparseable. */
+    readCliEnv(backend, profile = null) {
         try {
-            const env = JSON.parse(readFileSync(this.cliEnvPath(backend), "utf-8"));
+            const env = JSON.parse(readFileSync(this.cliEnvPath(backend, profile), "utf-8"));
             if (typeof env?.probedAt === "number" && Date.now() - env.probedAt < CLI_ENV_TTL_MS)
                 return env;
         }
@@ -15894,10 +16035,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * previous list, never stall the command that asked for it.
      */
     async probeBackendBounded(backend, opts = {}) {
-        // #725: single-flight per backend. Explicit vendor refreshes remain a
+        // #725: single-flight per backend (#2072: per backend and credential profile). Explicit vendor refreshes remain a
         // separate flight from an ordinary probe, while sysinfo can join either.
-        const regularFlight = this.pendingCliEnvProbes.get(backend);
-        const vendorFlight = this.pendingVendorCliEnvProbes.get(backend);
+        const profile = opts.profile ?? null;
+        const key = profile ? `${backend}@${profile}` : backend;
+        const regularFlight = this.pendingCliEnvProbes.get(key);
+        const vendorFlight = this.pendingVendorCliEnvProbes.get(key);
         if (opts.refreshVendorCatalog && vendorFlight)
             return vendorFlight;
         if (!opts.refreshVendorCatalog && (vendorFlight || regularFlight))
@@ -15908,25 +16051,26 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const epoch = this.cliEnvProbeEpoch;
         const input = {
             mode: "env", backend, instanceDir,
-            config: { workingDirectory: "", instanceDir, instanceName: `probe-${backend}`, mcpServers: {} },
+            config: { workingDirectory: "", instanceDir, instanceName: `probe-${backend}`, mcpServers: {},
+                ...(profile ? { credentialStoreHome: credentialProfileStoreHome(getAgendHome(), backend, profile) } : {}) },
             refreshVendorCatalog: opts.refreshVendorCatalog === true,
         };
-        const bounded = this.runBackendProbeWorker(`global:${backend}`, input).then(probed => {
+        const bounded = this.runBackendProbeWorker(`global:${key}`, input).then(probed => {
             if (!probed || Array.isArray(probed) || this.shuttingDown || epoch !== this.cliEnvProbeEpoch)
                 return null;
             try {
-                return this.persistCliEnvProbeResult(backend, probed);
+                return this.persistCliEnvProbeResult(backend, probed, profile);
             }
             catch (err) {
-                this.logger.warn({ backend, err }, "CLI env cache write failed");
+                this.logger.warn({ backend, profile, err }, "CLI env cache write failed");
                 return null;
             }
         }).finally(() => {
             const flights = opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes;
-            if (flights.get(backend) === bounded)
-                flights.delete(backend);
+            if (flights.get(key) === bounded)
+                flights.delete(key);
         });
-        (opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes).set(backend, bounded);
+        (opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes).set(key, bounded);
         return bounded;
     }
     stopCliEnvProbes() {
@@ -16041,12 +16185,21 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     modelDisplayForInstance(instanceName) {
         return this.resolveInstanceModel(instanceName).display;
     }
+    /**
+     * #2072: the model an instance runs is always among its choices — one its CLI's catalog does not list (an older
+     * name, a custom provider's, a typed one) is shown first, marked, so the menu never hides what is running.
+     */
+    withCurrentModel(options, currentModel) {
+        if (!currentModel || currentModel === "default" || options.some(o => o.id === currentModel))
+            return options;
+        return [{ id: currentModel, label: currentModel, description: t("model.not_listed") }, ...options];
+    }
     modelChoiceLabel(option, currentModel) {
         const label = option.description ? `${option.label} — ${option.description}` : option.label;
         return option.id === currentModel ? `✓ ${label}` : label;
     }
     /** Preserve the existing cache merge rules for worker probes. */
-    persistCliEnvProbeResult(backend, probed) {
+    persistCliEnvProbeResult(backend, probed, profile = null) {
         const env = { backend, probedAt: Date.now(), ...probed };
         // An empty result must never overwrite a catalog we already have. Some
         // probes hit the network (`agy models` fetches, 5s cap), so a slow moment
@@ -16055,14 +16208,14 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // antigravity cache replaced by an empty one. Keep the known models and
         // let the fresher currentModel/version through.
         if (!env.models?.length) {
-            const previous = this.readCliEnv(backend);
+            const previous = this.readCliEnv(backend, profile);
             if (previous?.models?.length)
                 env.models = previous.models;
         }
         // Same protection for the extended catalog: one offline moment must not
         // blank a good account list for the whole cache TTL.
         if (!env.apiModels?.length) {
-            const previous = this.readCliEnv(backend);
+            const previous = this.readCliEnv(backend, profile);
             if (previous?.apiModels?.length)
                 env.apiModels = previous.apiModels;
         }
@@ -16070,12 +16223,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // keeps the cached levels only for that same binary: both versions known and equal, cache still valid. A help
         // that was read and lists none ([]) is an answer and is written as is, so the fallback applies.
         if (env.effortLevels === undefined) {
-            const previous = this.readCliEnv(backend);
+            const previous = this.readCliEnv(backend, profile);
             if (previous?.effortLevels && previous.version && env.version && previous.version === env.version) {
                 env.effortLevels = previous.effortLevels;
             }
         }
-        const path = this.cliEnvPath(backend);
+        const path = this.cliEnvPath(backend, profile);
         mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, JSON.stringify(env, null, 2));
         return env;
@@ -16097,6 +16250,18 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // indefinitely — each is wrapped by CLI_ENV_PROBE_DEADLINE_MS.
         for (const b of backends)
             void this.probeBackendBounded(b);
+        // #2072: each Claude credential profile in use has its own account catalog. Only fleet.yaml's agents are walked
+        // here; a ClassicBot room on a profile is probed on its first /model (catalogProfile knows rooms too).
+        const profiles = new Set();
+        for (const name of Object.keys(this.fleetConfig?.instances ?? {})) {
+            if (this.backendNameForInstance(name) !== "claude-code")
+                continue;
+            const profile = this.catalogProfile("claude-code", name);
+            if (profile)
+                profiles.add(profile);
+        }
+        for (const profile of profiles)
+            void this.probeBackendBounded("claude-code", { profile });
     }
     /** Best-effort model list for `/model`: cached CLI env first, else live probe. Never throws. */
     async getModelOptions(instanceName, refresh = false, onLiveProbe) {
@@ -16110,7 +16275,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      */
     async getModelOptionsWithSource(instanceName, opts = {}) {
         const backendName = this.backendNameForInstance(instanceName);
-        const cached = this.readCliEnv(backendName);
+        const profile = this.catalogProfile(backendName, instanceName);
+        const cached = this.readCliEnv(backendName, profile);
         if (!opts.refresh && cached?.models.length && !this.cliEnvNeedsRefresh(cached)) {
             return { models: cached.models, source: "cache" };
         }
@@ -16121,7 +16287,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // Stale, missing, or a forced refresh → probe live (also refreshes the cache).
         // A newly released model is invisible until this runs, which is why staleness
         // triggers it rather than waiting for the 24h hard expiry or a cold start.
-        const env = await this.probeBackendBounded(backendName, { refreshVendorCatalog: opts.refreshVendorCatalog });
+        const env = await this.probeBackendBounded(backendName, { refreshVendorCatalog: opts.refreshVendorCatalog, profile });
         if (env?.models.length)
             return { models: env.models, source: "live" };
         // Probe failed or timed out: the previous list is still the best answer.
@@ -16136,7 +16302,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     modelMenuChoices(instanceName, nonce, options, currentModel) {
         const isClaude = this.backendNameForInstance(instanceName) === "claude-code";
         const choices = [{ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:__refresh__`, label: t("model.refresh") }];
-        for (const o of options.slice(0, isClaude ? 23 : 24)) {
+        for (const o of this.withCurrentModel(options, currentModel).slice(0, isClaude ? 23 : 24)) {
             choices.push({ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`, label: this.modelChoiceLabel(o, currentModel) });
         }
         if (isClaude)
@@ -16543,16 +16709,18 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
     }
     /** Cached-or-live account catalog behind "/model → more models" (claude). */
-    async claudeApiModelOptions() {
-        const cached = this.readCliEnv("claude-code");
+    async claudeApiModelOptions(instanceName) {
+        // #2072: the account behind THIS instance — its credential profile's catalog, else the default login's.
+        const profile = this.catalogProfile("claude-code", instanceName);
+        const cached = this.readCliEnv("claude-code", profile);
         if (cached?.apiModels?.length)
             return cached.apiModels;
-        const env = await this.probeBackendBounded("claude-code");
+        const env = await this.probeBackendBounded("claude-code", { profile });
         return env?.apiModels ?? [];
     }
     /** Replace a consumed "/model" menu with the full account catalog tier. */
     async expandClaudeModelMenu(pending) {
-        const expanded = await this.claudeApiModelOptions();
+        const expanded = await this.claudeApiModelOptions(pending.instanceName);
         if (!expanded.length) {
             await pending.respond(t("model.more_unavailable")).catch(() => { });
             return;
@@ -19847,6 +20015,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.rejectedHostsLogged.add(name);
         this.logger.warn({ host: name }, "Web request refused: Host is not allowed (add it to web.allowed_hosts if this is a proxy you run)");
     }
+    /**
+     * #1920: the instances a guest session may see — derived on every request, never stored. Phase 2 derives it from
+     * the account's chat access (and an admin's naming for an open connection); until then a guest sees nothing.
+     */
+    guestScope(_owner) {
+        return NO_GUEST_SCOPE;
+    }
     /** Shared handler dispatcher; gateway admission is enforced by its separate listener. */
     dispatchWebHttp(req, res, port, closing = false) {
         try {
@@ -19907,6 +20082,22 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     res.end(JSON.stringify({ error: decision.message }));
                     return;
                 }
+                // #1920: a guest reaches only GUEST_ROUTES, within the scope derived for it now — default deny, before any
+                // handler, on this listener and the public link's gateway alike (both come through here).
+                if (decision.via === "session" && decision.session.tier === "guest") {
+                    const owner = decision.session.owner;
+                    const verdict = guestRouteDecision(req.method ?? "GET", parsedUrl, this.guestScope(owner));
+                    if (verdict.kind === "deny") {
+                        res.writeHead(verdict.status);
+                        res.end(JSON.stringify({ error: verdict.error }));
+                        return;
+                    }
+                    // Phase 1b: the handlers that answer per recipient (the stream, the poll, a file) know it is a guest's, and
+                    // ask its scope anew each time.
+                    const admitted = decision.session;
+                    bindGuestRequest(req, { owner, scope: () => this.guestScope(owner),
+                        current: () => !!this.webSessions && !!this.webToken && this.webSessions.isCurrent(admitted, tokenEpoch(this.webToken)) });
+                }
             }
             if (req.method === "GET" && req.url === "/health") {
                 const health = this.getFleetHealth();
@@ -20297,6 +20488,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.logger.warn({ code: err.code, port: settings.port }, "Preview listener unavailable; HTML previews are off");
             this.previewListening = false;
             this.previewListener = null;
+            this.previewListenError = `${settings.port}: ${err.code ?? err.message}`;
         });
         // An optional listener never takes the fleet down: a port Node refuses outright throws here, synchronously.
         try {
@@ -20307,6 +20499,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.logger.warn({ err: err.message, port: settings.port }, "Preview listener cannot listen; HTML previews are off");
             this.previewListening = false;
             this.previewListener = null;
+            this.previewListenError = `${settings.port}: ${err.code ?? err.message}`;
         }
     }
     /** What a reload may change hot: web.preview, and the dashboard names (the shim's allow-list and frame-ancestors). */
@@ -20327,6 +20520,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     stopPreviewListener() {
         this.previewListening = false;
+        this.previewListenError = null;
         this.previewListener?.close();
         this.previewListener = null;
     }
@@ -20334,10 +20528,18 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     previewForUi(hostHeader, secure) {
         const listener = this.previewListening ? this.previewListener : null;
         const decided = previewAvailability(listener ? listener.settings : null, hostHeader, secure, listener ? listener.origins : undefined);
+        // Previews are on, but no listener answers: say why — its port could not be opened (the error, never "turned off"),
+        // or it is not listening yet.
         if (!listener && this.fleetConfig?.web?.preview !== false)
-            decided.reason = "Previews are not available on this fleet right now.";
+            Object.assign(decided, this.previewNotListening());
         return { ...decided, boot: listener ? listener.bootId : null };
     }
+    previewNotListening() {
+        const failed = this.previewListenError;
+        return failed
+            ? { code: "listenFailed", detail: failed, reason: `Previews are unavailable: the fleet could not open its preview port (${failed}). Another program may be using it — set web.preview_port, then restart AgEnD.` }
+            : { code: "notListening", reason: "Previews are not available on this fleet right now." };
+    }
     /**
      * #1723: for one page of the public link (exposure `exposureId`, at `dashboardOrigin`): its own preview tunnel's
      * origin once up, "starting" until then, why it failed if it did — or a configured web.preview_origin, used instead.
@@ -20352,8 +20554,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const configured = typeof web?.preview_origin === "string" ? normalizeOrigin(web.preview_origin) : null;
         if (configured) {
             const listener = this.previewListening ? this.previewListener : null;
-            if (!listener)
-                return off("publicLink", "Previews are not available on this fleet right now.");
+            if (!listener) {
+                const why = this.previewNotListening();
+                return off(why.code, why.reason, why.detail ? { detail: why.detail } : {});
+            }
             if (!configured.startsWith("https:"))
                 return off("needHttps", "Previews need an https web.preview_origin when the dashboard is reached over https.");
             return { dashboardOrigin, previewOrigin: configured, reason: null, code: null, boot: listener.bootId, frameSrc: `${configured}/frame` };
@@ -20493,6 +20697,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // #1685: host memory pressure while it slows or holds new agents (the dashboard's indicator; macOS elevated is
             // shown here rather than in chat). null when normal, unknown or advisory.
             host_memory: this.hostMemoryIndicator(),
+            // #2015: the largest processes while it lasts (name, pid, RSS, and whose: an instance, the fleet or tmux).
+            ...(this.hostMemoryIndicator() && this.memoryTop ? { host_memory_top: this.memoryTop.processes } : {}),
         };
     }
 }