@songsid/agend 2.2.0-beta.3 → 2.2.0-beta.5

package/dist/fleet-manager.js

@@ -4,11 +4,14 @@ import { SettingsHttpConfirmation } from "./settings-http-confirmation.js";
 import { SettingsControlServer } from "./settings-control.js";
 import { SettingsExecution, settingsRevision, noteSettingsWrite, settingsFileResource, assertSettingsLease, trySettingsLease, waitSettingsLease, settingsUndo, undoSettingsPaths } from "./settings-transaction.js";
 import { performance } from "node:perf_hooks";
+import { withSpawnHoldReply } from "./spawn-hold-reply.js";
 import { gatewayRequestContext } from "./web-request-context.js";
 import { createPublicWebGateway } from "./public-web-gateway.js";
 import { handleWebIconRequest } from "./web-icons.js";
 import { renderPublicLinkProgress, ThrottledMessageEditor } from "./public-link-progress.js";
 import { PublicWebLink, publicLinkSettings } from "./public-web-link.js";
+import { PUBLIC_PREVIEW_FRAME_SRC, PUBLIC_PREVIEW_TUNNEL_DIR, PublicPreview, publicPreviewWanted } from "./public-preview.js";
+import { CloudflaredProvider } from "./tunnel/cloudflared.js";
 import { TunnelPurposeLane } from "./tunnel/purpose-lane.js";
 import { ManagedTunnel } from "./tunnel/manager.js";
 import { withinBudget } from "./monotonic-budget.js";
@@ -27,7 +30,7 @@ import { join, dirname, basename, delimiter, isAbsolute, resolve as resolvePath
 import { fileURLToPath } from "node:url";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
 import { fleetLabel } from "./fleet-label.js";
-import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, setUpdateProgressStage, updateProgressOperation, } from "./update-marker.js";
+import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, setUpdateProgressStage, updateProgressOperation, updateReceiptOf, } from "./update-marker.js";
 import { formatUpdateProgress } from "./update-progress.js";
 import { sdNotify, sdNotifyBlocking } from "./sd-notify.js";
 import { readFleetMemory } from "./process-memory.js";
@@ -75,7 +78,7 @@ import { InstanceLifecycle, SupersededStartError, BACKEND_INSTALLATION_INFO, che
 import { TopicArchiver } from "./topic-archiver.js";
 import { StatuslineWatcher } from "./statusline-watcher.js";
 import { outboundHandlers } from "./outbound-handlers.js";
-import { DeliveryOutbox, isSilentScheduleDelivery } from "./delivery-outbox.js";
+import { DeliveryOutbox, DEFAULT_REPLY_OBLIGATION_TTL_MS, isSilentScheduleDelivery } from "./delivery-outbox.js";
 // The target Daemon can legitimately wait 30 minutes for a busy pane before
 // deciding to defer before submission. This is an alert threshold only: the
 // active manager/target generation pair owns the lane until the daemon reports
@@ -129,6 +132,7 @@ export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
 import { handleWebRequest, broadcastSseEvent, SSE_HEARTBEAT_MS } from "./web-api.js";
 import { WebChatHistory, WEB_CHAT_TEXT_MAX, isWebMessageId, newWebMessageId } from "./web-chat-history.js";
 import { WebChatDiskStore } from "./web-chat-store.js";
+import { SeenUsers, resolveMentions } from "./web-mentions.js";
 import { WebPrefsStore } from "./web-prefs.js";
 import { ReplyButtonStore, parseReplyButtons, replyButtonClickText, replyButtonsFallbackText, REPLY_BUTTON_PREFIX } from "./reply-buttons.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
@@ -151,7 +155,7 @@ import { runVisibilityCommand } from "./cross-instance-notice.js";
 import { installedChannel, isPrereleaseVersion, updateNoticeKey } from "./update-check.js";
 import { resolveInstalledAgend } from "./update-dispatch.js";
 import { resolveUpdateLaunch, watchUpdateLaunch } from "./update-launch.js";
-import { LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS } from "./login-controller.js";
+import { admitProfileLogin, LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS } from "./login-controller.js";
 import { runBeforeDeadline } from "./deadline.js";
 import { LoginWindowLock } from "./login-window-lock.js";
 import { handleSettingsRequest } from "./settings-api.js";
@@ -179,7 +183,7 @@ import { GENERAL_PAUSE_ERROR, isGeneralInstance } from "./general-instance.js";
 import { buildOrgChart } from "./web-org.js";
 import { CacheService, WINDOWS } from "./cache-service.js";
 import { runWebCommand } from "./web-commands.js";
-import { claudeProjectKey } from "./backend/claude-code.js";
+import { claudeConfigDirFor, claudeProjectKey } from "./backend/claude-code.js";
 import { sharedRolloutIndex } from "./rollout-index.js";
 import { mayUseTool, resolveToolSet, scheduleOpRefusal, toolForIpcType, toolRefusedMessage, } from "./tool-permissions.js";
 import { authorizeSession, decideWebGate, loadOrCreateWebToken, readWebToken } from "./web-auth.js";
@@ -189,7 +193,7 @@ import { localSessionPolicy, tokenEpoch, WebSessionStore } from "./web-session.j
 import { WebLoginCodes, LOGIN_CODE_TTL_MS } from "./web-login.js";
 import { CodeRequestLimiter, ReturningDevices } from "./web-returning-device.js";
 import { allowedHostNames, applyWebSecurityHeaders, hostnameOf, isHostAllowed, WEB_HOST_REJECTED_MESSAGE } from "./web-host-guard.js";
-import { createPreviewListener, previewAvailability, previewSettings } from "./web-preview.js";
+import { createPreviewListener, normalizeOrigin, previewAvailability, previewSettings } from "./web-preview.js";
 import { fleetLevelDifferences, fleetLevelSignature, appendedConnections } from "./fleet-level-config.js";
 import { checkSelfRestartAllowance, recordSelfRestartAttempt } from "./self-restart-limit.js";
 import { SecretStore } from "./secret-store.js";
@@ -199,10 +203,10 @@ 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 { credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
+import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.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";
-import { formatRestartProgressCompletion, RESTART_PROGRESS_TERMINAL_TIMEOUT_MS, RestartProgress, } from "./restart-progress.js";
+import { cleanupWatchVerdict, formatRestartProgressCompletion, RESTART_PROGRESS_TERMINAL_TIMEOUT_MS, RestartProgress, } from "./restart-progress.js";
 import { launchFullRestartHelper } from "./full-restart.js";
 import { SYSTEMD_RESTART_INDETERMINATE_EXIT_CODE } from "./service-restart-selection.js";
 import { collectRedundantInstanceDefaultPaths } from "./fleet-yaml-slim.js";
@@ -428,6 +432,8 @@ const CLI_ENV_FRESH_MS = 60 * 60 * 1000;
  * and hides exactly the newly released model the user opened `/model` to find.
  * The wait is announced before it starts, so it reads as progress, not a stall.
  */
+/** #1690: how long `/model` waits for the daemon's word on our own runtime switch (its dialog wait plus settling). */
+export const RUNTIME_SWITCH_RESULT_MS = 12_000;
 export const CLI_ENV_PROBE_DEADLINE_MS = 16_000;
 /**
  * How many CLIs may cold-start at once, from BOTH memory and cores.
@@ -731,6 +737,13 @@ export class FleetManager {
     updateProgressEditRunning = false;
     lastUpdateProgressText = null;
     updateCompletionTipText = null;
+    /**
+     * #1660: an adopted update whose retire outcome is still owed. The
+     * completion summary was (or will be) posted; this watch appends the
+     * cleanup outcome to the same receipt instead of letting stage edits
+     * clobber it — and refuses a receipt that no longer matches (checklist 3/5).
+     */
+    updateCleanupWatch = null;
     /** Injectable only to keep the chat→CLI reload hand-off deterministic in tests. */
     fullRestartLauncher = launchFullRestartHelper;
     eventLogPruneTimer = null;
@@ -750,8 +763,8 @@ export class FleetManager {
     memoryLogAt = null;
     memoryDebugAt = null;
     memoryLogLevel = null;
-    memoryNoticeAt = null;
-    memoryNoticeLevel = null;
+    /** #1685: the host_memory value the last status frame carried, so a change re-sends the frame. */
+    memoryIndicatorShown = null;
     // Mirror topic: buffer cross-instance messages, flush every 3s
     mirrorBuffer = [];
     mirrorTimer = null;
@@ -763,6 +776,8 @@ export class FleetManager {
     webChatStore = null;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     webFiles = new WebFileLedger();
+    /** #1682: the people seen on inbound messages (id → name), for the web chat's mention pills; bounded, in memory. */
+    seenUsers = new SeenUsers();
     webPrefsStore;
     /** #1665: the web preferences kept on the host (<home>/web-prefs.json), read on first use. */
     get webPrefs() {
@@ -1330,7 +1345,9 @@ export class FleetManager {
         // #926: a restart kills the turn that was working on a request, and a
         // resumed CLI does not pick it back up. Remind the owner once per restart.
         try {
-            outbox.remindReplyObligations(name, { reason: "restart", graceMs: 0, since: new Date() });
+            const now = new Date();
+            this.expireReplyObligations(now);
+            outbox.remindReplyObligations(name, { reason: "restart", graceMs: 0, now, since: now, restartId: daemonBootId });
         }
         catch (err) {
             this.logger.error({ err, owner: name }, "Could not persist the post-restart reply reminder");
@@ -1348,6 +1365,7 @@ export class FleetManager {
             return;
         const stateOf = (name) => this.daemons.get(name)?.getInstanceState();
         try {
+            this.expireReplyObligations(now);
             for (const name of this.daemons.keys()) {
                 if (stateOf(name) === "idle")
                     outbox.remindReplyObligations(name, { now, graceMs: REPLY_REMINDER_GRACE_MS, reason: "turn-ended" });
@@ -1359,6 +1377,15 @@ export class FleetManager {
             this.logger.error({ err }, "Reply-obligation sweep failed");
         }
     }
+    expireReplyObligations(now) {
+        const hours = this.fleetConfig?.defaults?.reply_obligation_ttl_hours;
+        const duration = typeof hours === "number" && hours > 0 && Number.isFinite(hours * 3_600_000)
+            ? hours * 3_600_000 : DEFAULT_REPLY_OBLIGATION_TTL_MS;
+        for (const row of this.deliveryOutbox.expireReplyObligations({ now, ttlMs: duration })) {
+            this.logger.info({ owner: row.ownerInstance, requester: row.requesterInstance,
+                correlationId: row.correlationId, lastAskedAt: row.lastAskedAt, expiredAt: row.expiredAt }, "Reply obligation expired");
+        }
+    }
     scheduleDeliveryOutboxPump(delayMs = 0) {
         if (!this.deliveryOutbox || this.shuttingDown || !this.deliveryOutbox.isOpen)
             return;
@@ -1598,6 +1625,14 @@ export class FleetManager {
             return Math.max(1, Math.min(20, explicit));
         return deriveSpawnConcurrency(Math.round(freemem() / (1024 * 1024)), cpus().length);
     }
+    /** #1685: "elevated" or "critical" while host memory pressure slows or holds new agents; otherwise null (an
+     *  unknown macOS reading — the advisory case — is unknown, so null too). */
+    hostMemoryIndicator() {
+        if (!this.memoryPressure)
+            return null;
+        const level = this.memoryPressure.snapshot().level;
+        return level === "elevated" || level === "critical" ? level : null;
+    }
     /** Separate cooldown: changing measurements must not create new text-throttle keys. */
     reportMemoryPressure(snapshot) {
         if (this.shuttingDown)
@@ -1608,6 +1643,12 @@ export class FleetManager {
             this.logger.debug({ hostMemory: snapshot }, "Host memory sample");
         }
         const changed = snapshot.level !== this.memoryLogLevel;
+        // #1685: the dashboard's indicator (the status frame's host_memory) is re-sent when it changes.
+        const indicator = this.hostMemoryIndicator();
+        if (indicator !== this.memoryIndicatorShown) {
+            this.memoryIndicatorShown = indicator;
+            this.emitSseEvent("status", this.getUiStatus());
+        }
         if (this.memoryPressure.advisoryOnly()) {
             // The sampler logs the unknown kernel value once per lifecycle; no warning/cooldown here.
             this.memoryLogLevel = snapshot.level;
@@ -1628,20 +1669,6 @@ export class FleetManager {
                     : "Host memory sample unavailable — slowing new CLI spawns");
         }
         this.memoryLogLevel = snapshot.level;
-        if (!snapshot.memory || snapshot.level === "unknown" || (!this.adapter && this.adapters.size === 0))
-            return;
-        const escalation = snapshot.level === "critical" && this.memoryNoticeLevel !== "critical";
-        if (!escalation && this.memoryNoticeAt !== null && now - this.memoryNoticeAt < 10 * 60_000)
-            return;
-        const size = (bytes) => bytes === null ? t("memory.unknown") : `${Math.round(bytes / 1024 / 1024)} MiB`;
-        const action = t(snapshot.level === "critical" ? "memory.holding" : "memory.slowing");
-        const text = this.memoryPressure.platform === "darwin"
-            ? t("memory.kernel_pressure", snapshot.memory.darwinPressureLevel ?? t("memory.unknown"), size(snapshot.memory.availableBytes), size(snapshot.memory.swapFreeBytes), action)
-            : t("memory.pressure", t(snapshot.memory.availableKind === "available" ? "memory.available" : "memory.free", size(snapshot.memory.availableBytes)), size(snapshot.memory.swapFreeBytes), action);
-        if (this.notifyFleetError(text, { throttle: false })) {
-            this.memoryNoticeAt = now;
-            this.memoryNoticeLevel = snapshot.level;
-        }
     }
     /** Wire the one fleet-wide storm into notification and recovery surfaces. */
     bindStormWindowEvents() {
@@ -1772,14 +1799,17 @@ export class FleetManager {
         // the next tunnel and says so, it does not block the fleet.
         this.announceToolPermissionsChange();
         this.tightenInstanceDirectories();
-        void reapStaleTunnel(this.dataDir)
-            .then(outcome => {
-            if (outcome.kind === "manual")
-                this.logger.warn({ tunnel: outcome }, manualCleanupMessage(outcome));
-            else if (outcome.kind === "reaped")
-                this.logger.info({ how: outcome.how, pid: outcome.pid }, "Reaped a leftover tunnel");
-        })
-            .catch(err => this.logger.warn({ err }, "Tunnel reaper failed"));
+        // #1723: the public link's preview tunnel keeps its own lease beside it; a leftover one is reaped the same way.
+        for (const leaseDir of [this.dataDir, join(this.dataDir, PUBLIC_PREVIEW_TUNNEL_DIR)]) {
+            void reapStaleTunnel(leaseDir)
+                .then(outcome => {
+                if (outcome.kind === "manual")
+                    this.logger.warn({ tunnel: outcome }, manualCleanupMessage(outcome));
+                else if (outcome.kind === "reaped")
+                    this.logger.info({ how: outcome.how, pid: outcome.pid }, "Reaped a leftover tunnel");
+            })
+                .catch(err => this.logger.warn({ err }, "Tunnel reaper failed"));
+        }
         // An existing installation has never written the setup marker — it predates
         // it — so `agend setup` would open a pre-fleet form for a fleet that plainly
         // exists. A fleet that just came up on a config with agents in it is proof
@@ -1802,7 +1832,13 @@ export class FleetManager {
         // We are the post-update fleet: the update is over by definition. Clearing
         // it here (rather than in the update command, which exits before the new
         // fleet is up) is what keeps the quiet window from outliving the restart.
-        clearUpdateMarker(this.dataDir);
+        // #1660 exception: an update still owing its retire outcome keeps its
+        // receipt until the cleanup watch resolves it — deleting it here is what
+        // lost the warning. Terminal stages are still cleared unconditionally.
+        const leftover = readUpdateProgress(this.dataDir)?.progress;
+        if (!(leftover?.cleanup === "pending" && leftover.stage !== "failed" && leftover.stage !== "complete")) {
+            clearUpdateMarker(this.dataDir);
+        }
         if (this.reloadPending)
             this.scheduleReconcile();
         void this.sweepOrphanedCancelButtons();
@@ -3310,6 +3346,9 @@ export class FleetManager {
      * the check and the act, so the channel's instance cannot be rebound to another bot in between.
      */
     async dispatchSlash(slash, adapterId, adapter) {
+        return withSpawnHoldReply(text => slash.respond(text), () => this.dispatchSlashCore(slash, adapterId, adapter));
+    }
+    async dispatchSlashCore(slash, adapterId, adapter) {
         // #1569: an alias (/web) is its command (/dashboard) from here on — the door, the table and the handler see one name.
         const data = { ...slash, command: canonicalCommand(slash.command) };
         const door = this.slashDoor(data, adapterId);
@@ -4684,7 +4723,13 @@ export class FleetManager {
         return { display: issued.display, expiresAt: issued.expiresAt, ttlMinutes: Math.round(LOGIN_CODE_TTL_MS / 60_000) };
     }
     tunnelPurposeLane = null;
+    previewTunnel = null;
     publicWebLink = null;
+    /** #1723: the public link's preview tunnel — a manager and lease of its own, never the fleet's one tunnel lane. */
+    getPreviewTunnel() {
+        return this.previewTunnel ??= new ManagedTunnel({ dataDir: join(this.dataDir, PUBLIC_PREVIEW_TUNNEL_DIR),
+            log: () => this.logger.warn("Public preview tunnel cleanup requires attention") });
+    }
     getTunnelLane() {
         return this.tunnelPurposeLane ??= new TunnelPurposeLane(new ManagedTunnel({ dataDir: this.dataDir,
             log: () => this.logger.warn("Managed tunnel cleanup requires attention") }));
@@ -4737,6 +4782,13 @@ export class FleetManager {
                     this.logger.warn("Public session revocation could not be saved; exposure remains closed");
             },
             log: (event, exposureId) => this.logger.info({ event, exposureId }, "Public web link"),
+            createPreview: ({ id, expiresAt, binary, protocol, dashboardOrigin, isCurrent }) => {
+                if (!publicPreviewWanted(this.fleetConfig?.web))
+                    return null;
+                return new PublicPreview({ exposureId: id, expiresAt, dashboardOrigin, isCurrent, manager: this.getPreviewTunnel(),
+                    provider: () => new CloudflaredProvider({ binaryName: binary, protocol }),
+                    log: event => this.logger.info({ event, exposureId: id }, "Public web link") });
+            },
             onCleanupUnconfirmed: (result, owner) => {
                 this.logger.warn({ pid: result.confirmed ? null : result.pid }, "Public web access closed; tunnel cleanup unconfirmed");
                 const world = this.worlds.get(owner.adapterId);
@@ -4769,6 +4821,16 @@ export class FleetManager {
             await owner.binding.sendText(owner.chatId, t("dashboard.menu_failed"), { threadId: owner.threadId }).catch(() => undefined);
         }
     }
+    /**
+     * #1686: build the Telegram deep-link that opens a DM with this bot pre-seeded with `/start web`.
+     * Returns null when no botUsername is known or the username fails Telegram's format validation.
+     */
+    tgStartWebUrl(adapterId) {
+        const username = this.worlds.get(adapterId)?.botUsername;
+        if (!username || !/^[A-Za-z0-9_]{5,32}$/.test(username))
+            return null;
+        return `https://t.me/${username}?start=web`;
+    }
     async sendLocalDashboard(data, adapterId) {
         if (this.shuttingDown || !this.hasFleetAdmins(adapterId) || !this.isFleetAdmin(data.userId, adapterId)) {
             await data.respond(t("not_authorized"));
@@ -4890,10 +4952,12 @@ export class FleetManager {
         const adapter = owner.binding;
         const status = this.getPublicWebStatus();
         const publicAllowed = publicLinkSettings(this.fleetConfig?.web).allowed;
+        const tgHint = adapter.type === "telegram" ? this.tgStartWebUrl(owner.adapterId) : null;
         const menuText = this.topicCommands.getDashboardText(false, !publicAllowed)
             + (publicAllowed ? "\n\n" + t("dashboard.public_risk") : "")
             + "\n" + t("dashboard.public_status", status.state, status.remainingSeconds ?? 0)
-            + (status.expiresAt ? t("dashboard.public_until", formatFleetTime(status.expiresAt)) : "");
+            + (status.expiresAt ? t("dashboard.public_until", formatFleetTime(status.expiresAt)) : "")
+            + (tgHint ? "\n" + t("dashboard.menu_tg_hint", tgHint) : "");
         const choices = [{ action: "local", label: t("dashboard.local") },
             ...(publicLinkSettings(this.fleetConfig?.web).allowed ? [{ action: "public", label: t("dashboard.public_open") }] : []),
             ...(status.state !== "closed" ? [{ action: "close", label: t("dashboard.public_close") }] : [])];
@@ -5036,7 +5100,11 @@ export class FleetManager {
             : owner.binding.type !== "discord" ? "dashboard.private_sent" : deliveredByDm ? "dashboard.private_sent_dm" : "dashboard.private_sent_here");
         await progress;
         await steps?.close(); // the last step edit has landed: the outcome cannot be overwritten by it
-        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, lastSteps ? renderPublicLinkProgress(lastSteps, performance.now(), outcome) : outcome, data.editClicked);
+        // #1686: attach the deep-link button on the failure outcome (Telegram only; Discord and the editClicked path ignore urlButtons).
+        const failUrlButtons = (!ok && owner.binding.type === "telegram")
+            ? (() => { const u = this.tgStartWebUrl(adapterId); return u ? [{ label: t("dashboard.start_web_label"), url: u }] : undefined; })()
+            : undefined;
+        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, lastSteps ? renderPublicLinkProgress(lastSteps, performance.now(), outcome) : outcome, data.editClicked, failUrlButtons);
         return true;
     }
     /** `/dashboard revoke`: sign out every browser and withdraw any unused code. */
@@ -5278,6 +5346,53 @@ export class FleetManager {
         setUpdateProgressStage(this.dataDir, "failed", { error: message });
     }
     /** The old fleet edits CLI install stages; the new fleet adopts the same message below. */
+    /**
+     * #1660: arm the post-completion cleanup watch and make sure its monitor
+     * actually runs. The new fleet adopts the receipt at boot but nothing else
+     * starts this timer on that path (Prism a) — without this, the owed
+     * outcome would sit in the marker unwatched. READY never waits for it.
+     */
+    armCleanupWatch(receipt, summary) {
+        this.updateCleanupWatch = { receipt, summary };
+        if (!this.updateProgressTimer)
+            this.startUpdateProgressMonitor();
+    }
+    /**
+     * #1660: append a recorded cleanup outcome to the adopted update message,
+     * then release the receipt — but only if this receipt still owns the
+     * marker. The await yields, so a newer receipt (e.g. a full-restart that
+     * landed mid-edit) must not be cleared or disturbed (Prism b).
+     */
+    async appendCleanupWarning(target, watch, warning, cleanupCommand) {
+        const text = formatRestartProgressCompletion("update", {
+            ...watch.summary,
+            warningText: warning,
+            warningCommand: cleanupCommand,
+        }, watch.receipt.startedAt);
+        const stopWatching = () => {
+            this.updateCleanupWatch = null;
+            if (this.updateProgressTimer)
+                clearInterval(this.updateProgressTimer);
+            this.updateProgressTimer = null;
+        };
+        if (text !== this.lastUpdateProgressText) {
+            const adapter = this.adapters.get(target.adapterId);
+            if (!adapter)
+                return; // retry on a later tick
+            await adapter.editMessage(target.chatId, target.messageId, text, target.threadId);
+            this.lastUpdateProgressText = text;
+        }
+        const verdict = cleanupWatchVerdict(readUpdateProgress(this.dataDir), watch.receipt);
+        if (verdict.action === "drop") {
+            // Someone else owns the marker now — leave it entirely alone.
+            this.updateCleanupWatch = null;
+            return;
+        }
+        if (verdict.action === "wait")
+            return; // not terminal; keep watching
+        clearUpdateMarker(this.dataDir);
+        stopWatching();
+    }
     startUpdateProgressMonitor(initialAdapter) {
         if (this.updateProgressTimer)
             clearInterval(this.updateProgressTimer);
@@ -5291,6 +5406,48 @@ export class FleetManager {
                 this.updateProgressTimer = null;
                 return;
             }
+            // #1660: the completion summary was already posted; only watch for
+            // the retire outcome owed to this exact receipt. Never stage-edit
+            // here (that would clobber the posted completion), and never touch a
+            // receipt that no longer matches (checklist 3/5).
+            const watch = this.updateCleanupWatch;
+            if (watch) {
+                const stopWatching = () => {
+                    this.updateCleanupWatch = null;
+                    if (this.updateProgressTimer)
+                        clearInterval(this.updateProgressTimer);
+                    this.updateProgressTimer = null;
+                };
+                const verdict = cleanupWatchVerdict(marker, watch.receipt);
+                if (verdict.action === "drop") {
+                    // Receipt gone or replaced (e.g. a later full-restart adopted the
+                    // marker): not ours — leave it to its own lifecycle, drop the watch.
+                    this.logger.info("[update] cleanup watch: marker receipt changed, dropping watch");
+                    this.updateCleanupWatch = null;
+                }
+                else if (verdict.action === "release") {
+                    // Done silent, or the updater died past the max age: release it.
+                    clearUpdateMarker(this.dataDir);
+                    stopWatching();
+                    return;
+                }
+                else if (verdict.action === "wait") {
+                    return;
+                }
+                else {
+                    this.updateProgressEditRunning = true;
+                    try {
+                        await this.appendCleanupWarning(marker.progress.target, watch, verdict.warning, verdict.cleanupCommand);
+                    }
+                    catch (err) {
+                        this.logger.warn({ err }, "[update] cleanup watch: failed to append warning, will retry");
+                    }
+                    finally {
+                        this.updateProgressEditRunning = false;
+                    }
+                    return;
+                }
+            }
             const target = marker.progress.target;
             const adapter = this.adapters.get(target.adapterId) ?? (initialAdapter?.id === target.adapterId ? initialAdapter : undefined);
             if (!adapter)
@@ -5381,7 +5538,11 @@ export class FleetManager {
         // 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.
-        this.lifecycle.primeAuthVerification(Object.values(fleet.instances).map(config => config.backend ?? fleet.defaults?.backend ?? "claude-code"));
+        this.lifecycle.primeAuthVerification(Object.values(fleet.instances).map(config => {
+            const backend = config.backend ?? fleet.defaults?.backend ?? "claude-code";
+            // #1699 follow-up: each instance's own login — a profile is probed with its own environment.
+            return { backend, profile: credentialHomeSpec(backend) ? instanceCredentialProfile(config, fleet.defaults, backend) : null };
+        }));
         // Start tmux control mode client for idle detection
         if (!this.controlClient) {
             this.controlClient = new TmuxControlClient(getTmuxSession(), 2000, this.logger);
@@ -5786,7 +5947,13 @@ export class FleetManager {
             const _require = createRequire(import.meta.url);
             const agendVersion = _require("../package.json").version ?? "unknown";
             await progressStart;
-            const progressCompleted = await startupProgress.finish({
+            // #1660: when the adopted update still owes its retire outcome, the
+            // completion posts without the warning and this same summary object is
+            // kept for the watch to append it to the same receipt later. Waiting
+            // for cleanup before READY would deadlock with the updater (it retires
+            // only after the restart returns), so READY and cleanup notification
+            // have separate lifecycles (review checklist 3/5).
+            const completionSummary = {
                 running: started,
                 total,
                 version: agendVersion,
@@ -5798,7 +5965,14 @@ export class FleetManager {
                         return tip ? this.formatTip(tip) : undefined;
                     })()
                     : undefined,
-            });
+            };
+            const progressCompleted = await startupProgress.finish(completionSummary);
+            if (pendingUpdateProgress && pendingProgressOperation === "update"
+                && pendingUpdateProgress.progress.cleanup === "pending") {
+                const receipt = updateReceiptOf(pendingUpdateProgress);
+                if (receipt)
+                    this.armCleanupWatch(receipt, completionSummary);
+            }
             if (!progressCompleted && fleet.channel?.group_id) {
                 let text;
                 if (pendingProgressOperation === "full-restart") {
@@ -5820,6 +5994,9 @@ export class FleetManager {
                     text = t("fleet.ready_with_failed", started, total, agendVersion, failedNames.join(", "))
                         + (pausedNames.length > 0 ? `\n⏸ Paused: ${pausedNames.join(", ")}` : "");
                 }
+                // #1660: a pending cleanup warning cannot be present yet (the updater
+                // retires only after the restart returns); the watch appends it to
+                // the adopted message when the outcome lands. Nothing to add here.
                 await this.sendFleetStartCompletionFallback(String(fleet.channel.group_id), text, generalThreadId != null ? String(generalThreadId) : undefined);
             }
             // After "fleet ready", so the notice is not the first thing people see of a restart.
@@ -6569,6 +6746,14 @@ export class FleetManager {
                         });
                     }
                 }
+                else if (msg.type === "runtime_switch_result") {
+                    // #1690: what our own runtime /model came to (the daemon answered claude's "Switch model?" or saw the result).
+                    const waiter = typeof msg.id === "string" ? this.runtimeSwitchWaiters.get(msg.id) : undefined;
+                    if (waiter) {
+                        this.runtimeSwitchWaiters.delete(msg.id);
+                        waiter(msg);
+                    }
+                }
                 else if (msg.type === "instance_state" || msg.type === "instance_state_response") {
                     this.cacheInstanceExecutionState(name, msg);
                     if (msg.type === "instance_state_response") {
@@ -7081,6 +7266,16 @@ export class FleetManager {
         });
     }
     async handleInboundMessage(msg) {
+        if (msg.isBotMessage)
+            return withSpawnHoldReply(undefined, () => this.handleInboundMessageCore(msg));
+        const adapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapters.get(msg.adapterId ?? "") ?? this.adapter;
+        return withSpawnHoldReply(text => adapter?.sendText(msg.chatId, text, { threadId: msg.threadId }) ?? Promise.resolve(), () => this.handleInboundMessageCore(msg));
+    }
+    async handleInboundMessageCore(msg) {
+        // #1682: who wrote, for the web chat's mention pills (a person, never one of the fleet's bots: those are named by
+        // the instance they belong to).
+        if (!msg.isBotMessage && msg.userId && msg.username)
+            this.seenUsers.record(msg.userId, msg.username);
         // Platform author identity is the authority. This runs before routing,
         // collab/commands/access/dedup and does not depend on any echo setting/ACK.
         const fleetBotIds = new Set();
@@ -7236,6 +7431,16 @@ export class FleetManager {
                 }
                 // Handle /start command
                 if (text === "/start" || text.startsWith("/start ")) {
+                    // #1686: intercept /start web before the ClassicBot admission flow runs.
+                    // /start alone already opens the DM for future bot-to-user messages — no further action needed.
+                    const requestedBackend = text.slice("/start".length).trim().split(/\s+/, 1)[0] || undefined;
+                    if (requestedBackend === "web" && isPrivateChat) {
+                        if (this.isFleetAdmin(msg.userId, msg.adapterId ?? "")) {
+                            await msgAdapter?.sendText(chatId, t("dashboard.start_web_ack"));
+                        }
+                        // Non-fleet-admins: /start alone is enough to open the DM channel; no further action.
+                        return;
+                    }
                     // All new starts, including explicit backend and later chooser callbacks,
                     // share validateClassicStart. Existing channels are recognized first.
                     const blocker = this.validateClassicStart(chatId, msg.userId, undefined, msg.adapterId);
@@ -7244,7 +7449,6 @@ export class FleetManager {
                         return;
                     }
                     const channelName = msg.username || chatId;
-                    const requestedBackend = text.slice("/start".length).trim().split(/\s+/, 1)[0] || undefined;
                     if (requestedBackend) {
                         // handleClassicStart binds the instance to this adapter authoritatively.
                         const reply = await this.handleClassicStart(chatId, channelName, msg.userId, undefined, msg.adapterId, requestedBackend);
@@ -9731,6 +9935,45 @@ export class FleetManager {
             return null;
         }
     }
+    /**
+     * #1682 GET /ui/mentions: names for the mention ids a page found in what it rendered — never a Discord request; in order:
+     * the fleet's bots (an instance's own bot is that instance's label: fleet.yaml, and the View profiles read from
+     * profiles.db, as the status frame does), the people seen on inbound messages, and the Discord adapters' caches
+     * (members, users, roles, channels).
+     */
+    webMentionNames(query) {
+        const bots = (q) => {
+            const u = Object.create(null);
+            if (!q.u.length)
+                return { u };
+            let own = new Map();
+            try {
+                own = this.ownBots();
+            }
+            catch { /* none known */ }
+            const profiles = profileIdentities(this.dataDir);
+            const rooms = new Map((this.classicChannels?.getAll() ?? []).map(ch => [ch.instanceName, ch]));
+            for (const [instance, connection] of own) {
+                const id = this.adapters.get(connection)?.getBotUserId?.();
+                if (!id || !q.u.includes(id))
+                    continue;
+                const cfg = Object.hasOwn(this.fleetConfig?.instances ?? {}, instance) ? this.fleetConfig.instances[instance] : undefined;
+                u[id] = resolveInstanceIdentity({ cfg, classic: rooms.get(instance), profile: profiles.get(instance) }).display_name || instance;
+            }
+            return { u };
+        };
+        const seen = (q) => {
+            const u = Object.create(null);
+            for (const id of q.u) {
+                const name = this.seenUsers.get(id);
+                if (name)
+                    u[id] = name;
+            }
+            return { u };
+        };
+        const caches = [...this.adapters.values()].filter(a => typeof a.mentionNames === "function").map(a => (q) => a.mentionNames(q));
+        return resolveMentions(query, [bots, seen, ...caches]);
+    }
     /** GET /ui/emojis: the custom emoji of every server the fleet's Discord bots are in (the Settings picker's cache). */
     async webEmojiList() {
         const adopted = [];
@@ -11174,6 +11417,48 @@ export class FleetManager {
         });
     }
     cacheService = null;
+    /**
+     * #1699: the credential profile an instance's CLI signs in with on `backend` — fleet.yaml's (with its defaults), or a
+     * ClassicBot room's launched or would-be login when the room runs that backend. Null: the backend's default login
+     * (also for a backend that has no profiles, where the option is ignored).
+     */
+    credentialProfileOf(name, backend) {
+        if (!credentialHomeSpec(backend))
+            return null;
+        const cfg = this.fleetConfig?.instances?.[name];
+        if (cfg)
+            return instanceCredentialProfile(cfg, this.fleetConfig?.defaults, backend);
+        const launched = this.daemons.get(name)?.getConfigSnapshot?.();
+        if (launched)
+            return (launched.backend ?? "claude-code") === backend ? profileName(profileOf(launched.backend_options, backend)) : null;
+        if (!this.classicChannels || this.classicChannels.getBackendByInstance(name, this.fleetConfig?.defaults?.backend) !== backend)
+            return null;
+        return profileName(this.classicChannels.getCredentialProfileByInstance(name, this.fleetConfig?.defaults));
+    }
+    /**
+     * #1699: the claude config dir an instance's CLI uses — its credential profile's, else exactly as before
+     * (CLAUDE_CONFIG_DIR or ~/.claude).
+     */
+    claudeConfigDirOf(name) {
+        const profile = this.credentialProfileOf(name, "claude-code");
+        return claudeConfigDirFor(profile ? credentialProfileHome(getAgendHome(), "claude-code", profile) : null);
+    }
+    /** The instances the cache analysis reads: fleet.yaml's, then the ClassicBot rooms (their workspace under the AgEnD home, their own backend). */
+    cacheInstances() {
+        const fleet = Object.entries(this.fleetConfig?.instances ?? {}).map(([name, cfg]) => ({
+            name, backend: this.backendNameOf(name), workingDirectory: cfg.working_directory, ledgerPath: join(this.getInstanceDir(name), "cache-ledger.json"),
+            claudeConfigDir: this.claudeConfigDirOf(name),
+        }));
+        const taken = new Set(fleet.map(i => i.name));
+        const classic = (this.classicChannels?.getAll() ?? []).filter(ch => !taken.has(ch.instanceName)).map(ch => ({
+            name: ch.instanceName,
+            backend: this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code",
+            workingDirectory: join(getAgendHome(), "workspaces", ch.instanceName),
+            ledgerPath: join(this.getInstanceDir(ch.instanceName), "cache-ledger.json"),
+            claudeConfigDir: this.claudeConfigDirOf(ch.instanceName),
+        }));
+        return [...fleet, ...new Map(classic.map(c => [c.name, c])).values()];
+    }
     /**
      * #1468: the prompt-cache expiry analysis for the web, per instance, over `window`. Read from each instance's
      * ledger as it is now; the first request starts the bounded, persisted catch-up over the transcripts
@@ -11182,20 +11467,7 @@ export class FleetManager {
     cacheReport(window) {
         const w = Object.prototype.hasOwnProperty.call(WINDOWS, window) ? window : "7d";
         this.cacheService ??= new CacheService({
-            // fleet.yaml's instances, then the ClassicBot rooms (their workspace under the AgEnD home, their own backend).
-            instances: () => {
-                const fleet = Object.entries(this.fleetConfig?.instances ?? {}).map(([name, cfg]) => ({
-                    name, backend: this.backendNameOf(name), workingDirectory: cfg.working_directory, ledgerPath: join(this.getInstanceDir(name), "cache-ledger.json"),
-                }));
-                const taken = new Set(fleet.map(i => i.name));
-                const classic = (this.classicChannels?.getAll() ?? []).filter(ch => !taken.has(ch.instanceName)).map(ch => ({
-                    name: ch.instanceName,
-                    backend: this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code",
-                    workingDirectory: join(getAgendHome(), "workspaces", ch.instanceName),
-                    ledgerPath: join(this.getInstanceDir(ch.instanceName), "cache-ledger.json"),
-                }));
-                return [...fleet, ...new Map(classic.map(c => [c.name, c])).values()];
-            },
+            instances: () => this.cacheInstances(),
             claudeProjectsDir: () => join(process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude"), "projects"),
             claudeKey: claudeProjectKey,
             codexSessionsDir: () => join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "sessions"),
@@ -11382,7 +11654,9 @@ export class FleetManager {
     }
     async retireNonceButtons(pending, messageId, text, 
     /** The click's own edit of a private prompt (AdapterCallbackData.editClicked); preferred over the prompt's. */
-    editClicked) {
+    editClicked, 
+    /** #1686: URL buttons to attach when editing the outcome (Telegram only; ignored when editClicked or retire is set). */
+    urlButtons) {
         this.webPromptGone(pending, text);
         try {
             const retire = editClicked ?? pending.retire;
@@ -11392,7 +11666,12 @@ export class FleetManager {
             }
             if (!pending.adapter.editMessageRemoveButtons)
                 throw new Error("adapter cannot remove prompt buttons");
-            await pending.adapter.editMessageRemoveButtons(pending.chatId, messageId, text, pending.threadId);
+            if (urlButtons) {
+                await pending.adapter.editMessageRemoveButtons(pending.chatId, messageId, text, pending.threadId, urlButtons);
+            }
+            else {
+                await pending.adapter.editMessageRemoveButtons(pending.chatId, messageId, text, pending.threadId);
+            }
         }
         catch (err) {
             // The action was already atomically consumed. An edit failure must not
@@ -12006,9 +12285,12 @@ export class FleetManager {
      * Backends with no remote login flow (opencode logs in from a terminal) get
      * no button — the alert's own wording already tells them what to run.
      */
-    async offerBackendLogin(targetInstance, backend) {
+    async offerBackendLogin(targetInstance, backend, profile) {
         if (!LOGIN_FLOWS[backend])
             return;
+        if (profile && !CHAT_PROFILE_LOGIN_BACKENDS.has(backend))
+            return; // that profile signs in on the host
+        const shown = profile ? t("login.profile_label", backend, profile) : backend;
         const adapterId = this.getInstanceAdapterId(targetInstance);
         const adapter = this.getAdapterForInstance(targetInstance);
         const chatId = this.getGroupIdForInstance(targetInstance);
@@ -12026,9 +12308,10 @@ export class FleetManager {
             adapterId,
             chatId,
             threadId,
-            message: t("login.offer", backend),
-            choices: [{ action: backend, label: t("login.offer_action", backend) }],
+            message: t("login.offer", shown),
+            choices: [{ action: backend, label: t("login.offer_action", shown) }],
             expiredText: t("buttons.stale"),
+            ...(profile ? { extra: { loginProfile: profile } } : {}),
         });
     }
     /** Consume a General assist button exactly once. */
@@ -12841,7 +13124,7 @@ export class FleetManager {
                 fleetConfig: () => this.fleetConfig,
                 isFleetAdmin: (userId, adapterId) => this.isFleetAdmin(userId, adapterId),
                 eventLog: () => this.eventLog,
-                recoverBackendInstances: backend => this.recoverBackendInstances(backend),
+                recoverBackendInstances: (backend, profile) => this.recoverBackendInstances(backend, undefined, profile ?? null),
                 claimWindow: backend => this.loginWindow.tryClaim("web", backend),
                 releaseWindow: claim => { this.loginWindow.release(claim); },
                 isClaimCurrent: claim => this.loginWindow.isCurrent(claim),
@@ -12850,11 +13133,12 @@ export class FleetManager {
                 reserveTunnel: owner => this.getTunnelLane().reserve("login", owner),
                 // Throws when the prompt cannot be posted: the controller tells the
                 // user so instead of leaving "Starting…" as the last word (#1133).
-                postButtons: async ({ prefix, instanceName, chat, message, choices, expiredText }) => {
+                postButtons: async ({ prefix, instanceName, chat, message, choices, expiredText, profile }) => {
                     await this.postNonceButtonPromptOrThrow({
                         prefix, alertType: "login", instanceName,
                         adapter: chat.adapter, adapterId: chat.adapterId, chatId: chat.chatId, threadId: chat.threadId,
                         message, choices, expiredText,
+                        ...(profile ? { extra: { loginProfile: profile } } : {}),
                     });
                 },
             });
@@ -13068,10 +13352,20 @@ export class FleetManager {
         // A removed backend (#1280) is neither installed nor signed into: say what replaces it.
         if (isRemovedBackend(wanted))
             return removedBackendMessage(wanted);
+        // #1699 part 2: a profile is admitted before anything is installed for it — a name that is not one, or a backend
+        // whose profiles sign in on the host, is refused here, not after an install it did not need.
+        if (opts.profile !== undefined) {
+            const admitted = admitProfileLogin(wanted, opts.profile);
+            if ("refusal" in admitted)
+                return admitted.refusal;
+            opts = { ...opts, profile: admitted.profile };
+        }
         if (BACKEND_INSTALLATION_INFO[wanted] && !this.isCliInstalled(wanted)) {
             const flow = LOGIN_FLOWS[wanted];
             this.recordLoginFlow(wanted, flow && flow.remoteLogin !== "unsupported" ? "install_then_login" : "install_only", chat.userId);
-            return this.startInstallSession(wanted, chat);
+            return opts.profile !== undefined
+                ? this.startInstallSession(wanted, chat, { profile: opts.profile })
+                : this.startInstallSession(wanted, chat);
         }
         this.recordLoginFlow(wanted, "login", chat.userId);
         return this.launchSignIn(backendArg, chat, opts);
@@ -13160,7 +13454,9 @@ export class FleetManager {
      * cancelled: they are still coming back, and are reported as pending so the
      * message can say so instead of implying failure.
      */
-    async recoverBackendInstances(backend, deadlineMs = POST_LOGIN_RECOVERY_DEADLINE_MS) {
+    async recoverBackendInstances(backend, deadlineMs = POST_LOGIN_RECOVERY_DEADLINE_MS, 
+    /** #1699 part 2: the login just signed in — a profile, or null for the backend's default one. */
+    profile = null) {
         const woken = [];
         const restarted = [];
         const pending = [];
@@ -13168,6 +13464,9 @@ export class FleetManager {
         for (const name of this.configuredBackendInstanceNames()) {
             if (this.backendNameOf(name) !== backend)
                 continue;
+            // Only the instances on the login that changed: another profile's (or the default's) credentials did not.
+            if (this.credentialProfileOf(name, backend) !== profile)
+                continue;
             const status = this.getInstanceStatus(name);
             if (status !== "paused" && status !== "running")
                 continue;
@@ -13205,14 +13504,16 @@ export class FleetManager {
         if (claimed === "consumed")
             return true;
         const { entry, action: backend } = claimed;
-        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("login.starting_backend", backend));
-        const text = await this.startLoginSession(backend, {
+        const profile = entry.loginProfile;
+        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("login.starting_backend", profile ? t("login.profile_label", backend, profile) : backend));
+        const chat = {
             adapter: entry.adapter,
             adapterId: entry.adapterId,
             chatId: entry.chatId,
             threadId: entry.threadId,
             userId: data.userId,
-        });
+        };
+        const text = profile ? await this.startLoginSession(backend, chat, { profile }) : await this.startLoginSession(backend, chat);
         if (text)
             await this.postPromptOutcome(entry, text);
         return true;
@@ -13226,11 +13527,13 @@ export class FleetManager {
             return true;
         const { entry, action } = claimed;
         const backend = entry.instanceName;
+        const profile = entry.loginProfile;
+        const shown = profile ? t("login.profile_label", backend, profile) : backend;
         if (action === "cancel") {
-            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("login.cancelled", backend));
+            await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("login.cancelled", shown));
             return true;
         }
-        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("login.starting_backend", backend));
+        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, t("login.starting_backend", shown));
         const text = await this.startLoginSession(backend, {
             adapter: entry.adapter,
             adapterId: entry.adapterId,
@@ -13242,6 +13545,7 @@ export class FleetManager {
             tokenPresent: action === "go-relogin" || action === "go-relogin-tunnel",
             // The consent is the button itself: only the explicit "Open public link" actions carry it.
             tunnel: action === "go-tunnel" || action === "go-relogin-tunnel",
+            ...(profile ? { profile } : {}),
         });
         if (text)
             await this.postPromptOutcome(entry, text);
@@ -13269,7 +13573,7 @@ export class FleetManager {
     /** An install that succeeded, between its success line and the sign-in it hands over to (#1131). */
     installHandoff = null;
     /** Start a CLI install session. Caller enforces admin. */
-    async startInstallSession(backendArg, chat) {
+    async startInstallSession(backendArg, chat, signIn = {}) {
         const backend = LOGIN_BACKEND_ALIASES[backendArg.toLowerCase()] ?? backendArg.toLowerCase();
         const info = BACKEND_INSTALLATION_INFO[backend];
         if (!info)
@@ -13353,7 +13657,8 @@ export class FleetManager {
                 // without a click.
                 // launchSignIn, not startLoginSession: if the new binary were still
                 // not visible, startLoginSession would route straight back to an install.
-                const next = await this.launchSignIn(backend, chat, {}).catch((err) => t("login.failed", backend, err?.message ?? String(err)));
+                // A `/login <backend> <profile>` that had to install first signs that profile in, not the default login.
+                const next = await this.launchSignIn(backend, chat, signIn.profile !== undefined ? { profile: signIn.profile } : {}).catch((err) => t("login.failed", backend, err?.message ?? String(err)));
                 if (next) {
                     await chat.adapter.sendText(chat.chatId, next, { threadId: chat.threadId })
                         .catch(err => this.logger.warn({ err, backend }, "Could not post the sign-in step after an install"));
@@ -13461,8 +13766,16 @@ export class FleetManager {
             return;
         }
         const backend = String(data.options?.backend ?? "").trim();
+        // #1699 part 2: a supplied profile is never dropped — a blank one is refused by the admission like any bad name,
+        // and one without a backend is refused rather than becoming the default login's picker.
+        const profileSupplied = data.options?.profile !== undefined && data.options?.profile !== null;
+        const profile = profileSupplied ? String(data.options?.profile).trim() : undefined;
+        if (profileSupplied && !backend) {
+            await data.respond(t("login.profile_needs_backend"));
+            return;
+        }
         if (backend) {
-            const text = await this.startLoginSession(backend, chat);
+            const text = profile !== undefined ? await this.startLoginSession(backend, chat, { profile }) : await this.startLoginSession(backend, chat);
             await data.respond(text ?? t("login.confirm_posted"));
             return;
         }
@@ -14319,6 +14632,49 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         });
     }
     /** Paste raw text directly to a classic instance's CLI (no [user:] wrapping) */
+    /** #1690: our own runtime switches awaiting the daemon's outcome, by id. */
+    runtimeSwitchWaiters = new Map();
+    /**
+     * #1690: type `/model <model>` and wait for what it came to: the daemon answers claude's "Switch model?" for us (Yes
+     * when it names this model, No otherwise) or sees claude's own result. Null when it could not be sent; a timeout is
+     * "not confirmed".
+     */
+    runRuntimeModelSwitch(instanceName, model) {
+        const ipc = this.instanceIpcClients.get(instanceName);
+        if (!ipc)
+            return Promise.resolve({ outcome: "not_sent" });
+        const id = `switch-${randomUUID()}`;
+        return new Promise(resolve => {
+            const timer = setTimeout(() => { this.runtimeSwitchWaiters.delete(id); resolve({ outcome: "not_confirmed" }); }, RUNTIME_SWITCH_RESULT_MS);
+            timer.unref?.();
+            this.runtimeSwitchWaiters.set(id, result => { clearTimeout(timer); resolve(result); });
+            const sent = ipc.send({ type: "raw_paste", content: `/model ${model}`, runtime_switch: { id, kind: "model", requested: model } });
+            if (!sent) {
+                clearTimeout(timer);
+                this.runtimeSwitchWaiters.delete(id);
+                resolve({ outcome: "not_sent" });
+                return;
+            }
+            this.logger.info({ instanceName, model }, "Runtime model switch sent");
+        });
+    }
+    /**
+     * #1690: the names claude-code is known to accept, for checking `/model <name>` BEFORE it is typed — claude itself
+     * accepts any string ("Set model to opsu"), and its "Switch model?" then names the typo. Static aliases (with [1m]),
+     * the cached account catalog, the configured model; without a cached catalog, any `claude-…` id too (cannot check).
+     */
+    claudeModelKnown(instanceName, model) {
+        const aliases = ["default", "sonnet", "opus", "haiku", "opusplan", "Fable"];
+        const api = (this.readCliEnv("claude-code")?.apiModels ?? []).map(m => m.id);
+        const configured = this.fleetConfig?.instances[instanceName]?.model ?? this.fleetConfig?.defaults?.model;
+        const lower = model.trim().toLowerCase();
+        const bare = lower.replace(/\[1m\]$/, "");
+        const known = aliases.some(a => a.toLowerCase() === bare)
+            || api.some(id => id.toLowerCase() === lower || `${id.toLowerCase()}[1m]` === lower)
+            || (typeof configured === "string" && configured.toLowerCase() === lower)
+            || (api.length === 0 && /^claude-[a-z0-9][a-z0-9.-]*(\[1m\])?$/.test(lower));
+        return { known, names: [...aliases, ...api.filter(id => !id.endsWith("[1m]")).slice(0, 12)] };
+    }
     pasteRawToClassicInstance(instanceName, text) {
         const ipc = this.instanceIpcClients.get(instanceName);
         if (!ipc) {
@@ -14918,7 +15274,16 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             try {
                 // Asked again after the progress edit awaited above: the instance may have moved, or the admin lost admin.
                 result = this.menuClickStillCurrent(pending.instanceName, data.userId, pending.channelId, adapterId, pending.adapterChatId)
-                    ? await this.applyEffort(pending.instanceName, level) : t("menu.click_stale");
+                    ? await withSpawnHoldReply(async (text) => {
+                        if (pending.adapter && pending.adapterChatId) {
+                            if (progressMsgId)
+                                await pending.adapter.editMessage(pending.adapterChatId, progressMsgId, text, pending.adapterThreadId);
+                            else
+                                await pending.adapter.sendText(pending.adapterChatId, text, { threadId: pending.adapterThreadId });
+                        }
+                        else
+                            await pending.respond(text);
+                    }, () => this.applyEffort(pending.instanceName, level)) : t("menu.click_stale");
             }
             catch (err) {
                 this.logger.error({ err, instance: pending.instanceName, level }, "Effort switch failed");
@@ -15243,7 +15608,16 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             try {
                 // Asked again after the progress edit awaited above: the instance may have moved, or the admin lost admin.
                 result = this.menuClickStillCurrent(pending.instanceName, data.userId, pending.channelId, adapterId, pending.adapterChatId)
-                    ? await this.applyModel(pending.instanceName, model) : t("menu.click_stale");
+                    ? await withSpawnHoldReply(async (text) => {
+                        if (pending.adapter && pending.adapterChatId) {
+                            if (progressMsgId)
+                                await pending.adapter.editMessage(pending.adapterChatId, progressMsgId, text, pending.adapterThreadId);
+                            else
+                                await pending.adapter.sendText(pending.adapterChatId, text, { threadId: pending.adapterThreadId });
+                        }
+                        else
+                            await pending.respond(text);
+                    }, () => this.applyModel(pending.instanceName, model)) : t("menu.click_stale");
             }
             catch (err) {
                 this.logger.error({ err, instance: pending.instanceName, model }, "Model switch failed");
@@ -15377,21 +15751,34 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         catch { /* default restart */ }
         const warn = isModelCompatible(backendName, model) ? "" : t("model.pattern_warning", model, backendName);
+        // #1690: claude takes any name; a mistyped one would be "switched" to and fail the next turn. Checked first —
+        // nothing is typed or saved for an unknown one.
+        if (backendName === "claude-code") {
+            const check = this.claudeModelKnown(instanceName, model);
+            if (!check.known)
+                return t("model.unknown_name", model, check.names.join(", "));
+        }
         if (strategy === "runtime" && !this.instanceIpcClients.get(instanceName)) {
             return `${warn}${t("effort.not_running", instanceName)}`;
         }
+        // #1690: claude-code's runtime switch reports what it came to; the model is saved unless claude was told No.
+        if (strategy === "runtime" && backendName === "claude-code") {
+            const result = await this.runRuntimeModelSwitch(instanceName, model);
+            if (result.outcome === "mismatch")
+                return `${warn}${t("model.switch_mismatch", instanceName, result.shown, model)}`;
+            if (result.outcome === "not_sent")
+                return `${warn}${t("model.switch_not_sent", instanceName, model)}`;
+            const persistedNow = this.persistInstanceModel(instanceName, model);
+            if (!persistedNow)
+                return `${warn}${t("model.persist_failed", instanceName)}`;
+            const head = result.outcome === "switched"
+                ? (result.confirmed ? t("model.switch_confirmed", instanceName, model) : t("model.runtime_success", instanceName, model))
+                : t("model.switch_unconfirmed", instanceName, model, Math.round(RUNTIME_SWITCH_RESULT_MS / 1000));
+            return `${warn}${head}${this.effortSuffix(instanceName)}`;
+        }
         // Persist either way: a runtime switch must survive the next respawn too,
         // or the instance silently reverts to the CLI default after a fleet restart.
-        let persisted = false;
-        if (this.fleetConfig?.instances[instanceName]) {
-            this.fleetConfig.instances[instanceName].model = model;
-            this.saveFleetConfig();
-            persisted = true;
-        }
-        else if (this.classicChannels?.setModelByInstance(instanceName, model)) {
-            persisted = true;
-        }
-        if (!persisted)
+        if (!this.persistInstanceModel(instanceName, model))
             return `${warn}${t("model.persist_failed", instanceName)}`;
         if (strategy === "runtime") {
             this.pasteRawToClassicInstance(instanceName, `/model ${model}`);
@@ -15400,6 +15787,15 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         await this.restartSingleInstance(instanceName);
         return `${warn}${t("model.restart_success", instanceName, model)}${this.effortSuffix(instanceName)}`;
     }
+    /** Save an instance's model (fleet.yaml, or its ClassicBot channel). False when neither holds it. */
+    persistInstanceModel(instanceName, model) {
+        if (this.fleetConfig?.instances[instanceName]) {
+            this.fleetConfig.instances[instanceName].model = model;
+            this.saveFleetConfig();
+            return true;
+        }
+        return this.classicChannels?.setModelByInstance(instanceName, model) === true;
+    }
     /**
      * The trailing "Current effort: …" line for a /model reply.
      *
@@ -15510,6 +15906,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     /** Handle Discord's required static slash choice, warning before a likely startup failure. */
     async handleClassicStartSlash(data, adapterId) {
+        return withSpawnHoldReply(text => data.respond(text), () => this.handleClassicStartSlashCore(data, adapterId));
+    }
+    async handleClassicStartSlashCore(data, adapterId) {
         const requestedBackend = typeof data.options?.backend === "string" ? data.options.backend : undefined;
         if (!requestedBackend) {
             // beta.31 made this option required. Discord can briefly retain the old
@@ -15626,7 +16025,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // failure. The selected backend is still attempted as requested.
         if (warning)
             await pending.complete(warning, pending.messageId);
-        const reply = await this.handleClassicStart(pending.channelId, pending.channelName, pending.userId, pending.guildId, pending.adapterId, selectedBackend);
+        const reply = await withSpawnHoldReply(text => pending.complete(text, pending.messageId), () => this.handleClassicStart(pending.channelId, pending.channelName, pending.userId, pending.guildId, pending.adapterId, selectedBackend));
         await pending.complete(warning ? `${warning}\n\n${reply}` : reply, pending.messageId);
     }
     /** Start a classic channel instance with lightweight config */
@@ -18092,14 +18491,25 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     return;
                 }
                 (async () => {
+                    let held = false;
                     try {
                         const topicMode = this.fleetConfig?.channel?.mode === "topic";
-                        await this.startInstance(name, config, topicMode ?? false, "fleet-topic", true);
+                        await withSpawnHoldReply(async (message) => {
+                            held = true;
+                            res.writeHead(202, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({ held: true, message, instance: name }));
+                        }, () => this.startInstance(name, config, topicMode ?? false, "fleet-topic", true));
                         this.emitSseEvent("status", this.getUiStatus());
+                        if (held)
+                            return;
                         res.writeHead(200);
                         res.end(JSON.stringify({ ok: true }));
                     }
                     catch (err) {
+                        if (held) {
+                            this.logger.error({ err, name }, "Held start failed");
+                            return;
+                        }
                         res.writeHead(500);
                         res.end(JSON.stringify({ error: `Start failed: ${err.message}` }));
                     }
@@ -18114,15 +18524,24 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 const name = decodeURIComponent(req.url.slice("/restart/".length));
                 this.logger.info({ name }, "Instance restart requested via HTTP");
                 (async () => {
+                    let held = false;
                     try {
-                        await this.restartSingleInstance(name, { explicit: true });
+                        await withSpawnHoldReply(async (message) => {
+                            held = true;
+                            res.writeHead(202, { "Content-Type": "application/json" });
+                            res.end(JSON.stringify({ held: true, message, instance: name }));
+                        }, () => this.restartSingleInstance(name, { explicit: true }));
                         this.logger.info({ name }, "Instance restarted");
                         this.emitSseEvent("status", this.getUiStatus());
+                        if (held)
+                            return;
                         res.writeHead(200);
                         res.end(JSON.stringify({ restarted: name }));
                     }
                     catch (err) {
                         this.logger.error({ err, name }, "Instance restart failed");
+                        if (held)
+                            return;
                         const status = err.message.includes("not found") ? 404 : 500;
                         res.writeHead(status);
                         res.end(JSON.stringify({ error: `Restart failed: ${err.message}` }));
@@ -18291,7 +18710,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.logger.warn({ health_port: requestedPort }, "No port for the HTML preview listener (health_port is the highest port) — set web.preview_port; previews are off");
             return;
         }
-        const listener = createPreviewListener({ settings, healthPort: boundPort, config: this.fleetConfig });
+        const listener = createPreviewListener({ settings, healthPort: boundPort, config: this.fleetConfig,
+            // #1723: with a web.preview_origin, the open public link's dashboard frames this listener's preview too.
+            extraOrigins: () => { const o = settings.origin ? this.publicWebLink?.openDashboardOrigin() : null; return o ? [o] : []; } });
         this.previewListener = listener;
         listener.server.on("error", (err) => {
             if (this.previewListener !== listener)
@@ -18340,6 +18761,37 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             decided.reason = "Previews are not available on this fleet right now.";
         return { ...decided, boot: listener ? listener.bootId : null };
     }
+    /**
+     * #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.
+     */
+    publicPreviewForUi(exposureId, dashboardOrigin) {
+        const web = this.fleetConfig?.web;
+        const off = (code, reason, extra = {}) => ({ dashboardOrigin, previewOrigin: null, reason, code, boot: null, frameSrc: null, ...extra });
+        if (web?.preview === false)
+            return off("fleetOff", "Previews are turned off for this fleet (web.preview: false).");
+        if (web?.preview_on_public_link === false)
+            return off("publicLink", "Previews are off on the public link (web.preview_on_public_link: false).");
+        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 (!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` };
+        }
+        const status = this.publicWebLink?.previewStatus(exposureId) ?? null;
+        if (!status)
+            return off("publicLink", "Previews are not offered on this public link.");
+        // The page may load before the preview tunnel has a host: it frames the quick-tunnel wildcard, and only ever the
+        // origin /ui/preview-status names (the preview side's exact frame-ancestors is the boundary).
+        if (status.state === "starting")
+            return off("publicLinkStarting", "Preview is starting…", { frameSrc: PUBLIC_PREVIEW_FRAME_SRC });
+        if (status.state === "failed")
+            return off("publicLinkPreviewFailed", `Previews are unavailable on this public link (${status.reason}).`, { detail: status.reason });
+        return { dashboardOrigin, previewOrigin: status.origin, reason: null, code: null, boot: status.boot, frameSrc: PUBLIC_PREVIEW_FRAME_SRC };
+    }
     getUiStatus() {
         return measureSyncWork("fleet.uiStatus", () => this.getUiStatusSync());
     }
@@ -18438,6 +18890,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             connections: (this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : [])).length,
             // #1665: the host preferences' revision — a page that has another re-reads /ui/prefs (no values in this frame).
             prefs_rev: this.webPrefs.rev(),
+            // #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(),
         };
     }
 }