@songsid/agend 2.2.0-beta.1 → 2.2.0-beta.11

package/dist/fleet-manager.js

@@ -1,21 +1,26 @@
+import { humanOwnerObjectId, webHumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsBaselines } from "./settings-baseline.js";
 import { SettingsConfirmationStore } from "./settings-confirmation.js";
 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 { trackWebServer } from "./web-server-drain.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";
 import { measureSyncWork } from "./sync-work-attribution.js";
 import { RuntimeCpuProfiler, ProfileBusyError, profileDuration } from "./runtime-cpu-profile.js";
 import { ProfileControlServer } from "./profile-control.js";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, constants as fsConstants } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, constants as fsConstants, closeSync } from "node:fs";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
@@ -27,20 +32,21 @@ 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, sameUpdateMarker, setUpdateProgressStage, updateMarkerIdentity, 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";
 import { MemoryPressure } from "./memory-pressure.js";
 import { replyDedupText, ReplyDeduper } from "./reply-dedup.js";
 import { isMap, isScalar, parseDocument } from "yaml";
+import { kiroLogGate } from "./kiro-log-gate.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
 import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiImageUrl, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
 import { isProbeableRouteTarget } from "./fleet-context.js";
-import { loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
+import { getEffectiveInstanceDefaults, loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
 import { EventLog } from "./event-log.js";
 import { binaryProbe } from "./binary-probe.js";
 import { classifySqliteOpenError } from "./sqlite-open-errors.js";
@@ -51,13 +57,16 @@ import { startEventLoopWatch } from "./event-loop-watch.js";
 import { TmuxManager } from "./tmux-manager.js";
 import { AccessManager } from "./channel/access-manager.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
+import { usesChannelAddress } from "./channel/mcp-tools.js";
 import { formatFleetTime } from "./tz-utils.js";
 import { createAdapter } from "./channel/factory.js";
 import { isWebChannelEcho, WEB_ECHO_PREFIX } from "./web-channel-echo.js";
 import { TelegramAdapter } from "./channel/adapters/telegram.js";
 import { createBackend } from "./backend/factory.js";
 import { readEffortMetadata } from "./backend/effort-metadata.js";
-import { CLI_ENV_TTL_MS, isModelCompatible, SYSINFO_BACKEND_IDS, UnsupportedCliError } from "./backend/types.js";
+import { codexEffort, flagEffort } from "./backend/launch-effort.js";
+import { codexMetadataHomes, readCodexModelEffortLevels, resolveCodexLaunchModel } from "./backend/codex-metadata.js";
+import { CLI_ENV_TTL_MS, isModelCompatible, resolveBinary, SYSINFO_BACKEND_IDS, UnsupportedCliError } from "./backend/types.js";
 import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
@@ -73,8 +82,9 @@ import { RoutingEngine } from "./routing-engine.js";
 import { InstanceLifecycle, SupersededStartError, BACKEND_INSTALLATION_INFO, checkBinaryInstalled, } from "./instance-lifecycle.js";
 import { TopicArchiver } from "./topic-archiver.js";
 import { StatuslineWatcher } from "./statusline-watcher.js";
-import { outboundHandlers } from "./outbound-handlers.js";
-import { DeliveryOutbox } from "./delivery-outbox.js";
+import { applyInstanceConfigPatch, outboundHandlers } from "./outbound-handlers.js";
+import { backendArgs, backendStep, joinBackendArgs, modelNameCarried, planDisplay } from "./backend-command.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
@@ -126,12 +136,21 @@ export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
     return tasks;
 }
 import { handleWebRequest, broadcastSseEvent, SSE_HEARTBEAT_MS } from "./web-api.js";
+import { LogService } from "./log-service.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 { WEB_NAME_FALLBACK, safeWebName, validateWebName, webNameInUse, webPersonKey } from "./web-profile.js";
 import { ReplyButtonStore, parseReplyButtons, replyButtonClickText, replyButtonsFallbackText, REPLY_BUTTON_PREFIX } from "./reply-buttons.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
+import { parsePoll } from "./reply-polls.js";
 import { publicAttachment, sweepOrphanedUploads, WebFileLedger } from "./web-upload.js";
+import { REPLY_FILES_MAX_BYTES, snapshotReplyFile, sweepReplySnapshots, webFilesDir } from "./web-reply-files.js";
 import { handleViewRequest, isViewPath, profileIdentities, resolveInstanceIdentity } from "./view-api.js";
+import { downloadStickerImage } from "./channel/sticker-download.js";
+import { WebImageCache, imageMimeForFile, WEB_IMAGE_MAX_AGE_MS, WEB_IMAGE_MAX_BYTES, WEB_IMAGE_RETRY_MS } from "./web-images.js";
+import { accentColor, avatarFor, ownBotConnections } from "./instance-avatar.js";
 import { envFileKeys } from "./token-env-name.js";
 import { discordGeneralChannelId } from "./discord-general.js";
 import { parseEnvText } from "./env-file.js";
@@ -145,8 +164,8 @@ import { canonicalCommand, commandSpec, decideCommand, ruleFor } from "./command
 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 { resolveUpdateLaunch, openUpdateLog, updateLogPath, watchUpdateLaunch } from "./update-launch.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";
@@ -156,11 +175,12 @@ import { describeSignalSource, recordInternalRequest, withOrigin } from "./fleet
 import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
 import { ClassicChannelManager, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
-import { validateFleetConfig } from "./config-validator.js";
+import { KNOWN_BACKENDS, validateFleetConfig } from "./config-validator.js";
 import { isRemovedBackend, removedBackendMessage } from "./backend/removed.js";
 import { presentationState, interactionSummary, sameInteractionOwner } from "./interaction-observation.js";
 import { readLastInboundAt } from "./daemon.js";
 import { clearPausedMarker, readPausedAt, readPauseReason, writePausedMarker } from "./pause-marker.js";
+import { readBackgroundWorkEndedMarker } from "./background-work-ended.js";
 import { DEFAULT_WARM_OVERFLOW, WakeCoordinator } from "./wake-coordinator.js";
 import { TargetQueueWorker } from "./target-queue-worker.js";
 import { resolveDeliveryWorkerMode } from "./types.js";
@@ -174,17 +194,17 @@ 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";
 import { bypassesWebGate, handleAuthRequest, serveSigninPage } from "./auth-api.js";
 import { isWebPageNavigation } from "./web-shell-routes.js";
-import { tokenEpoch, WebSessionStore } from "./web-session.js";
+import { localSessionPolicy, tokenEpoch, WebSessionStore } from "./web-session.js";
 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";
@@ -194,10 +214,11 @@ 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, 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";
-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";
@@ -248,6 +269,10 @@ export function isOrphanInstanceWindowName(name) {
 /** Retry cadence for retiring a cancel button whose delete failed (e.g. a DC
  * forum thread the bot momentarily can't reach). 3 retries × 5min = 15min. */
 const CANCEL_BTN_RETRY_INTERVAL_MS = 5 * 60_000;
+/** #1753: a carried conversation this large is logged as a warning (it is still carried). */
+const CARRY_LARGE_BYTES = 256 * 1024 * 1024;
+/** #1742: how long after a Telegram /web that could not reach an admin privately a bare /start counts as /start web. */
+const TG_WEB_START_WINDOW_MS = 10 * 60_000;
 const CANCEL_BTN_MAX_RETRIES = 3;
 /** Backstop: every 5min, retire a button whose instance has gone idle. Catches
  * buttons no clear trigger reached (e.g. a scheduled/HTTP turn that never called
@@ -333,6 +358,7 @@ const CLASSIC_BACKEND_SELECTION_TIMEOUT_MS = 60_000;
 const CLASSIC_BACKEND_CALLBACK_PREFIX = "classic-backend:";
 const MODEL_SELECT_CALLBACK_PREFIX = "model-select:";
 const EFFORT_SELECT_CALLBACK_PREFIX = "effort-select:";
+const BACKEND_SELECT_CALLBACK_PREFIX = "backend-select:";
 const INTERACTIVE_ASSIST_CALLBACK_PREFIX = "interactive-assist:";
 const EXIT_RESTART_CALLBACK_PREFIX = "exit-restart:";
 /** #1386: how long a paused instance's marker reason is reused before it is read again (transitions drop it at once). */
@@ -356,6 +382,7 @@ const WEB_MIRRORED_PROMPT_PREFIXES = new Set([
 const WEB_ONLY_REPLY_SINK = {
     type: "web",
     supportsReplyButtons: true, // #1266: the web chat shows a reply's buttons itself
+    supportsPolls: true, // #1823: …and a poll (its pages are told; there is nothing to edit)
     sendText: async () => ({ chatId: "web", messageId: newWebMessageId() }),
     sendFile: async () => ({ chatId: "web", messageId: newWebMessageId() }),
 };
@@ -423,6 +450,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.
@@ -610,6 +639,11 @@ export class FleetManager {
     webChannelEchoGuards = new Map();
     /** instanceName → restart currently executing; concurrent callers join it. */
     restartsInFlight = new Map();
+    /**
+     * #1753: each in-flight restart's stop → start gap — the conversation carry it will run there (its own, or one a later
+     * caller joined with before the gap), and whether the gap has been reached.
+     */
+    restartGaps = new Map();
     /**
      * Delayed automatic retries for instances whose startup failed. Before this a
      * failed start was logged once and the instance stayed `stopped` until an
@@ -645,6 +679,8 @@ export class FleetManager {
     /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
     pendingEffortSelects = new Map();
     pendingModelSelects = new Map();
+    /** #1806: in-flight /backend steps, keyed by nonce (see handleBackendSelection). */
+    pendingBackendSelects = new Map();
     /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
     pendingNonceButtons = new Map();
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
@@ -714,6 +750,7 @@ export class FleetManager {
     collabInstances = new Set();
     // Health endpoint
     healthServer = null;
+    healthServerDrain = null;
     /** #1306: the preview listener (health_port + 1 by default), and whether it is listening. */
     previewListener = null;
     previewListening = false;
@@ -726,6 +763,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;
@@ -745,8 +789,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;
@@ -758,6 +802,93 @@ export class FleetManager {
     webChatStore = null;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     webFiles = new WebFileLedger();
+    /** #1770: per instance, its last web reply still copying its files — the next one is shown after it, in order. */
+    webReplyOrder = new Map();
+    /** #1770: an instance's web-files byte cap (a field, so a test can make it small). */
+    webReplyMaxBytes = REPLY_FILES_MAX_BYTES;
+    /** #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. */
+    /**
+     * #1827: a web person as agents and chats see them. Signed in as an account (a sign-in code DMed to it): that
+     * account's user id — still `via web`, and only for recognition — and the name they chose, else their account's name
+     * at sign-in (made safe). Otherwise (an `agend web` session): "web-user", as before, under a name the operator may set.
+     * Names are checked again now: one an instance or bot has taken since reads as the next choice down.
+     */
+    webPerson(owner) {
+        const key = webPersonKey(owner);
+        let profile = null;
+        try {
+            profile = this.webPrefs.profile(key);
+        }
+        catch (err) {
+            this.logger.warn({ err: err.message }, "Web profile unavailable");
+        }
+        const reserved = (n) => this.webNameReserved(n);
+        const own = profile?.name !== undefined ? webNameInUse(profile.name, reserved) : WEB_NAME_FALLBACK;
+        const chosen = own !== WEB_NAME_FALLBACK;
+        const platformName = owner ? safeWebName(profile?.platformName, reserved) : undefined;
+        return {
+            key, bound: !!owner,
+            userId: owner ? owner.userId : WEB_NAME_FALLBACK,
+            // A poll ballot is the account's — the same key its votes on the platform have — or the operator's.
+            voterKey: owner ? `${owner.adapterId}:${owner.userId}` : "web:operator",
+            name: chosen ? own : platformName ?? WEB_NAME_FALLBACK,
+            set: chosen,
+            ...(platformName !== undefined ? { platformName } : {}),
+        };
+    }
+    /** #1827: set (null: clear — back to their account's name) a web person's own name; validated in full. */
+    setWebPersonName(owner, raw) {
+        let name = null;
+        if (raw !== null) {
+            const v = validateWebName(raw, (n) => this.webNameReserved(n));
+            if (!v.ok)
+                return { ok: false, status: 400, error: v.error };
+            name = v.name;
+        }
+        const w = this.webPrefs.setProfileName(webPersonKey(owner), name);
+        return w.ok ? { ok: true, person: this.webPerson(owner) } : { ok: false, status: w.status, error: w.error };
+    }
+    /** #1827 (auth-api): a sign-in as this account — its display name then is the web name it starts with. */
+    noteWebSignIn(account) {
+        if (account.username)
+            this.webPrefs.setPlatformName(webPersonKey(account), account.username);
+    }
+    /**
+     * #1827: a name that belongs to something here — an instance (or ClassicBot room), its display name, a bot. On the web
+     * send path: it never throws (a lookup that fails reserves nothing; the name was checked in full when it was set).
+     */
+    webNameReserved(lowered) {
+        try {
+            return this.webNameTaken(lowered);
+        }
+        catch {
+            return false;
+        }
+    }
+    webNameTaken(lowered) {
+        const low = (s) => (typeof s === "string" ? s.normalize("NFC").toLocaleLowerCase("en-US") : "");
+        for (const [name, cfg] of Object.entries(this.fleetConfig?.instances ?? {})) {
+            if (low(name) === lowered || low(cfg.display_name) === lowered)
+                return true;
+        }
+        for (const ch of this.classicChannels?.getAll() ?? [])
+            if (low(ch.instanceName) === lowered || low(ch.displayName) === lowered)
+                return true;
+        for (const w of this.worlds.values())
+            if (w.botUsername && low(w.botUsername) === lowered)
+                return true;
+        return false;
+    }
+    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, {
+            exists: (name) => Object.hasOwn(this.fleetConfig?.instances ?? {}, name)
+                || (this.classicChannels?.getAll() ?? []).some((ch) => ch.instanceName === name),
+        }));
+    }
     /**
      * Read from disk on every access rather than cached at startup: `agend
      * web-token rotate` runs in a separate process, and a cached copy would keep
@@ -1099,6 +1230,8 @@ export class FleetManager {
             mayClick: (set, userId) => this.mayAnswerReplyButtons(set.instance, set.adapterId, userId),
             deliver: (set, button, by) => this.deliverReplyButtonChoice(set, button, by),
             publish: (instance, view) => this.emitSseEvent("reply_buttons", { instance, buttons: view }),
+            admitResults: (set, key, text) => this.admitPollResults(set, key, text),
+            monotonic: () => performance.now(),
             logger: this.logger,
             setTimer: (fn, ms) => { const h = setTimeout(fn, ms); h.unref?.(); return h; },
             clearTimer: (h) => clearTimeout(h),
@@ -1107,6 +1240,21 @@ export class FleetManager {
         return this.replyButtonsCtl;
     }
     replyButtonsStore = null;
+    /**
+     * #1823: a closed poll's results go to its instance through the delivery outbox, as a system notice keyed by the
+     * poll: durable (held until the instance can take it) and admitted once, however often this is asked. Addressed to
+     * the poll's chat, so the instance's answer (the right option, the scores) goes there.
+     */
+    admitPollResults(set, key, text) {
+        this.ensureDeliveryOutbox();
+        const outbox = this.deliveryOutbox;
+        if (!outbox)
+            return false;
+        outbox.admitSystemNotice(set.instance, key, text, new Date(), {
+            chatId: set.chatId, threadId: set.threadId || undefined, adapterId: set.adapterId === "web" ? undefined : set.adapterId,
+        });
+        return true;
+    }
     /**
      * #1266: who may answer a reply's buttons on a platform — whoever may message that instance there: in a ClassicBot
      * room anyone there (as a typed message), elsewhere someone the sending connection lets speak (#754/#1148), never a
@@ -1147,7 +1295,7 @@ export class FleetManager {
         const reactions = this.pendingReactionsMeta(set.instance);
         let accepted = false;
         try {
-            accepted = (await this.deliverToInstance(set.instance, {
+            accepted = (await this.deliverHumanToInstance(set.instance, {
                 type: "fleet_inbound",
                 content,
                 targetSession: set.instance,
@@ -1156,7 +1304,7 @@ export class FleetManager {
                     thread_id: set.threadId, adapter_id: inbound.adapterId, source: inbound.source,
                     ...reactions.meta,
                 },
-            })) !== false;
+            }, by.humanOrigin, button.label)) !== false;
         }
         finally {
             // Both false and throw reopen the choice in the controller. Finish the
@@ -1215,8 +1363,13 @@ export class FleetManager {
             if (event.deliveryId && (event.state === "failed" || event.state === "uncertain")) {
                 const row = outbox.get(event.deliveryId);
                 if (row && row.kind !== "delivery_outcome_notice" && row.kind !== "post_restart_outcome_notice") {
-                    const notice = t(`delivery.fleet_${row.state}`, row.targetInstance, row.operationId, row.deliveryId);
-                    this.logger.error({ deliveryId: row.deliveryId, operationId: row.operationId, target: row.targetInstance, state: row.state }, notice);
+                    // #1647: the cause goes in the log (the notice points there), and a silent schedule's paste says what it is.
+                    const silent = isSilentScheduleDelivery(row);
+                    const notice = silent
+                        ? t(`delivery.fleet_${row.state}_silent_schedule`, row.targetInstance, row.operationId, row.deliveryId, row.lastError ?? "unknown")
+                        : t(`delivery.fleet_${row.state}`, row.targetInstance, row.operationId, row.deliveryId);
+                    this.logger.error({ deliveryId: row.deliveryId, operationId: row.operationId, target: row.targetInstance, state: row.state,
+                        cause: row.lastError, ...(silent ? { silentSchedule: true } : {}) }, notice);
                     this.notifyFleetError(notice);
                 }
             }
@@ -1270,11 +1423,25 @@ export class FleetManager {
             deliveryId: admitted.delivery.deliveryId,
             state: admitted.delivery.state,
             duplicate: !admitted.inserted,
+            kind: admitted.delivery.kind,
         };
     }
     queryDurableDeliveryStatus(callerInstance, selector) {
         this.ensureDeliveryOutbox();
-        return this.deliveryOutbox.queryStatusForInstance(callerInstance, selector);
+        const page = this.deliveryOutbox.queryStatusForInstance(callerInstance, selector);
+        // #1641: a sender that sees only `queued` cannot tell "next in line" from "the target is stuck": say which.
+        return {
+            ...page,
+            items: page.items.map(item => (item.state === "queued" || item.state === "retry_wait")
+                ? { ...item, waiting_reason: this.deliveryWaitingReason(item.target_instance) }
+                : item),
+        };
+    }
+    /** #1641: why a target is not taking queued work right now, or null when nothing known holds it. */
+    deliveryWaitingReason(target) {
+        if (this.lifecycle.isPaused(target))
+            return t("delivery.hold_state", "paused");
+        return this.daemons.get(target)?.notAcceptingReason?.() ?? null;
     }
     getDaemonBootId(instanceName) {
         return this.daemons.get(instanceName)?.bootId;
@@ -1298,7 +1465,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");
@@ -1316,6 +1485,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" });
@@ -1327,6 +1497,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;
@@ -1566,6 +1745,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)
@@ -1576,6 +1763,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;
@@ -1596,20 +1789,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() {
@@ -1730,7 +1909,7 @@ export class FleetManager {
     isPlannedRestart() {
         return this.shuttingDown || isUpdateInProgress(this.dataDir);
     }
-    finishStartup() {
+    finishStartup(bootUpdateMarker = null) {
         this.startupComplete = true;
         this.startNeedsYou();
         // Resolve whatever a previous run — or a setup host that crashed — left
@@ -1740,14 +1919,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
@@ -1767,14 +1949,33 @@ export class FleetManager {
         for (const settled of this.applyJobs.settleAfterRestart()) {
             this.logger.info({ jobId: settled.id }, "Settings apply job settled by fleet restart");
         }
-        // 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);
+        this.clearSettledUpdateMarker(bootUpdateMarker);
         if (this.reloadPending)
             this.scheduleReconcile();
         void this.sweepOrphanedCancelButtons();
     }
+    /**
+     * 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.
+     * #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.
+     * #1735: and while the watch is armed it owns the marker — even if the outcome landed after the completion posted
+     * (a launchd kickstart or a detached restart returns at once, so it can land at any point of the boot): the watch
+     * appends it, then clears.
+     * #1737 review: and only the marker this boot adopted. One written since — a `/restart full` or a new `/update`
+     * landing while this boot's completion was still being edited — belongs to its writer and is left alone.
+     */
+    clearSettledUpdateMarker(bootUpdateMarker) {
+        if (this.updateCleanupWatch)
+            return;
+        const current = updateMarkerIdentity(this.dataDir);
+        if (current && !sameUpdateMarker(current, bootUpdateMarker))
+            return;
+        const leftover = readUpdateProgress(this.dataDir)?.progress;
+        if (leftover?.cleanup === "pending" && leftover.stage !== "failed" && leftover.stage !== "complete")
+            return;
+        clearUpdateMarker(this.dataDir);
+    }
     // ── ArchiverContext bridge ────────────────────────────────────────────
     lastActivityMs(name) {
         return this.lastActivity.get(name) ?? 0;
@@ -2129,10 +2330,15 @@ export class FleetManager {
             this.failUpdateProgress(t("not_authorized"));
             return;
         }
+        const logPath = updateLogPath(this.dataDir);
+        const ts = new Date().toISOString();
+        const logFd = openUpdateLog(logPath, `--- /update ${ts} ---`);
         const child = spawn(launch.command, launch.args, {
-            detached: true, stdio: "ignore", env: withOrigin(origin),
+            detached: true, stdio: ["ignore", logFd ? logFd.fd : "ignore", logFd ? logFd.fd : "ignore"], env: withOrigin(origin),
         });
-        watchUpdateLaunch(child, message => this.failUpdateProgress(message));
+        if (logFd)
+            closeSync(logFd.fd); // parent closes its copy; the child's fd stays open
+        watchUpdateLaunch(child, message => this.failUpdateProgress(message), logFd ? logPath : undefined, logFd?.offset, installed.agend);
         child.unref();
     }
     async handleProfileSlash(data, adapterId) {
@@ -2558,6 +2764,8 @@ export class FleetManager {
             startsFresh: !backendChanged && credentialSwitchStartsFresh(backend),
             from: profileKey(launched),
             to: profileKey(next),
+            ...(!backendChanged && launched.state !== "invalid" && next.state !== "invalid"
+                ? { carry: { backend, from: profileName(launched), to: profileName(next) } } : {}),
         };
     }
     /** `[instance, effective backend, credential profile]` for everything that is
@@ -2592,6 +2800,55 @@ export class FleetManager {
         return this.classicChannels?.getAll().some(channel => channel.instanceName === name) ?? false;
     }
     /** #1523 N2: a ClassicBot room's own summary for its Details page (classicBot.yaml), or null. */
+    /** #1218: the Log tab's on-demand service — made on first use; with `web.log_tab` off it answers off and does nothing. */
+    logService = null;
+    get log() {
+        return this.logService ??= new LogService({
+            enabled: () => this.fleetConfig?.web?.log_tab === true,
+            known: (name) => Object.prototype.hasOwnProperty.call(this.fleetConfig?.instances ?? {}, name) || this.classicRoomFor(name) !== null,
+            source: (name) => this.logSource(name),
+            events: (name, limit) => (this.eventLog?.query({ instance: name, limit }) ?? []),
+            emit: (event, data) => this.emitSseEvent(event, data),
+        });
+    }
+    /** #1218: GET /ui/steps — an instance's steps, read on demand (null: no such instance). */
+    logSteps(name, q) { return this.log.steps(name, q); }
+    /**
+     * #1218: where an instance's steps are read from, resolved only when its Log asks: the transcript its daemon follows
+     * now; for claude-code, also the path its statusline last named (so a stopped instance's Log still shows its last
+     * work). kiro: fleet events with the reason its history is not read (kiro-log-gate.ts); other backends have no
+     * transcript AgEnD can read.
+     */
+    logSource(name) {
+        const instances = this.fleetConfig?.instances ?? {};
+        const config = Object.prototype.hasOwnProperty.call(instances, name) ? instances[name] : undefined;
+        const backend = config?.backend ?? (config ? null : this.classicRoomFor(name)?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
+        const live = this.lifecycle.daemons.get(name)?.logTranscriptPath() ?? null;
+        if (backend === "claude-code") {
+            let path = live;
+            if (!path) {
+                try {
+                    path = JSON.parse(readFileSync(join(this.getInstanceDir(name), "statusline.json"), "utf-8")).transcript_path ?? null;
+                }
+                catch {
+                    path = null;
+                }
+                if (typeof path !== "string" || !path)
+                    path = null;
+            }
+            return { backend, path, format: "claude", ...(path ? {} : { reason: "no_transcript" }) };
+        }
+        if (backend === "codex")
+            return { backend, path: live, format: "codex", ...(live ? {} : { reason: "not_running" }) };
+        if (backend === "kiro-cli") {
+            // #1218 PR4: events only until the launch's root and the current conversation are both proven (kiro-log-gate.ts);
+            // the reason names which proof is missing. With today's proofs the gate never opens, and nothing is read for kiro:
+            // the reader is bound to an admitted launch when the proofs arrive (#849 root, #1789 current conversation).
+            const gate = kiroLogGate(this.lifecycle.daemons.get(name)?.logLaunch() ?? null);
+            return { backend, path: null, format: null, reason: gate.open ? "kiro_session_unobservable" : gate.reason };
+        }
+        return { backend, path: null, format: null, reason: "unsupported" };
+    }
     classicRoomFor(name) {
         const ch = this.classicChannels?.getAll().find(channel => channel.instanceName === name);
         if (!ch)
@@ -2893,7 +3150,7 @@ export class FleetManager {
         const queued = this.ipcWaitTails.get(instanceName);
         if (!queued) {
             const ipc = this.instanceIpcClients.get(instanceName);
-            if (ipc?.connected && ipc.send(payload))
+            if (ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
                 return true;
         }
         const attempt = (queued ?? Promise.resolve())
@@ -2928,7 +3185,7 @@ export class FleetManager {
             // Re-read every round: a reconnect replaces the IpcClient object entirely,
             // so a cached reference would stay dead forever.
             const ipc = this.instanceIpcClients.get(instanceName);
-            if (ipc?.connected && ipc.send(payload))
+            if (ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
                 return true;
             if (Date.now() >= deadline) {
                 throw new Error(`Instance '${instanceName}' IPC is unavailable`);
@@ -2963,7 +3220,8 @@ export class FleetManager {
      * or a rebound adapter is never posted through a stale route. A copy
      * already in flight may still land late — the contract permits that.
      */
-    async sendClassicWebEcho(instance, text) {
+    /** `sender` (#1827): the web person's name, as the room log records them ("web-user" when none). */
+    async sendClassicWebEcho(instance, text, sender = WEB_NAME_FALLBACK) {
         const guard = this.webChannelEchoGuards.get(instance);
         const handled = new Set();
         let posted = 0;
@@ -2994,7 +3252,7 @@ export class FleetManager {
                 if (!adapter?.sendText)
                     continue;
                 await adapter.sendText(entry.channelId, text, { format: "text", allowedMentions: { parse: [] } });
-                ClassicChannelManager.logMessage(instance, "web-user", text, new Date());
+                ClassicChannelManager.logMessage(instance, sender, text, new Date());
                 posted++;
             }
             catch (err) {
@@ -3003,13 +3261,38 @@ export class FleetManager {
         }
         return posted;
     }
-    reserveWebChannelEcho(instanceName, sendEcho) {
+    /**
+     * #1666: a delivered web chat message starts the same cancel/progress lifecycle in the instance's topic as a platform
+     * inbound (afterUserInboundDelivered): the same bubble, ticker and retire rules. Not its ✅ tracking — the web message
+     * id is no platform message, and the echo is the fleet's own post. The web send calls this on the echo's lane.
+     */
+    startWebChatProgress(instanceName) {
+        if (this.shuttingDown)
+            return Promise.resolve();
+        return this.sendCancelButton(instanceName);
+    }
+    /**
+     * `copy: false` (#1666/#1668): an entry that is not a copy of a message — the web send's Cancel/progress bubble. It
+     * keeps its place in the order, but the lane's copy rules do not apply to it: its 5 s budget starts when its turn
+     * starts (waiting behind a slow echo is not its delay), its own timeout only releases the lane (the copies queued
+     * behind it are not "behind an ambiguous copy"), and another entry's timeout never drops it. A copy reserved while
+     * any non-copy is still open starts its own budget when the last of them finishes: a slow bubble is no copy's delay,
+     * however far back the copy is. And a timeout only ever drops copies reserved AFTER the entry that timed out — with
+     * deferred budgets, deadlines no longer grow with the order, so that rule is stated, not implied (#1668 r3).
+     */
+    reserveWebChannelEcho(instanceName, sendEcho, opts = {}) {
+        const copy = opts.copy !== false;
         const epoch = this.getDeliveryEpoch(instanceName);
-        const deadlineAt = performance.now() + 5_000;
+        const queued = this.webChannelEchoTails.get(instanceName);
+        // The last open non-copy ahead of this copy: its budget starts when that one finishes.
+        const nonCopyAhead = copy && (queued?.nonCopiesOpen ?? 0) > 0 ? queued?.lastNonCopyDone : undefined;
+        let deadlineAt = copy && !nonCopyAhead ? performance.now() + 5_000 : Number.POSITIVE_INFINITY;
         let decide;
         const admission = new Promise(resolve => { decide = resolve; });
-        const queue = this.webChannelEchoTails.get(instanceName)
+        const queue = queued
             ?? { tail: Promise.resolve(), pending: new Set() };
+        const seq = queue.nextSeq ?? 0;
+        queue.nextSeq = seq + 1;
         const previous = queue.tail;
         let resolveDone;
         const tail = new Promise(resolve => { resolveDone = resolve; });
@@ -3020,6 +3303,8 @@ export class FleetManager {
             if (done)
                 return;
             done = true;
+            if (!copy)
+                queue.nonCopiesOpen = Math.max(0, (queue.nonCopiesOpen ?? 0) - 1);
             clearTimeout(timer);
             queue.pending.delete(entry);
             if (guard && this.webChannelEchoGuards.get(instanceName) === guard) {
@@ -3027,7 +3312,7 @@ export class FleetManager {
             }
             resolveDone();
         };
-        const entry = { started: false, drop: () => {
+        const entry = { seq, started: false, copy, drop: () => {
                 this.logger.warn({ instanceName }, "Queued web channel echo dropped after ordering timeout");
                 finish();
             } };
@@ -3037,14 +3322,16 @@ export class FleetManager {
             expired = true;
             this.logger.warn({ instanceName, inFlight: entry.started }, "Web channel echo ordering timed out");
             finish();
-            // Do not post copies that were queued behind an ambiguous platform send.
-            for (const pending of queue.pending)
-                if (!pending.started)
-                    pending.drop();
+            // Do not post copies that were queued behind an ambiguous platform send. A non-copy that timed out was no copy
+            // at all (nothing behind it is ambiguous), and a non-copy is never dropped as one.
+            if (copy)
+                for (const pending of queue.pending)
+                    if (pending.seq > seq && !pending.started && pending.copy)
+                        pending.drop();
         };
         const checkDeadline = () => {
-            if (done)
-                return;
+            if (done || deadlineAt === Number.POSITIVE_INFINITY)
+                return; // a non-copy's budget has not started yet
             const remaining = deadlineAt - performance.now();
             if (remaining <= 0)
                 expire();
@@ -3053,8 +3340,19 @@ export class FleetManager {
         };
         queue.pending.add(entry);
         queue.tail = tail;
+        if (!copy) {
+            queue.nonCopiesOpen = (queue.nonCopiesOpen ?? 0) + 1;
+            queue.lastNonCopyDone = tail;
+        }
         this.webChannelEchoTails.set(instanceName, queue);
         checkDeadline();
+        // Registered before the admission below (which waits on `previous`, itself after the non-copy ahead), so the budget
+        // is set by the time that runs.
+        if (nonCopyAhead)
+            void nonCopyAhead.then(() => { if (!done) {
+                deadlineAt = performance.now() + 5_000;
+                checkDeadline();
+            } });
         void Promise.all([previous, admission]).then(([, accepted]) => {
             if (done)
                 return;
@@ -3063,11 +3361,15 @@ export class FleetManager {
                 return;
             }
             // A delayed timer callback must not admit an already expired copy.
-            if (performance.now() >= deadlineAt) {
+            if (copy && performance.now() >= deadlineAt) {
                 expire();
                 return;
             }
             entry.started = true;
+            if (!copy) {
+                deadlineAt = performance.now() + 5_000;
+                checkDeadline();
+            }
             guard = { epoch, deadlineAt };
             this.webChannelEchoGuards.set(instanceName, guard);
             let request;
@@ -3102,6 +3404,101 @@ export class FleetManager {
     instanceLaunchSupportsSteer(instanceName) {
         return this.daemons.get(instanceName)?.launchSupportsSteer();
     }
+    humanReceiptDaemons = new WeakSet();
+    /** Cached FM + lifecycle + Daemon + tmux owner; unknown ownership grants nothing. */
+    humanReceiptOwner(instanceName, daemon = this.daemons.get(instanceName)) {
+        try {
+            if (this.shuttingDown || !daemon || this.daemons.get(instanceName) !== daemon)
+                return null;
+            const epoch = this.lifecycle.epochOf(instanceName);
+            const owner = daemon.captureHumanReceiptOwner();
+            if (!Number.isSafeInteger(epoch) || !owner)
+                return null;
+            return JSON.stringify([this.managerBootId, epoch, this.getDeliveryEpoch(instanceName), humanOwnerObjectId(daemon), owner]);
+        }
+        catch {
+            return null;
+        }
+    }
+    listenForHumanReceipt(instanceName, daemon) {
+        // Lazy initialization also supports narrow prototype-based integration fixtures.
+        this.humanReceiptDaemons ??= new WeakSet();
+        if (this.humanReceiptDaemons.has(daemon))
+            return;
+        this.humanReceiptDaemons.add(daemon);
+        daemon.on("human_receipt_result", (result) => {
+            try {
+                this.deliveryOutbox?.settleHumanReceipt(result.receipt_id, instanceName, result.owner_key, result.proof, this.humanReceiptOwner(instanceName, daemon));
+            }
+            catch (err) {
+                this.logger.error({ err, instanceName }, "Could not persist human delivery evidence");
+            }
+        });
+    }
+    /** Evidence-only admission. Bots/system/agent payloads have no trusted origin. */
+    humanReceiptPayload(instanceName, payload, origin, originalBody) {
+        if (!origin || !this.deliveryOutbox)
+            return payload;
+        const row = this.deliveryOutbox.createHumanReceipt({ targetInstance: instanceName, originalBody,
+            origin: { ...origin }, inputKind: String(payload.type), managerBootId: this.managerBootId });
+        return { ...payload, meta: { ...(payload.meta ?? {}),
+                human_receipt_id: row.receipt_id, verification_id: row.message_id } };
+    }
+    /** Bind at the actual IPC send, after all wake/reconnect waits. No human retry lane. */
+    bindHumanReceiptPayload(instanceName, payload) {
+        const meta = payload.meta;
+        if (!meta?.human_receipt_id || !this.deliveryOutbox)
+            return payload;
+        const daemon = this.daemons.get(instanceName);
+        const owner = this.humanReceiptOwner(instanceName, daemon);
+        if (!daemon || !owner) {
+            this.deliveryOutbox.markHumanReceiptUncertain(meta.human_receipt_id, instanceName);
+            return payload;
+        }
+        this.listenForHumanReceipt(instanceName, daemon);
+        const daemonOwner = daemon.captureHumanReceiptOwner();
+        const wire = daemon.humanReceiptWire(String(payload.content ?? ""), meta, String(payload.type));
+        const row = this.deliveryOutbox.bindHumanReceipt(meta.human_receipt_id, instanceName, owner, wire, this.managerBootId);
+        if (!daemonOwner || this.humanReceiptOwner(instanceName, daemon) !== owner)
+            throw new Error("Human delivery ownership changed");
+        // /raw retains exact bytes and never acquires a positive verification capability.
+        if (payload.type === "raw_paste" || String(payload.content ?? "").startsWith("/raw ")) {
+            this.deliveryOutbox.markHumanReceiptUncertain(row.receipt_id, instanceName);
+            return payload;
+        }
+        return { ...payload, meta: { ...meta, human_owner_key: owner, human_daemon_owner: daemonOwner, human_wire_sha256: row.wire_sha256 } };
+    }
+    async deliverHumanToInstance(instanceName, payload, origin, originalBody, options) {
+        const admitted = this.humanReceiptPayload(instanceName, payload, origin, originalBody);
+        const id = admitted.meta?.human_receipt_id;
+        let sent = false;
+        try {
+            const result = options ? await this.deliverToInstance(instanceName, admitted, options) : await this.deliverToInstance(instanceName, admitted);
+            sent = result !== false;
+            return result;
+        }
+        finally {
+            if (!sent && id)
+                this.deliveryOutbox?.markHumanReceiptUncertain(id, instanceName);
+        }
+    }
+    /** Synchronous steer/btw handoff, using the same evidence and owner binding. */
+    sendHumanControl(instanceName, payload, origin, originalBody) {
+        const ipc = this.instanceIpcClients.get(instanceName);
+        if (this.shuttingDown || !ipc?.connected)
+            return false;
+        const admitted = this.humanReceiptPayload(instanceName, payload, origin, originalBody);
+        const id = admitted.meta?.human_receipt_id;
+        let sent = false;
+        try {
+            sent = ipc.send(this.bindHumanReceiptPayload(instanceName, admitted));
+            return sent;
+        }
+        finally {
+            if (!sent && id)
+                this.deliveryOutbox?.markHumanReceiptUncertain(id, instanceName);
+        }
+    }
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     async deliverToInstance(instanceName, payload, options = {}) {
         const deliveryEpoch = this.getDeliveryEpoch(instanceName);
@@ -3234,6 +3631,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);
@@ -3291,7 +3691,7 @@ export class FleetManager {
                 userId: data.userId,
                 username,
                 source: "discord",
-                timestamp: new Date(),
+                timestamp: new Date(), adapterId, humanOrigin: data.humanOrigin, humanOriginalBody: text,
             });
         }
         else if (data.command === "save") {
@@ -3315,6 +3715,9 @@ export class FleetManager {
         else if (data.command === "model") {
             await this.handleModelSlash(data, adapterId);
         }
+        else if (data.command === "backend") {
+            await this.handleBackendSlash(data, adapterId);
+        }
         else if (data.command === "clear") {
             await this.handleClearSlash(data, adapterId);
         }
@@ -3408,7 +3811,7 @@ export class FleetManager {
                 await data.respond(result.durable ? t("dashboard.revoked", result.count) : t("dashboard.revoked_not_durable", result.count));
             }
             else {
-                const owner = this.dashboardOwner(data.userId, adapterId, data.channelId);
+                const owner = this.dashboardOwner(data.userId, adapterId, data.channelId, undefined, data.username);
                 if (!owner) {
                     await this.sendLocalDashboard(data, adapterId);
                     return;
@@ -3436,7 +3839,8 @@ export class FleetManager {
                 await data.respond(t("classic.no_agent"));
                 return;
             }
-            const steerText = String(data.options?.message ?? "").trim();
+            const originalSteerText = String(data.options?.message ?? "");
+            const steerText = originalSteerText.trim();
             if (!steerText) {
                 await data.respond(t("steer.usage"));
                 return;
@@ -3446,7 +3850,7 @@ export class FleetManager {
             // rerouting the instance's replies to the slash context.
             const result = this.topicCommands.sendSteer(name, steerText, {
                 chatId: "", messageId: "", username: data.username ?? "user",
-                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord", humanOrigin: data.humanOrigin, humanOriginalBody: originalSteerText,
             });
             await data.respond(result);
         }
@@ -3456,14 +3860,15 @@ export class FleetManager {
                 await data.respond(t("classic.no_agent"));
                 return;
             }
-            const btwText = String(data.options?.message ?? "").trim();
+            const originalBtwText = String(data.options?.message ?? "");
+            const btwText = originalBtwText.trim();
             if (!btwText) {
                 await data.respond(t("btw.usage"));
                 return;
             }
             const result = this.topicCommands.sendBtw(name, btwText, {
                 chatId: "", messageId: "", username: data.username ?? "user",
-                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord", humanOrigin: data.humanOrigin, humanOriginalBody: originalBtwText,
             });
             await data.respond(result);
         }
@@ -3763,12 +4168,16 @@ export class FleetManager {
                 const autoPauseChanged = oldAutoPause.get(ch.instanceName) !== newAutoPause;
                 // #1220: a running CLI keeps the login it was launched with, so a new
                 // credential_profile only takes effect through a restart.
-                const { changed: profileChanged, startsFresh: profileSwitchStartsFresh, from: profileFrom, to: profileTo } = this.classicProfileChange(ch.instanceName, backendChanged);
+                const { changed: profileChanged, startsFresh: profileSwitchStartsFresh, from: profileFrom, to: profileTo, carry: profileCarry } = this.classicProfileChange(ch.instanceName, backendChanged);
                 if (this.daemons.has(ch.instanceName) && (backendChanged || modelChanged || autoPauseChanged || profileChanged)) {
                     this.logger.info({ instanceName: ch.instanceName, backendFrom: oldBackends.get(ch.instanceName), backendTo: newBackend, modelFrom: oldModels.get(ch.instanceName), modelTo: newModel,
                         ...(profileChanged ? { profileFrom, profileTo } : {}) }, "Backend/model/profile changed — restarting");
+                    const launchedIn = this.daemons.get(ch.instanceName)?.getConfigSnapshot?.()?.working_directory;
                     await this.stopInstance(ch.instanceName).catch(() => { });
-                    if (profileSwitchStartsFresh)
+                    // #1753: the conversation goes along where it can; otherwise a switch that loses it starts fresh.
+                    if (profileCarry)
+                        await this.switchConversation(ch.instanceName, { ...profileCarry, workingDirectory: launchedIn });
+                    else if (profileSwitchStartsFresh)
                         this.writeFreshStartMarker(ch.instanceName);
                     // Small delay to let tmux window clean up
                     await new Promise(r => setTimeout(r, 2000));
@@ -4152,6 +4561,33 @@ export class FleetManager {
             names.add(channel.instanceName);
         return [...names];
     }
+    /** #1624: migration cannot infer ownership from the running daemon roster.
+     * Stopped/paused ClassicBot entries count too; their workspace is exactly
+     * the one startClassicInstance builds, not this FleetManager's dataDir.
+     */
+    kiroPeerWorkingDirectories(name) {
+        if (!this.fleetConfig || !this.classicChannels)
+            throw new Error("Kiro peer configuration is not loaded");
+        const peers = [];
+        for (const [peer, cfg] of Object.entries(this.fleetConfig.instances)) {
+            if (peer === name || (cfg.backend ?? this.fleetConfig.defaults?.backend ?? "claude-code") !== "kiro-cli")
+                continue;
+            if (typeof cfg.working_directory !== "string" || !cfg.working_directory)
+                throw new Error("Kiro peer cwd is unknown");
+            peers.push(cfg.working_directory);
+        }
+        for (const ch of this.classicChannels.getAll()) {
+            if (ch.instanceName === name) {
+                if (Object.hasOwn(this.fleetConfig.instances, name))
+                    throw new Error("Kiro instance name has two configurations");
+                continue;
+            }
+            if (this.classicChannels.getBackendByInstance(ch.instanceName, this.fleetConfig.defaults?.backend) === "kiro-cli") {
+                peers.push(join(getAgendHome(), "workspaces", ch.instanceName));
+            }
+        }
+        return peers;
+    }
     /**
      * Probe the same executable set exposed by the web backend catalog.
      *
@@ -4374,6 +4810,9 @@ export class FleetManager {
         // Published so the outage hand-off can wait for an explicit stop that began
         // BEFORE it (the generation fence alone only catches stops that begin after
         // the hand-off snapshotted it).
+        // #1716: scope the marker to this stop — a marker older than beganAt is
+        // from an earlier stop and never reports.
+        const beganAt = Date.now();
         const run = (async () => {
             try {
                 await this.lifecycle.stop(name, transition);
@@ -4381,6 +4820,10 @@ export class FleetManager {
             finally {
                 this.clearNoncePromptsForInstance(name);
             }
+            const backgroundWorkEnded = readBackgroundWorkEndedMarker(this.getInstanceDir(name), beganAt) !== null;
+            if (backgroundWorkEnded)
+                this.notifyInstanceTopic(name, t("stop.background_work_ended", name));
+            return { backgroundWorkEnded };
         })().finally(() => { if (this.stopsInFlight.get(name) === run)
             this.stopsInFlight.delete(name); });
         this.stopsInFlight.set(name, run);
@@ -4395,6 +4838,16 @@ export class FleetManager {
         const inFlight = this.restartsInFlight.get(name);
         if (inFlight) {
             this.logger.info({ name }, "restartSingleInstance: joining the restart already in flight");
+            // #1753: a credential-profile switch joining it still needs its conversation carried in that restart's stop →
+            // start gap: handed to the restart while it has not reached the gap (and carries nothing else); otherwise not
+            // carried, and said so — the restart has already started, or will start, the CLI without it.
+            if (opts?.carry) {
+                const gap = this.restartGaps.get(name);
+                if (gap && !gap.reached && !gap.carry)
+                    gap.carry = opts.carry;
+                else
+                    opts.carry.result = { carried: false, reason: gap?.carry ? "a restart in flight carries another switch" : "joined a restart in flight past its stop" };
+            }
             return inFlight;
         }
         const workingDirectory = this.fleetConfig?.instances[name]?.working_directory || this.getInstanceDir(name);
@@ -4403,6 +4856,8 @@ export class FleetManager {
         // spawn gate is taken inside the transition, never the other way round, so
         // the start being waited for can still get its own gate slot.
         this.lifecycle.invalidate(name);
+        const gap = { carry: opts?.carry, reached: false };
+        this.restartGaps.set(name, gap);
         const run = this.lifecycle.runTransition(name, transition => this.spawnGate.run({
             instanceName: name,
             workingDirectory,
@@ -4411,6 +4866,8 @@ export class FleetManager {
         }, () => this.doRestartSingleInstance(name, opts, transition)))
             .finally(() => {
             this.restartsInFlight.delete(name);
+            if (this.restartGaps.get(name) === gap)
+                this.restartGaps.delete(name);
             this.scheduleDeliveryOutboxPump();
         });
         this.restartsInFlight.set(name, run);
@@ -4480,10 +4937,41 @@ export class FleetManager {
     async doRestartWithSlot(name, opts, transition, config, wasPaused) {
         const pausedAt = wasPaused ? (this.lifecycle.getLastPausedAt(name) ?? readPausedAt(this.getInstanceDir(name))) : null;
         const pauseReason = wasPaused ? readPauseReason(this.getInstanceDir(name)) : null;
+        // #1753: the directory the CLI being stopped was launched in — its conversation is under that directory's key.
+        const launchedIn = this.daemons.get(name)?.getConfigSnapshot?.()?.working_directory;
+        // Between the stop and the start: the old CLI's transcript is complete, the new one has not looked yet.
+        /** `launching`: the login the start will use — read only when a switch is to be carried. */
+        const betweenStopAndStart = async (launching) => {
+            // #1753: this restart's own carry, or one a caller joined it with before this point (restartSingleInstance).
+            const gap = this.restartGaps.get(name);
+            const carry = gap?.carry ?? opts?.carry;
+            if (gap)
+                gap.reached = true;
+            if (!carry) {
+                if (opts?.freshStart)
+                    this.writeFreshStartMarker(name);
+                return;
+            }
+            // Only into the login this start really launches: a restart that read its configuration before the switch was
+            // saved (one a switch joined) launches the old one — a copy into the new would be reported as carried, falsely.
+            const launch = launching();
+            if (launch.backend !== carry.backend || launch.profile !== carry.to) {
+                const login = (p) => (p ? `profile "${p}"` : "the default login");
+                carry.result = { carried: false, reason: `the restart launches ${launch.backend !== carry.backend ? launch.backend : login(launch.profile)}, not ${login(carry.to)}` };
+                this.logger.info({ name, launches: launch, carry: { backend: carry.backend, from: carry.from, to: carry.to } }, "Conversation not carried: the restart launches another login");
+                // The old login resumes its own conversation; any other starts fresh, as an uncarried switch does.
+                if (launch.backend !== carry.backend || launch.profile !== carry.from)
+                    this.writeFreshStartMarker(name);
+                return;
+            }
+            carry.result = await this.switchConversation(name, { ...carry, workingDirectory: launchedIn });
+        };
         if (config) {
             await this.stopInstance(name, transition);
-            if (opts?.freshStart)
-                this.writeFreshStartMarker(name);
+            await betweenStopAndStart(() => {
+                const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
+                return { backend, profile: credentialHomeSpec(backend) ? instanceCredentialProfile(config, this.fleetConfig?.defaults, backend) : null };
+            });
             const topicMode = this.fleetConfig?.channel?.mode === "topic";
             await this.startAfterRestart(name, wasPaused, pausedAt, pauseReason, () => this.startInstance(name, config, topicMode ?? false, "fleet-topic", false, transition));
             this.stormWindow.markRecovered(name);
@@ -4496,8 +4984,10 @@ export class FleetManager {
             const adapterId = this.classicChannels.getAdapterIdByInstance(name);
             await this.stopInstance(name, transition);
             await new Promise(r => setTimeout(r, 1000)); // let tmux clean up
-            if (opts?.freshStart)
-                this.writeFreshStartMarker(name);
+            await betweenStopAndStart(() => {
+                const backend = this.classicChannels.getBackendByInstance(name, fleetBackend);
+                return { backend, profile: credentialHomeSpec(backend) ? profileName(this.classicChannels.getCredentialProfileByInstance(name, this.fleetConfig?.defaults)) : null };
+            });
             await this.startAfterRestart(name, wasPaused, pausedAt, pauseReason, () => this.startClassicInstance(name, this.classicChannels.getBackendByInstance(name, fleetBackend), this.classicChannels.getPreTaskCommand(channelId, adapterId), this.classicChannels.getModel(channelId, adapterId, this.fleetConfig?.defaults?.model), this.classicChannels.getAutoPauseAfter(channelId, adapterId, this.fleetConfig?.defaults?.auto_pause_after), transition));
             this.stormWindow.markRecovered(name);
             return;
@@ -4518,6 +5008,43 @@ export class FleetManager {
             this.logger.warn({ err, name }, "freshStart: failed to write crash-state marker");
         }
     }
+    /**
+     * #1753: a credential-profile switch, between the old CLI's stop and the new one's start. Where the backend can take
+     * the conversation along (claude-code), copy it into the new profile and make it the one `--continue` picks; when that
+     * cannot be done, or the backend cannot, start fresh as before. Null when nothing was tried.
+     */
+    async switchConversation(name, sw) {
+        if (!credentialSwitchCarriesConversation(sw.backend)) {
+            if (credentialSwitchStartsFresh(sw.backend))
+                this.writeFreshStartMarker(name);
+            return null;
+        }
+        let sessionId = null;
+        try {
+            sessionId = readFileSync(join(this.getInstanceDir(name), "session-id"), "utf-8");
+        }
+        catch { /* none: nothing to carry */ }
+        const dir = (profile) => claudeConfigDirFor(profile ? credentialProfileHome(this.dataDir, sw.backend, profile) : null);
+        let result;
+        try {
+            result = await carryClaudeConversation({ sessionId, workingDirectory: sw.workingDirectory ?? "", fromConfigDir: dir(sw.from), toConfigDir: dir(sw.to) });
+        }
+        catch (err) {
+            result = { carried: false, reason: `copy failed: ${err.message}` };
+        }
+        if (result.carried) {
+            const fields = { name, from: sw.from ?? "default", to: sw.to ?? "default", bytes: result.bytes, ms: result.ms, replacedOlderCopy: result.replacedOlderCopy };
+            if (result.bytes > CARRY_LARGE_BYTES)
+                this.logger.warn(fields, "Conversation carried to the new credential profile (a large transcript)");
+            else
+                this.logger.info(fields, "Conversation carried to the new credential profile");
+        }
+        else {
+            this.logger.info({ name, from: sw.from ?? "default", to: sw.to ?? "default", reason: result.reason }, "Conversation not carried to the new credential profile; starting fresh");
+            this.writeFreshStartMarker(name);
+        }
+        return result;
+    }
     /** Load .env file from data dir into process.env */
     loadEnvFile(owner) {
         const envPath = join(this.dataDir, ".env");
@@ -4549,6 +5076,9 @@ export class FleetManager {
             this.webSessions = new WebSessionStore({
                 dataDir: this.dataDir,
                 onWarn: message => this.logger.warn(message),
+                // #1620: fleet.yaml's web.session.local, read at every check — a Settings save or a reload applies at once
+                // (shortening ends the sessions it now outlives). The public link's policy stays fixed.
+                localPolicy: () => localSessionPolicy(this.fleetConfig?.web?.session?.local),
             });
         }
         if (!this.returningDevices) {
@@ -4578,7 +5108,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") }));
@@ -4597,7 +5133,7 @@ export class FleetManager {
             && cfg.topic_id?.toString() === owner.threadId);
     }
     /** Exact owning General. No primary-adapter or name fallback participates in authorization. */
-    dashboardOwner(userId, adapterId, address, threadId) {
+    dashboardOwner(userId, adapterId, address, threadId, username) {
         const world = this.worlds.get(adapterId);
         if (!world || !this.hasFleetAdmins(adapterId) || !this.isFleetAdmin(userId, adapterId))
             return null;
@@ -4612,10 +5148,65 @@ export class FleetManager {
             const matched = dc ? topic === address || (group === address && topic === threadId)
                 : group === address && ((topic === "1" && (threadId === undefined || threadId === "1")) || topic === threadId);
             if (group && matched)
-                return { userId, adapterId, chatId: group, threadId: topic, binding: world.adapter };
+                return { userId, adapterId, chatId: group, threadId: topic, binding: world.adapter, ...(username ? { username } : {}) };
         }
         return null;
     }
+    /**
+     * #1742: the General a fleet admin's DM speaks for (`/start web`): the same owner `/web` in that General would make
+     * — this bot's configured group and its one General topic. No address to match in a DM, so it must be unambiguous:
+     * no General, or more than one on this bot and group, and there is no owner (nothing is guessed).
+     */
+    dmDashboardOwner(userId, adapterId, username) {
+        const world = this.worlds.get(adapterId);
+        if (!world || !this.hasFleetAdmins(adapterId) || !this.isFleetAdmin(userId, adapterId))
+            return null;
+        const configured = (this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : [])).find(ch => (ch.id ?? ch.type) === adapterId);
+        const group = String(configured?.group_id ?? "");
+        if (!group)
+            return null;
+        const topics = Object.entries(this.fleetConfig?.instances ?? {})
+            .filter(([name, cfg]) => cfg.general_topic && cfg.topic_id != null && this.getInstanceAdapterId(name) === adapterId
+            && String(this.getGroupIdForInstance(name) ?? "") === group)
+            .map(([, cfg]) => cfg.topic_id.toString());
+        if (topics.length !== 1)
+            return null;
+        const owner = { userId, adapterId, chatId: group, threadId: topics[0], binding: world.adapter, ...(username ? { username } : {}) };
+        return this.publicOwnerCurrent(owner) ? owner : null;
+    }
+    /**
+     * #1742: a fleet admin whose Telegram `/web` could not reach them privately may next open the bot's DM and press
+     * Telegram's START, which sends a bare `/start` — read as `/start web` (the DM menu) for 10 minutes, once, for that
+     * admin on that bot. Monotonic: a wall-clock jump neither opens nor shuts it.
+     */
+    tgWebStartWindows = new Map();
+    openTgWebStartWindow(adapterId, userId) {
+        const now = performance.now();
+        for (const [key, until] of this.tgWebStartWindows)
+            if (until <= now)
+                this.tgWebStartWindows.delete(key);
+        this.tgWebStartWindows.set(`${adapterId}\0${userId}`, now + TG_WEB_START_WINDOW_MS);
+    }
+    /** Uses the window up: true when it was open. */
+    takeTgWebStartWindow(adapterId, userId) {
+        const key = `${adapterId}\0${userId}`;
+        const until = this.tgWebStartWindows.get(key);
+        this.tgWebStartWindows.delete(key);
+        return until !== undefined && performance.now() < until;
+    }
+    /** #1742: `/start web` from a fleet admin: the /web menu right here in the DM, for the General this bot serves. */
+    async startWebInDm(msg, adapter) {
+        if (!adapter)
+            return;
+        const owner = msg.chatId === msg.userId ? this.dmDashboardOwner(msg.userId, msg.adapterId ?? "", msg.username) : null;
+        if (!owner) {
+            await adapter.sendText(msg.chatId, t("dashboard.start_web_ack"));
+            return;
+        }
+        if (!await this.showDashboardMenu(owner, undefined, undefined, msg.chatId)) {
+            await adapter.sendText(msg.chatId, t("dashboard.menu_failed")).catch(() => undefined);
+        }
+    }
     getPublicWebLink() {
         this.initializeWebSessions();
         return this.publicWebLink ??= new PublicWebLink({
@@ -4630,7 +5221,14 @@ export class FleetManager {
                 if (result && !result.durable)
                     this.logger.warn("Public session revocation could not be saved; exposure remains closed");
             },
-            log: (event, exposureId) => this.logger.info({ event, exposureId }, "Public web link"),
+            log: (event, exposureId, detail) => this.logger.info({ event, exposureId, ...(detail ? { detail } : {}) }, "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, detail) => this.logger.info({ event, exposureId: id, ...(detail ? { detail } : {}) }, "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);
@@ -4653,7 +5251,7 @@ export class FleetManager {
     /** Telegram's typed command enters through the same strict owner and nonce path as Discord. */
     async dashboardMenu(msg) {
         const id = msg.adapterId;
-        const owner = id ? this.dashboardOwner(msg.userId, id, msg.chatId, msg.threadId) : null;
+        const owner = id ? this.dashboardOwner(msg.userId, id, msg.chatId, msg.threadId, msg.username) : null;
         if (!owner) {
             const adapter = id ? this.adapters.get(id) : undefined;
             await adapter?.sendText(msg.chatId, t("dashboard.public_general"), { threadId: msg.threadId });
@@ -4663,6 +5261,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"));
@@ -4676,7 +5284,9 @@ export class FleetManager {
             return;
         }
         this.initializeWebSessions();
-        const login = this.webLoginCodes.issue({ epoch: tokenEpoch(token) });
+        // #1827: the code goes privately to this account (a DM, or else this slash command's ephemeral answer): whoever
+        // redeems it is recognised as that account. Recognition only — no owner (this is not an owning General's code).
+        const login = this.webLoginCodes.issue({ epoch: tokenEpoch(token), recipient: { adapterId, userId: data.userId, ...(data.username ? { username: data.username } : {}) } });
         const current = () => !this.shuttingDown && this.adapters.get(adapterId) === adapter
             && this.webToken === token && this.hasFleetAdmins(adapterId) && this.isFleetAdmin(data.userId, adapterId);
         const privateText = `${text}\n${t("dashboard.code", login.display, Math.round(LOGIN_CODE_TTL_MS / 60_000))}`;
@@ -4776,7 +5386,11 @@ export class FleetManager {
         this.logger.info({ code: typeof code === "string" || typeof code === "number" ? code : undefined, err: err?.message }, "Dashboard DM not delivered; answering privately where the command was used");
     }
     /** False when the menu was not shown (the caller still owes the user an answer). */
-    async showDashboardMenu(owner, respondButtons, retireButtons) {
+    /**
+     * `dmChatId` (#1742): show it in the owner's own private chat with the bot instead of the General — the owner, its
+     * gates and the code's route are the same; only where the menu sits (and its clicks are good) changes.
+     */
+    async showDashboardMenu(owner, respondButtons, retireButtons, dmChatId) {
         if (!this.publicOwnerCurrent(owner)) {
             this.logger.info("Dashboard menu not shown: the General owner changed");
             return false;
@@ -4784,16 +5398,18 @@ export class FleetManager {
         const adapter = owner.binding;
         const status = this.getPublicWebStatus();
         const publicAllowed = publicLinkSettings(this.fleetConfig?.web).allowed;
+        const tgHint = adapter.type === "telegram" && dmChatId === undefined ? 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") }] : [])];
         const posted = await this.postNonceButtonPrompt({
             prefix: "dashboard:", alertType: "login", instanceName: "dashboard", adapter, adapterId: owner.adapterId,
-            chatId: owner.chatId, threadId: owner.threadId, timeoutMs: 5 * 60_000,
+            chatId: dmChatId ?? owner.chatId, threadId: dmChatId === undefined ? owner.threadId : undefined, timeoutMs: 5 * 60_000,
             message: menuText,
             choices, expiredText: t("buttons.stale"), extra: { requesterUserId: owner.userId, dashboardOwner: owner, publicExposureId: this.publicWebLink?.exposureId },
             ...(respondButtons ? { deliver: async (c) => {
@@ -4856,6 +5472,8 @@ export class FleetManager {
         }) : null;
         let lastSteps;
         let deliveredByDm = false;
+        // #1742: a DM was tried and did not go — only then is "open the private chat" the way out.
+        let dmRefused = false;
         const send = async (url, exposureId, expiresAt, current = () => this.publicOwnerCurrent(owner)) => {
             const token = this.webToken;
             if (!token || !current())
@@ -4881,6 +5499,7 @@ export class FleetManager {
                     }
                     catch (err) {
                         this.logDashboardDmFailure(err);
+                        dmRefused = true;
                         if (direct.type !== "discord" || !data.respondPrivate || !current())
                             throw new Error("private delivery unavailable");
                         const sent = await withinBudget(data.respondPrivate(text, c), deadline);
@@ -4926,11 +5545,23 @@ export class FleetManager {
             this.logger.warn({ err }, "Dashboard sign-in delivery failed");
         }
         // Only safe, static words enter General; never link, code or platform error text.
-        const outcome = t(!ok ? "dashboard.private_failed"
-            : owner.binding.type !== "discord" ? "dashboard.private_sent" : deliveredByDm ? "dashboard.private_sent_dm" : "dashboard.private_sent_here");
+        // #1742: Telegram's failure walks through opening the DM (never a bare /start, which starts a ClassicBot agent),
+        // with the "先開私訊 →" button when the bot's username is known; and for a while a bare /start there counts as
+        // /start web. A menu shown in the DM itself says the details are right below it. Only when a DM was tried and did
+        // not go: a link that never got that far (the tunnel lane held, the owner gone) says so instead.
+        const telegram = owner.binding.type === "telegram";
+        const dmSteps = !ok && telegram && dmRefused;
+        const tgLink = dmSteps ? this.tgStartWebUrl(adapterId) : null;
+        if (dmSteps)
+            this.openTgWebStartWindow(adapterId, owner.userId);
+        const outcome = t(!ok ? (!telegram ? "dashboard.private_failed" : !dmSteps ? "dashboard.link_failed" : tgLink ? "dashboard.private_failed_tg" : "dashboard.private_failed_tg_nolink")
+            : telegram && entry.chatId === owner.userId ? "dashboard.private_sent_below"
+                : 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 = tgLink ? [{ label: t("dashboard.start_web_label"), url: tgLink }] : 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. */
@@ -5172,6 +5803,86 @@ 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.
+     */
+    /**
+     * #1735: what the completion of an adopted update does about its retire outcome, read from the marker as it is now.
+     * Already landed with a warning (a detached restart returns before this fleet boots, so the updater retires first)
+     * → render it in the completion. Still owed (`cleanup: "pending"` — a service restart waits for READY, which comes
+     * after the completion) → watch for it. Anything else (no retire on this update, done silently, another receipt)
+     * → nothing.
+     */
+    /**
+     * #1716: background work this restart/update ended, scoped to the operation
+     * so an older stop never reports (`sinceAt` null = plain boot, report
+     * nothing). A method — not a module function — because the #1737
+     * extracted-completion harness runs this region verbatim with only
+     * `this`-methods plus a fixed context.
+     */
+    collectBackgroundWorkEndedNames(names, sinceAt) {
+        if (sinceAt === null)
+            return [];
+        return names.filter(n => readBackgroundWorkEndedMarker(this.getInstanceDir(n), sinceAt) !== null);
+    }
+    updateCleanupAtCompletion(pending, operation) {
+        if (!pending || operation !== "update")
+            return null;
+        const receipt = updateReceiptOf(pending);
+        if (!receipt)
+            return null;
+        const current = readUpdateProgress(this.dataDir);
+        const verdict = cleanupWatchVerdict(current, receipt);
+        if (verdict.action === "append")
+            return { render: { warning: verdict.warning, cleanupCommand: verdict.cleanupCommand } };
+        if (verdict.action === "wait" && current?.progress.cleanup === "pending")
+            return { watch: receipt };
+        return null;
+    }
+    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);
@@ -5185,6 +5896,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)
@@ -5251,6 +6004,8 @@ export class FleetManager {
         const fleet = this.loadConfig(configPath);
         this.slimFleetConfigAtStartup();
         setLocale(detectLocale(fleet)); // user-facing text language (fleet.yaml defaults.locale / timezone)
+        // #1737 review: the marker this boot adopts — the startup clear may only ever clear this one.
+        const bootUpdateMarker = updateMarkerIdentity(this.dataDir);
         const savedUpdateProgress = readUpdateProgress(this.dataDir);
         const pendingUpdateProgress = savedUpdateProgress
             && savedUpdateProgress.progress.stage !== "failed"
@@ -5275,7 +6030,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);
@@ -5680,19 +6439,37 @@ export class FleetManager {
             const _require = createRequire(import.meta.url);
             const agendVersion = _require("../package.json").version ?? "unknown";
             await progressStart;
-            const progressCompleted = await startupProgress.finish({
+            // #1660/#1735: the nvm route's retire outcome, read NOW (not from the boot snapshot). Either order happens:
+            // a detached fleet's `agend restart` returns before this fleet boots, so the outcome may already be here —
+            // render it in the completion itself; a service restart waits for READY (after this), so it may still be owed
+            // — post without it and arm the watch, which appends it to the same receipt once it lands. READY never waits
+            // for cleanup (that would deadlock with an updater that retires after its restart returns).
+            const cleanupOutcome = this.updateCleanupAtCompletion(pendingUpdateProgress, pendingProgressOperation);
+            // #1716: background work this restart/update ended, scoped to the
+            // operation so an older stop never reports. No pending operation means
+            // a plain boot — nothing was stopped by an operation, report nothing.
+            const backgroundWorkEndedNames = this.collectBackgroundWorkEndedNames(configuredNames, pendingUpdateProgress?.startedAt ?? null);
+            const completionSummary = {
                 running: started,
                 total,
                 version: agendVersion,
                 pausedNames,
                 failedNames,
+                backgroundWorkEndedNames,
                 tipText: pendingProgressOperation === "update" && this.tipsEnabled()
                     ? (() => {
                         const tip = this.pickAvailableTip();
                         return tip ? this.formatTip(tip) : undefined;
                     })()
                     : undefined,
-            });
+                ...(cleanupOutcome && "render" in cleanupOutcome
+                    ? { warningText: cleanupOutcome.render.warning, warningCommand: cleanupOutcome.render.cleanupCommand }
+                    : {}),
+            };
+            const progressCompleted = await startupProgress.finish(completionSummary);
+            // Armed only after the completion posted: an append racing ahead of it would be overwritten by it.
+            if (cleanupOutcome && "watch" in cleanupOutcome)
+                this.armCleanupWatch(cleanupOutcome.watch, completionSummary);
             if (!progressCompleted && fleet.channel?.group_id) {
                 let text;
                 if (pendingProgressOperation === "full-restart") {
@@ -5702,6 +6479,7 @@ export class FleetManager {
                         version: agendVersion,
                         pausedNames,
                         failedNames,
+                        backgroundWorkEndedNames,
                     }, pendingUpdateProgress.startedAt);
                 }
                 else if (failedNames.length === 0 && pausedNames.length === 0) {
@@ -5714,6 +6492,18 @@ export class FleetManager {
                     text = t("fleet.ready_with_failed", started, total, agendVersion, failedNames.join(", "))
                         + (pausedNames.length > 0 ? `\n⏸ Paused: ${pausedNames.join(", ")}` : "");
                 }
+                // #1716: the fallback carries the same background-work names as the
+                // completion (inline: this block is executed verbatim by the #1737
+                // extracted-completion harness, which resolves `this`-methods plus a
+                // fixed context — no new bare module references here).
+                if (backgroundWorkEndedNames.length) {
+                    text += `\n⚠️ Background work was running and was ended: ${backgroundWorkEndedNames.join(", ")}`;
+                }
+                // #1735: an outcome that already landed goes in this message too; one still owed is the watch's.
+                if (cleanupOutcome && "render" in cleanupOutcome) {
+                    text += `\n\n⚠️ ${cleanupOutcome.render.warning}`
+                        + (cleanupOutcome.render.cleanupCommand ? `\n\`$ ${cleanupOutcome.render.cleanupCommand}\`` : "");
+                }
                 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.
@@ -5722,6 +6512,7 @@ export class FleetManager {
         // Health HTTP endpoint
         this.startHealthServer(fleet.health_port ?? 19280);
         // #1266: buttons that ended while AgEnD was down (expired, or chosen before a restart) are shown as ended now.
+        // #1823: and polls: a deadline that passed meanwhile closes now (results once); an open one's countdown is redrawn.
         void this.replyButtons()?.sweep().catch(err => this.logger.warn({ err }, "Reply-button sweep failed"));
         // Daily update check — first check after 1 hour, then every 24 hours
         this.updateCheckTimer = setTimeout(() => {
@@ -5735,7 +6526,7 @@ export class FleetManager {
         // A SIGHUP may arrive after the PID/general is available but before the
         // rest of startup finishes. Replay one coalesced reload only after all
         // startup-owned lifecycle work and signal handlers are in place.
-        this.finishStartup();
+        this.finishStartup(bootUpdateMarker);
         // Tell systemd we are ready only now. This used to fire right after the
         // generals started — before adapters, classic instances, topic creation and the
         // health server — so `systemctl start` returned success while the fleet was
@@ -6463,6 +7254,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") {
@@ -6975,6 +7774,24 @@ export class FleetManager {
         });
     }
     async handleInboundMessage(msg) {
+        msg = { ...msg, humanOriginalBody: msg.humanOriginalBody ?? msg.text, humanOrigin: msg.isBotMessage ? undefined : msg.humanOrigin && { ...msg.humanOrigin } };
+        if (msg.isBotMessage)
+            return withSpawnHoldReply(undefined, () => this.handleInboundMessageCore(msg));
+        return withSpawnHoldReply(text => this.inboundNoticeAdapter(msg)?.sendText(msg.chatId, text, { threadId: msg.threadId }) ?? Promise.resolve(), () => this.handleInboundMessageCore(msg));
+    }
+    /**
+     * #1752: the bot that speaks back about an inbound message — in a fleet topic the owning instance's adapter, never
+     * the sibling that happened to win the dedup race; elsewhere (ClassicBot rooms, no routed instance) the receiver.
+     */
+    inboundNoticeAdapter(msg) {
+        const id = this.governingAccess(msg, this.inboundRouteThreadId(msg)).adapterId ?? "";
+        return this.worlds.get(id)?.adapter ?? this.adapters.get(id) ?? this.adapter;
+    }
+    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();
@@ -7002,6 +7819,15 @@ export class FleetManager {
             return;
         }
         const threadId = this.inboundRouteThreadId(msg);
+        // #1752: a post by one of this fleet's own bots is never input to a fleet topic's instance. They speak there only
+        // for an instance (its replies, notices, warnings) — taking that as a user turn makes one bot's notice another
+        // agent's "user" message, and a loop. Fleet /collab and open mode admit OTHER bots and webhooks; they never meant
+        // our own. Exempt: ClassicBot rooms, where bots this fleet runs deliberately talk to each other by @mention
+        // (same-channel multi-bot collab), and no-thread Telegram (classic candidates; Telegram bots never see each other).
+        if (msg.userId && fleetBotIds.has(msg.userId) && threadId && !this.classicChannels?.hasChannel(threadId)) {
+            this.logger.debug({ adapterId: msg.adapterId, threadId, messageId: msg.messageId, author: msg.userId }, "Inbound dropped: authored by one of this fleet's own bots in a fleet topic");
+            return;
+        }
         const rootCommand = this.telegramRootCommandTarget(msg, threadId);
         this.logger.debug({ source: msg.source, chatId: msg.chatId, threadId, userId: msg.userId, isBotMessage: msg.isBotMessage, textLen: (msg.text ?? "").length, text: (msg.text ?? "").slice(0, 80) }, "handleInboundMessage entry");
         // Ownership and per-adapter filtering both run before the dedup claim below.
@@ -7130,6 +7956,23 @@ 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;
+                    // #1742: a bare /start from a fleet admin whose /web just failed to reach them privately is that /start web
+                    // (Telegram's START button sends it bare) — once, within the window; any other bare /start is ClassicBot's.
+                    const admin = isPrivateChat && this.isFleetAdmin(msg.userId, msg.adapterId ?? "");
+                    const webStart = isPrivateChat && (requestedBackend === "web"
+                        || (text === "/start" && admin && this.takeTgWebStartWindow(msg.adapterId ?? "", msg.userId)));
+                    if (webStart) {
+                        if (requestedBackend === "web")
+                            this.takeTgWebStartWindow(msg.adapterId ?? "", msg.userId);
+                        // #1742: the /web menu right here; the code comes to this DM.
+                        if (admin)
+                            await this.startWebInDm(msg, msgAdapter ?? undefined);
+                        // 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);
@@ -7138,7 +7981,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);
@@ -7206,6 +8048,21 @@ export class FleetManager {
                     }
                     return;
                 }
+                // #1806: /backend — channel admin, as /model. A ClassicBot agent is not switched by it (it says so).
+                if (text === "/backend" || text.startsWith("/backend ") || text.startsWith("/backend@")) {
+                    if (!this.isModelAdmin(msg.userId, chatId, msg.adapterId)) {
+                        await msgAdapter?.sendText(chatId, t("permission.denied"));
+                        return;
+                    }
+                    const backendInstance = this.classicChannels.getInstanceByChannel(chatId, msg.adapterId);
+                    if (!backendInstance) {
+                        await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
+                        return;
+                    }
+                    if (msgAdapter)
+                        await this.runBackendCommand(backendInstance, text, msg.userId, chatId, msgAdapter, chatId, undefined, msg.adapterId);
+                    return;
+                }
                 // Handle /compact command (admin only)
                 const classicCompact = parseCompactCommand(text);
                 if (classicCompact) {
@@ -7391,7 +8248,7 @@ export class FleetManager {
                 const { text, extraMeta } = await processAttachments(msg, inboundAdapter, this.logger, generalInstance);
                 const generalReactions = this.pendingReactionsMeta(generalInstance);
                 try {
-                    await this.deliverToInstance(generalInstance, {
+                    await this.deliverHumanToInstance(generalInstance, {
                         type: "fleet_inbound",
                         content: text,
                         targetSession: generalInstance,
@@ -7412,7 +8269,7 @@ export class FleetManager {
                             ...generalReactions.meta,
                             ...extraMeta,
                         },
-                    });
+                    }, msg.humanOrigin, msg.humanOriginalBody ?? msg.text);
                     generalReactions.consume();
                     this.afterUserInboundDelivered(generalInstance, msg);
                     this.logger.info(`${msg.username} → ${generalInstance}: ${(text ?? "").slice(0, 100)}`);
@@ -7492,7 +8349,7 @@ export class FleetManager {
         const { text, extraMeta } = await processAttachments(msg, inboundAdapter, this.logger, instanceName);
         const reactions = this.pendingReactionsMeta(instanceName);
         try {
-            await this.deliverToInstance(instanceName, {
+            await this.deliverHumanToInstance(instanceName, {
                 type: "fleet_inbound",
                 content: text,
                 targetSession: instanceName, // Channel messages → instance's own session
@@ -7511,7 +8368,7 @@ export class FleetManager {
                     ...reactions.meta,
                     ...extraMeta,
                 },
-            });
+            }, msg.humanOrigin, msg.humanOriginalBody ?? msg.text);
             // Only after the message actually went out. A failed delivery keeps the
             // reactions queued for the retry / the next message.
             reactions.consume();
@@ -7554,9 +8411,14 @@ export class FleetManager {
         if (Date.now() - lastWarn < 30 * 60_000)
             return;
         this.rateLimitWarnedAt.set(instanceName, Date.now());
-        const warnAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-        if (warnAdapter && msg.chatId) {
-            warnAdapter.sendText(msg.chatId, warning, { threadId: msg.threadId ?? undefined }).catch(() => { });
+        // #1752: the instance's own bot, in the instance's own topic. `msg.adapterId` is whichever sibling bot won the
+        // inbound dedup race; a warning from that bot is a stranger's post in this topic (and, to the owning adapter, a
+        // bot message it would take as input).
+        const warnAdapter = this.getAdapterForInstance(instanceName);
+        const dest = this.cancelButtonDestination(instanceName);
+        const { chatId, threadId } = dest?.threadId ? dest : { chatId: msg.chatId, threadId: msg.threadId ?? undefined };
+        if (warnAdapter && chatId) {
+            warnAdapter.sendText(chatId, warning, { threadId }).catch(() => { });
         }
     }
     /** Handle outbound tool calls from a daemon instance */
@@ -7710,10 +8572,12 @@ export class FleetManager {
             respond(null, "No adapter available");
             return;
         }
+        // Only channel-addressing schemas receive ClassicBot routing metadata.
+        // Non-channel calls (notably strict delivery_status) retain their arguments.
         // For classic instances: force chat_id to channelId and clear thread_id
         // (daemon may have set chat_id to guild_id which is wrong for DC; TG may have set thread_id which causes 'thread not found')
         const classicChannelId = this.classicChannels?.getChannelIdByInstance(senderInstanceName ?? instanceName);
-        if (classicChannelId) {
+        if (classicChannelId && usesChannelAddress(tool)) {
             args.chat_id = classicChannelId;
             // #1085: a Telegram forum ClassicBot replies in the topic it was asked
             // in. Any other thread_id (threadless Telegram, where it echoes the chat
@@ -7761,6 +8625,17 @@ export class FleetManager {
                 respond(null, `reply: ${parsedButtons.error}`);
                 return;
             }
+            // #1823: a poll is checked with its buttons. Where it cannot be shown it is refused, never sent as text: text
+            // options would never come back as results.
+            const parsedPoll = parsePoll(args.poll, parsedButtons && "buttons" in parsedButtons ? parsedButtons.buttons : null, args.text);
+            if (parsedPoll && "error" in parsedPoll) {
+                respond(null, `reply: ${parsedPoll.error}`);
+                return;
+            }
+            if (parsedPoll && (!outAdapter.supportsPolls || !this.replyButtons())) {
+                respond(null, `reply: a poll cannot be shown here${outAdapter.supportsPolls ? " (reply buttons are unavailable until AgEnD restarts)" : " — polls work in Discord and Telegram chats and the web chat"}; send the question without poll`);
+                return;
+            }
             // Stickers (#1226) are checked before anything is sent: a refused one is the reply's error, not a gap.
             const stickerProblem = await this.replyStickerProblem(outAdapter, args, threadId, contextAdapterId ?? this.getInstanceAdapterId(senderInstanceName ?? instanceName));
             if (stickerProblem) {
@@ -7780,7 +8655,7 @@ export class FleetManager {
                 const buttons = outAdapter.supportsReplyButtons ? this.replyButtons() : null;
                 if (buttons) {
                     const outId = outAdapter === WEB_ONLY_REPLY_SINK ? "web" : outAdapter.id ?? contextAdapterId ?? "";
-                    replySet = buttons.prepare({ instance: instanceName, adapterId: outId, chatId: String(args.chat_id ?? ""), threadId }, parsedButtons.buttons);
+                    replySet = buttons.prepare({ instance: instanceName, adapterId: outId, chatId: String(args.chat_id ?? ""), threadId }, parsedButtons.buttons, parsedPoll && "poll" in parsedPoll ? parsedPoll.poll : null);
                 }
                 else {
                     args.text = `${String(args.text)}\n\n${replyButtonsFallbackText(parsedButtons.buttons)}`;
@@ -7800,6 +8675,9 @@ export class FleetManager {
                         this.replyButtonsCtl?.discard(replySet.id);
                     }
                 }
+                // #1823: the agent learns its poll's id (the results name it).
+                if (replySet?.poll && !error && result && typeof result === "object")
+                    result = { ...result, poll_id: replySet.id };
                 ticket.complete(result, error);
                 // Return the platform outcome first. Bookkeeping below must never turn
                 // a confirmed Discord/Telegram POST into a tool error if a secondary
@@ -7812,7 +8690,7 @@ export class FleetManager {
                 // an agent cannot invent it to suppress the normal completion marker.
                 if (!error && result != null && msg.statusOnly !== true) {
                     try {
-                        this.afterReplyRouted(instanceName, args, senderSessionName, buttonsView);
+                        void this.afterReplyRouted(instanceName, args, senderSessionName, buttonsView);
                     }
                     catch (err) {
                         this.logger.warn({ err, instanceName }, "Reply delivered but post-delivery bookkeeping failed");
@@ -7827,7 +8705,7 @@ export class FleetManager {
                     });
                 }
             };
-            if (routeToolCall(outAdapter, tool, args, threadId, respondAndRecord, replySet ? { replyButtons: replySet.callbacks } : {})) {
+            if (routeToolCall(outAdapter, tool, args, threadId, respondAndRecord, replySet ? { replyButtons: replySet.callbacks, ...(replySet.poll ? { replyPoll: replySet.poll } : {}) } : {})) {
                 return;
             }
             if (replySet)
@@ -7865,6 +8743,7 @@ export class FleetManager {
     webOnlyPromptPlace() {
         return this.worlds.size === 0 && this.isWebOnlyFleet() ? { adapter: WEB_ONLY_PROMPT_SINK, adapterId: "web", chatId: "web" } : null;
     }
+    /** Resolves when the reply is in the web chat (#1770: after its files are copied); the caller need not wait. */
     afterReplyRouted(instanceName, args, senderSessionName, buttons = null) {
         // A reply is NOT proof the turn is over (#410) — but it is not proof of
         // more work either. Split the difference: an instance that is clearly
@@ -7882,27 +8761,74 @@ export class FleetManager {
         this.reactDone(instanceName);
         const replyTo = this.lastInboundUser.get(instanceName) ?? "user";
         this.logger.info(`${instanceName} → ${replyTo}: ${(args.text ?? "").slice(0, 100)}`);
-        // Files the agent attached are shown in the web chat too: registered for fetching by id (the path
-        // already passed the reply tool's sendability check, and is resolved once more here), never by path.
-        const replyFiles = Array.isArray(args.files) ? args.files.filter((f) => typeof f === "string") : [];
-        const attachments = replyFiles
-            .map(path => this.webFiles.registerServed({ path, instance: instanceName }))
-            .filter((f) => f !== null)
-            .map(publicAttachment);
-        // The one place a delivered agent reply reaches the web chat: the server marks it `agent` (#1306) — the only
-        // role that may get HTML preview cards. Never inferred from the sender name or the text.
-        this.emitSseEvent("message", {
-            instance: instanceName, sender: senderSessionName ?? instanceName, role: "agent",
-            text: (args.text ?? "").slice(0, WEB_CHAT_TEXT_MAX),
-            ts: new Date().toISOString(),
-            ...(attachments.length ? { attachments } : {}),
-            ...(buttons ? { buttons } : {}), // #1266
-        });
         // Log bot reply to classic instance chat-log
         const isClassic = this.classicChannels?.getChannelIdByInstance(instanceName) !== undefined;
         if (isClassic) {
             ClassicChannelManager.logMessage(instanceName, "bot", args.text ?? "", new Date());
         }
+        // Files the agent attached are shown in the web chat too, fetched by id, never by path. #1770: each is copied
+        // first (web-reply-files.ts), and the copy is what the chat serves and keeps — so the message is shown once the
+        // copies are done, and an instance's replies wait for the one before them: they reach the chat in order.
+        const replyFiles = Array.isArray(args.files) ? args.files.filter((f) => typeof f === "string") : [];
+        const ts = new Date().toISOString();
+        const show = (attachments) => {
+            // The one place a delivered agent reply reaches the web chat: the server marks it `agent` (#1306) — the only
+            // role that may get HTML preview cards. Never inferred from the sender name or the text.
+            this.emitSseEvent("message", {
+                instance: instanceName, sender: senderSessionName ?? instanceName, role: "agent",
+                text: (args.text ?? "").slice(0, WEB_CHAT_TEXT_MAX),
+                ts,
+                ...(attachments.length ? { attachments } : {}),
+                ...(buttons ? { buttons } : {}), // #1266
+            });
+        };
+        const before = this.webReplyOrder.get(instanceName);
+        if (!replyFiles.length && !before) {
+            show([]);
+            return Promise.resolve();
+        }
+        const done = (before ?? Promise.resolve())
+            .then(() => this.webReplyAttachments(instanceName, replyFiles))
+            .catch((err) => { this.logger.warn({ err, instanceName }, "Reply files could not be prepared for the web chat"); return []; })
+            .then((attachments) => { try {
+            show(attachments);
+        }
+        catch (err) {
+            this.logger.warn({ err, instanceName }, "Reply could not be shown in the web chat");
+        } })
+            .finally(() => { if (this.webReplyOrder.get(instanceName) === done)
+            this.webReplyOrder.delete(instanceName); });
+        this.webReplyOrder.set(instanceName, done);
+        return done;
+    }
+    /**
+     * #1770: a reply's files as the web chat shows them. Each is copied into the instance's web-files/ and served from
+     * the copy. One the copy refuses (a symlink, not a regular file, over 50 MB, a state file, missing) is not shown;
+     * one that could not be copied (I/O) is served from the agent's own path, as before — until the fleet restarts.
+     */
+    async webReplyAttachments(instanceName, paths) {
+        const home = getAgendHome();
+        const dir = webFilesDir(home, instanceName);
+        const out = [];
+        for (const path of paths) {
+            const id = randomBytes(16).toString("hex");
+            const got = dir ? await snapshotReplyFile(path, dir, id, { stateDir: home, maxDirBytes: this.webReplyMaxBytes }) : null;
+            if (got && "evicted" in got && got.evicted.length)
+                this.webFiles.dropServed(got.evicted);
+            let file = null;
+            if (got?.ok)
+                file = this.webFiles.registerServed({ id, path: got.path, name: basename(path), instance: instanceName, snapshot: true });
+            else if (got?.refused)
+                this.logger.info({ instanceName, file: basename(path), reason: got.reason }, "Reply file not shown in the web chat");
+            else {
+                if (got)
+                    this.logger.warn({ instanceName, file: basename(path), reason: got.reason }, "Reply file could not be copied for the web chat; served from its own path until a restart");
+                file = this.webFiles.registerServed({ path, instance: instanceName });
+            }
+            if (file)
+                out.push(publicAttachment(file));
+        }
+        return out;
     }
     // ===================== Scheduler =====================
     async handleScheduleTrigger(schedule, stableRunId = randomUUID(), retry) {
@@ -9301,7 +10227,9 @@ export class FleetManager {
         else
             await this.lifecycle.remove(name, authorization);
         // A later same-name registration owns its files and caches.
-        if (this.fleetConfig?.instances[name] || this.daemons.has(name))
+        // Own keys only: an instance named "constructor" is removed as any other (its inherited namesake is not a
+        // re-registration) — #1677 review.
+        if (Object.hasOwn(this.fleetConfig?.instances ?? {}, name) || this.daemons.has(name))
             return;
         execution?.assert();
         // Clean up per-instance tracking maps so they don't grow unbounded
@@ -9313,6 +10241,13 @@ export class FleetManager {
         // must not be shown the old one's conversation, and deleted names must not pile up.
         this.webChatHistory.forget(name);
         this.webFiles.forget(name);
+        // #1664: and it is nobody's favorite any more (every device sees that at its next status frame).
+        try {
+            this.webPrefs.forgetInstance(name);
+        }
+        catch (err) {
+            this.logger.warn({ err: err.message, name }, "Dropping a removed instance from web favorites failed");
+        }
         // Clean up statusline watcher + instance directory
         this.statuslineWatcher.unwatch(name);
         // instanceDirToClean and effectiveBackend are captured before lifecycle.remove
@@ -9482,26 +10417,210 @@ export class FleetManager {
                 this.guildEmojiFetches.set(key, pending);
             }
             try {
-                return { ...g, ...(await pending) };
-            }
-            catch (e) {
-                return { ...g, error: `Discord refused the emoji list: ${e.message}` };
+                return { ...g, ...(await pending) };
+            }
+            catch (e) {
+                return { ...g, error: `Discord refused the emoji list: ${e.message}` };
+            }
+        }));
+        const listed = guilds.filter((g) => !!g.emojis);
+        if (!listed.length)
+            return { ok: false, error: guilds[0]?.error ?? "no server to list emojis from" };
+        return {
+            ok: true,
+            fetched_at: Math.min(...listed.map(g => g.fetched_at)),
+            emojis: listed.flatMap(g => g.emojis),
+            guilds,
+        };
+    }
+    static GUILD_EMOJI_TTL_MS = 10 * 60_000;
+    /** Keyed `<connection>\0<server id>`. */
+    guildEmojiCache = new Map();
+    guildEmojiFetches = new Map();
+    // ── #1630: what stands for an instance in the web app, and Discord server emoji in web chat ──
+    webImageCaches = null;
+    webImageCache(kind) {
+        const onError = (key, err) => this.logger.debug({ err: err?.message, key }, "web image fetch failed (kept what was cached)");
+        this.webImageCaches ??= {
+            avatars: new WebImageCache({ dir: join(this.dataDir, "cache", "avatars"), onError }),
+            emoji: new WebImageCache({ dir: join(this.dataDir, "cache", "emoji"), onError }),
+        };
+        return this.webImageCaches[kind];
+    }
+    /**
+     * instance → the connection that is its own bot: configured now (a connection removed from fleet.yaml is nobody's,
+     * whatever an instance still names — #1635 review), not the primary, and answering for it alone.
+     */
+    ownBots() {
+        const instances = this.fleetConfig?.instances ?? {};
+        const channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
+        const configured = new Set(channels.map(ch => ch.id ?? ch.type).filter((id) => typeof id === "string"));
+        const assigned = (name) => { const c = this.getInstanceAdapterId(name); return c && configured.has(c) ? c : undefined; };
+        const assignments = Object.keys(instances).map(n => [n, assigned(n)]);
+        for (const room of this.classicChannels?.getAll() ?? []) {
+            if (!Object.hasOwn(instances, room.instanceName))
+                assignments.push([room.instanceName, assigned(room.instanceName)]);
+        }
+        return ownBotConnections(this.getPrimaryAdapterId(), assignments);
+    }
+    /**
+     * The bot a connection is now: its running adapter and that bot's own user id. Everything cached for an own bot is
+     * keyed by both, so a bot put in its place (a token replaced under the same connection id) never shows the old one's
+     * face or colour, and the old one's late answers land under the old key (#1635 review). null while it has no id.
+     */
+    botOwner(connection) {
+        const adapter = this.adapters.get(connection), id = adapter?.getBotUserId?.();
+        return adapter && id ? { adapter, id } : null;
+    }
+    /** Still the same bot behind `connection` (after an await): the same adapter object and the same bot id. */
+    botStillOwns(connection, owner) {
+        return this.adapters.get(connection) === owner.adapter && owner.adapter.getBotUserId?.() === owner.id;
+    }
+    /** keyed `<connection>\0<bot id>\0<channel>`: the bot's colour there, refreshed at most daily (monotonic), one read at a time. */
+    webAccents = new Map();
+    webAccentReads = new Set();
+    webAccent(connection, owner, channelId) {
+        const adapter = owner.adapter;
+        if (!adapter.botAccentColor)
+            return null;
+        const key = `${connection}\0${owner.id}\0${channelId ?? ""}`, now = performance.now(), cached = this.webAccents.get(key);
+        if ((!cached || now >= cached.until) && !this.webAccentReads.has(key)) {
+            this.webAccentReads.add(key);
+            adapter.botAccentColor(channelId)
+                // Keyed by the bot's id: a replaced bot's late answer lands under its own key, which the new bot never reads.
+                .then(value => { this.webAccents.set(key, { value: accentColor(value), until: performance.now() + WEB_IMAGE_MAX_AGE_MS }); }, () => { this.webAccents.set(key, { value: cached?.value ?? null, until: performance.now() + WEB_IMAGE_RETRY_MS }); })
+                .finally(() => this.webAccentReads.delete(key));
+        }
+        return cached?.value ?? null;
+    }
+    /** The cache key of an own bot's avatar, and its loader (which refuses an answer from a bot no longer there). */
+    botAvatarSource(connection, owner) {
+        return {
+            key: `bot:${connection}:${owner.id}`,
+            load: async () => {
+                const got = await owner.adapter.fetchBotAvatar();
+                if (!this.botStillOwns(connection, owner))
+                    throw new Error("the bot was replaced while its avatar was fetched");
+                return got;
+            },
+        };
+    }
+    /** One instance's avatar and ring for the status frame. Synchronous: what is cached now; fetches run behind. */
+    webIdentityImage(name, displayName, profileAvatar, own) {
+        let profileVersion = null;
+        if (profileAvatar && imageMimeForFile(profileAvatar)) {
+            try {
+                profileVersion = Math.floor(statSync(join(this.dataDir, "avatars", basename(profileAvatar))).mtimeMs).toString(36);
+            }
+            catch { /* removed */ }
+        }
+        const connection = own.get(name), owner = connection ? this.botOwner(connection) : null;
+        const source = connection && owner?.adapter.fetchBotAvatar ? this.botAvatarSource(connection, owner) : null;
+        const bot = source ? this.webImageCache("avatars").peek(source.key, source.load) : null;
+        const cfg = this.ownInstanceConfig(name);
+        const avatar = avatarFor({ name, displayName, profileVersion, bot: bot && connection ? { connection, version: bot.version } : null,
+            personaEmoji: cfg?.status_emojis?.delivered });
+        // The ring belongs to the bot's own face: only when that is what is shown.
+        const accent = !profileVersion && bot && connection && owner
+            ? this.webAccent(connection, owner, cfg ? (cfg.topic_id == null ? undefined : String(cfg.topic_id)) : this.classicChannels?.getChannelIdByInstance(name))
+            : null;
+        return accent ? { avatar, accent } : { avatar };
+    }
+    /** GET /ui/img/bot|avatar/<key>: what is cached, never a fetch. Only an own-bot connection, or a known instance's upload. */
+    webImage(kind, key) {
+        if (kind === "bot") {
+            if (![...this.ownBots().values()].includes(key))
+                return null;
+            const owner = this.botOwner(key);
+            return owner ? this.webImageCache("avatars").read(this.botAvatarSource(key, owner).key) : null;
+        }
+        const known = Object.hasOwn(this.fleetConfig?.instances ?? {}, key) || this.classicChannels?.getChannelIdByInstance(key) !== undefined;
+        if (!known)
+            return null;
+        const file = profileIdentities(this.dataDir).get(key)?.avatar_path;
+        const mime = file ? imageMimeForFile(file) : null;
+        if (!file || !mime)
+            return null;
+        try {
+            const path = join(this.dataDir, "avatars", basename(file));
+            return { bytes: readFileSync(path), mime, version: Math.floor(statSync(path).mtimeMs).toString(36) };
+        }
+        catch {
+            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;
             }
-        }));
-        const listed = guilds.filter((g) => !!g.emojis);
-        if (!listed.length)
-            return { ok: false, error: guilds[0]?.error ?? "no server to list emojis from" };
-        return {
-            ok: true,
-            fetched_at: Math.min(...listed.map(g => g.fetched_at)),
-            emojis: listed.flatMap(g => g.emojis),
-            guilds,
+            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 = [];
+        for (const [id, world] of [...this.worlds]) {
+            if (world.type !== "discord")
+                continue;
+            const listed = await this.listGuildEmojis(id);
+            if (listed.ok)
+                adopted.push({ id, world, emojis: listed.emojis });
+        }
+        // After the LAST await (#1635 review r2): only the lists whose world is still the one that was read — a connection
+        // removed or replaced while a later list was awaited takes its servers along, whenever it went.
+        const out = new Map();
+        for (const a of adopted) {
+            if (this.worlds.get(a.id) !== a.world)
+                continue;
+            for (const e of a.emojis)
+                if (!out.has(e.id))
+                    out.set(e.id, { id: e.id, name: e.name, animated: e.animated });
+        }
+        return [...out.values()];
+    }
+    /** GET /ui/img/emoji/<id>: only an emoji of those servers; fetched once from Discord's CDN, then from the host cache. */
+    async webEmoji(id) {
+        if (!/^\d{15,25}$/.test(id))
+            return null;
+        const emoji = (await this.webEmojiList()).find(e => e.id === id);
+        if (!emoji)
+            return null;
+        const image = await this.webImageCache("emoji").get(`emoji:${id}`, () => downloadStickerImage(`https://cdn.discordapp.com/emojis/${id}.${emoji.animated ? "gif" : "png"}?size=64`, { maxBytes: WEB_IMAGE_MAX_BYTES }));
+        // Still an emoji of the fleet's servers once it is here (a connection removed meanwhile takes its servers along).
+        return image && (await this.webEmojiList()).some(e => e.id === id) ? image : null;
     }
-    static GUILD_EMOJI_TTL_MS = 10 * 60_000;
-    /** Keyed `<connection>\0<server id>`. */
-    guildEmojiCache = new Map();
-    guildEmojiFetches = new Map();
     /**
      * What `instanceName` may pick as its persona emoji (the `list_emojis`
      * tool): its current status set with where each value comes from, the
@@ -10693,7 +11812,8 @@ export class FleetManager {
             // on the sign-in DM, armed by the first tap). A double tap, or a late second one from an old keyboard, lands
             // here with the spent nonce — and collapsing would wipe the message's text and the live buttons. The clicker is
             // told; the message is left alone.
-            if ([...this.pendingNonceButtons.values()].some(e => e.prefix === prefix && e.chatId === data.chatId && e.messageId === data.messageId)) {
+            // #1617: and of the same bot — two bots' DM message ids can collide; another bot's live prompt says nothing here.
+            if ([...this.pendingNonceButtons.values()].some(e => e.prefix === prefix && e.adapterId === callbackAdapterId && e.chatId === data.chatId && e.messageId === data.messageId)) {
                 data.ack?.(t("buttons.stale_notice"));
                 return "consumed";
             }
@@ -10846,6 +11966,8 @@ export class FleetManager {
             return true;
         if (await this.handleEffortSelection(data, adapterId))
             return true;
+        if (await this.handleBackendSelection(data, adapterId))
+            return true;
         if (await this.handleHangPrompt(data, adapterId, adapter))
             return true;
         if (data.callbackData.startsWith("cancel:")) {
@@ -10911,6 +12033,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
@@ -10919,20 +12083,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"),
@@ -11084,10 +12235,18 @@ export class FleetManager {
      * The caller has passed the /ui gate (session, same origin, CSRF). Here: the prompt must be one offered
      * on the dashboard, about the instance the page named, and the action one of its own buttons.
      */
-    /** #1266: a click on a reply's button in the web chat (the /ui gate is passed: a session, or the public link). */
-    clickWebReplyButton(instance, id, index) {
+    /** #1823: close_poll — `instance` closes one of its own polls before the deadline. */
+    closePollEarly(instance, id) {
         const buttons = this.replyButtons();
-        return buttons ? buttons.clickWeb(instance, id, index) : Promise.resolve({ status: 409, error: t("reply_buttons.closed") });
+        return buttons ? buttons.closeEarly(instance, id) : Promise.resolve({ ok: false, error: "polls are unavailable until AgEnD restarts" });
+    }
+    /**
+     * #1266: a click on a reply's button in the web chat (the /ui gate is passed: a session, or the public link). On a
+     * poll (#1823) it is `voter`'s vote: the page's session.
+     */
+    clickWebReplyButton(instance, id, index, voter) {
+        const buttons = this.replyButtons();
+        return buttons ? buttons.clickWeb(instance, id, index, voter) : Promise.resolve({ status: 409, error: t("reply_buttons.closed") });
     }
     async clickWebPrompt(instance, nonce, action) {
         if (!/^[0-9a-f]{32}$/.test(nonce) || !/^[a-z][a-z-]{0,23}$/.test(action))
@@ -11119,7 +12278,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;
@@ -11129,7 +12290,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
@@ -11137,7 +12303,8 @@ export class FleetManager {
             // only place some outcomes are told (cancel, later, a resend's result),
             // so the text goes out as a message instead (#1133).
             this.logger.warn({ err, instanceName: pending.instanceName }, "Failed to retire prompt buttons; posting the outcome instead");
-            await pending.adapter.sendText(pending.chatId, text, { threadId: pending.threadId })
+            // #1742: with its link button, if it had one — the outcome may be the only way to the DM.
+            await pending.adapter.sendText(pending.chatId, text, { threadId: pending.threadId, ...(urlButtons ? { urlButtons } : {}) })
                 .catch(sendErr => this.logger.warn({ err: sendErr, instanceName: pending.instanceName }, "Could not post a prompt's outcome"));
         }
     }
@@ -11432,6 +12599,8 @@ export class FleetManager {
             }
         };
     }
+    /** #1806: the web's /backend confirmations — one per question, used once, for the arguments and backend asked about. */
+    webBackendTokens = new Map();
     /** #1269: the web's /clear confirmations — one token per question, used once, for the instance as it was asked about. */
     webClearTokens = new Map();
     /** #1269: an instance's chat command from the web chat (web-commands.ts); `publicLink`: a gateway request. */
@@ -11439,8 +12608,10 @@ export class FleetManager {
         const webMeta = (instance) => {
             const topicId = this.fleetConfig?.instances[instance]?.topic_id;
             return {
-                chatId: this.getGroupIdForInstance(instance) || "", messageId: newWebMessageId(), username: "web-user", userId: "web-user",
-                threadId: topicId != null ? String(topicId) : undefined, adapterId: this.getAdapterForInstance(instance)?.id ?? "", source: "web",
+                // #1827: a /steer or /btw reaches the agent as the web person who wrote it.
+                chatId: this.getGroupIdForInstance(instance) || "", messageId: newWebMessageId(),
+                username: opts.person?.name ?? WEB_NAME_FALLBACK, userId: opts.person?.userId ?? WEB_NAME_FALLBACK,
+                threadId: topicId != null ? String(topicId) : undefined, adapterId: this.getAdapterForInstance(instance)?.id ?? "", source: "web", humanOrigin: webHumanOrigin(true),
             };
         };
         const choicesFromCache = (instance) => {
@@ -11470,9 +12641,44 @@ export class FleetManager {
                 const current = this.resolveInstanceEffort(instance).effort;
                 return { current, options: levels.map(l => ({ id: l, label: this.effortChoiceLabel(l, current) })) };
             },
+            backendStep: async (instance, args) => {
+                const refusal = this.backendCommandRefusal(instance);
+                if (refusal)
+                    return { error: refusal };
+                // The cached model lists only, as the web's /model: never a live probe on this path.
+                const step = await backendStep(this.backendCommandDeps(instance, { live: false }), instance, backendArgs(args));
+                if (step.kind === "refuse")
+                    return step.noop ? { text: step.text } : { error: step.text };
+                if (step.kind === "choose") {
+                    const id = (token) => joinBackendArgs([...step.args, token]);
+                    return { choices: { prompt: step.text, current: step.current === null ? null : id(step.current), options: step.choices.map(c => ({ id: id(c.token), label: c.label })) } };
+                }
+                const now = performance.now();
+                for (const [k, v] of this.webBackendTokens)
+                    if (v.deadline < now)
+                        this.webBackendTokens.delete(k);
+                const token = randomBytes(16).toString("hex");
+                this.webBackendTokens.set(token, {
+                    instance, asked: joinBackendArgs(backendArgs(args)), args: step.args, from: step.from,
+                    target: this.fleetConfig.instances[instance], deadline: now + CLASSIC_BACKEND_SELECTION_TIMEOUT_MS,
+                });
+                return { confirm: { token, message: step.text } };
+            },
+            backendConfirm: async (instance, args, token) => {
+                const entry = this.webBackendTokens.get(token);
+                this.webBackendTokens.delete(token); // used once, whatever happens next
+                if (!entry || entry.instance !== instance || entry.asked !== joinBackendArgs(backendArgs(args)) || performance.now() > entry.deadline) {
+                    return { status: 409, text: t("backend.selection_expired") };
+                }
+                // The instance it was asked about: one deleted and created again under the name, stopped or not, is another.
+                const stillCurrent = () => this.backendTargetIs(instance, entry.target);
+                if (!stillCurrent())
+                    return { status: 409, text: t("menu.click_stale") };
+                return { status: 200, text: await this.applyBackendSwitch(instance, entry.args, entry.from, stillCurrent) };
+            },
             cancel: (instance) => this.cancelInstance(instance),
-            steer: (instance, text) => this.topicCommands.sendSteer(instance, text, webMeta(instance)),
-            btw: (instance, text) => this.topicCommands.sendBtw(instance, text, webMeta(instance)),
+            steer: (instance, text, originalBody) => this.topicCommands.sendSteer(instance, text, { ...webMeta(instance), humanOriginalBody: originalBody }),
+            btw: (instance, text, originalBody) => this.topicCommands.sendBtw(instance, text, { ...webMeta(instance), humanOriginalBody: originalBody }),
             pauseWake: (instance, action) => this.topicCommands.runPauseWake(instance, action),
             save: (instance, filename) => this.topicCommands.sendSave(instance, filename),
             clearAsk: (instance) => {
@@ -11743,9 +12949,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);
@@ -11763,9 +12972,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. */
@@ -12578,7 +13788,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),
@@ -12587,11 +13797,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 } } : {}),
                     });
                 },
             });
@@ -12805,10 +14016,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);
@@ -12897,7 +14118,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 = [];
@@ -12905,6 +14128,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;
@@ -12942,14 +14168,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;
@@ -12963,11 +14191,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,
@@ -12979,6 +14209,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);
@@ -13006,7 +14237,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)
@@ -13090,7 +14321,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"));
@@ -13198,8 +14430,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;
         }
@@ -13234,16 +14474,26 @@ export class FleetManager {
         try {
             const store = new WebChatDiskStore({ home: getAgendHome(), logger: this.logger, ownerOf: (name) => this.webChatOwner(name) });
             const names = new Set([...Object.keys(fleet.instances ?? {}), ...(this.classicChannels?.getAll().map(c => c.instanceName) ?? [])]);
-            // A kept message's files are served again under their ids only from the instance's own inbox, by the ledger's
-            // checks (web-upload.ts restoreServed); they leave the ledger with their message.
+            // A kept message's files are served again under their ids only from the instance's own inbox or (#1770) its reply
+            // snapshots, by the ledger's checks (web-upload.ts restoreServed); they leave the ledger with their message.
             this.webChatHistory.setFiles({
                 storablePath: (id) => this.webFiles.storablePath(id),
-                restore: (entry, instance) => this.webFiles.restoreServed(entry, instance, join(getAgendHome(), "workspaces", instance, "inbox")),
+                restore: (entry, instance) => this.webFiles.restoreServed(entry, instance, join(getAgendHome(), "workspaces", instance, "inbox"), webFilesDir(getAgendHome(), instance) ?? undefined),
                 drop: (ids) => this.webFiles.dropServed(ids),
             });
             let restored = 0;
             for (const name of names)
                 restored += this.webChatHistory.restore(name, store.load(name));
+            // #1770: before any instance replies, the snapshots no restored message holds (it left the history while the
+            // fleet was down, or a copy stopped midway) are removed.
+            let swept = 0;
+            for (const name of names) {
+                const dir = webFilesDir(getAgendHome(), name);
+                if (dir)
+                    swept += sweepReplySnapshots(dir, this.webFiles.heldSnapshots(name));
+            }
+            if (swept)
+                this.logger.info({ swept }, "Removed web reply snapshots no message holds");
             this.webChatStore = store;
             this.webChatHistory.setStore(store);
             if (restored)
@@ -14034,12 +15284,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const reactions = this.pendingReactionsMeta(instanceName);
         Object.assign(meta, reactions.meta);
         try {
-            await this.deliverToInstance(instanceName, {
+            await this.deliverHumanToInstance(instanceName, {
                 type: "fleet_inbound",
                 content: fullText,
                 targetSession: instanceName,
                 meta,
-            });
+            }, msg.humanOrigin, msg.humanOriginalBody ?? text);
             reactions.consume();
         }
         catch (err) {
@@ -14056,6 +15306,50 @@ 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, 
+    /** #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 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) {
@@ -14655,7 +15949,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");
@@ -14980,7 +16283,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");
@@ -15008,7 +16320,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** How this instance's backend applies an effort change. */
     effortStrategyFor(instanceName) {
         try {
-            const { strategy, levels } = readEffortMetadata(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            const { strategy, levels } = this.instanceEffortMetadata(instanceName);
             return strategy !== "unsupported" && levels.length > 0 ? strategy : "unsupported";
         }
         catch {
@@ -15018,13 +16330,23 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** Effort levels this instance's backend actually accepts (empty = unsupported). */
     effortLevelsFor(instanceName) {
         try {
-            const { strategy, levels } = readEffortMetadata(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            const { strategy, levels } = this.instanceEffortMetadata(instanceName);
             return strategy === "unsupported" ? [] : levels;
         }
         catch {
             return [];
         }
     }
+    /** The instance's backend's effort metadata; agy's levels are its model's (#1825), the one the instance runs. */
+    instanceEffortMetadata(instanceName) {
+        const backend = this.backendNameForInstance(instanceName);
+        let model = null;
+        if (backend === "antigravity") {
+            const resolved = this.resolveInstanceModel(instanceName);
+            model = resolved.source === "unresolved" ? null : resolved.model;
+        }
+        return readEffortMetadata(backend, this.getInstanceDir(instanceName), model);
+    }
     /** Configured effort for an instance: per-instance, else fleet default, else none. */
     resolveInstanceEffort(instanceName) {
         const own = this.fleetConfig?.instances[instanceName]?.effort;
@@ -15114,21 +16436,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}`);
@@ -15137,6 +16472,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.
      *
@@ -15154,6 +16498,377 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             ? `\n${t("effort.current_fleet", effort)}`
             : `\n${t("effort.current", effort)}`;
     }
+    // ── #1806: /backend — another CLI backend, with its model and effort, in one write and one relaunch ──
+    /** The steps' view of this fleet (backend-command.ts). `live`: a missing or stale model list may be probed (not on the web). */
+    backendCommandDeps(instanceName, opts) {
+        return {
+            currentBackend: (name) => this.backendNameForInstance(name),
+            currentDisplay: (name) => `${this.backendNameForInstance(name)} · ${this.resolveInstanceModel(name).display}`,
+            installedBackends: () => KNOWN_BACKENDS.filter(b => b !== "mock" && this.backendInstalledHere(b)),
+            models: (backend) => this.backendModelOptions(backend, opts),
+            // #1808: the same rule update_instance_config's switch applies (backendModelVerdict).
+            modelKnown: (backend, model) => this.backendModelVerdict(instanceName, backend, model).ok,
+            effortLevels: (backend, model) => this.backendEffortLevels(instanceName, backend, model),
+            inherited: (key) => {
+                const value = getEffectiveInstanceDefaults(this.fleetConfig?.defaults)[key];
+                return typeof value === "string" && value ? value : undefined;
+            },
+            modelCompatible: (backend, model) => isModelCompatible(backend, model),
+            state: (name) => {
+                const status = this.getInstanceStatus(name);
+                return { running: status === "running", busy: status === "running" && !this.getInstanceIdle(name), status };
+            },
+            t: (key, ...args) => t(key, ...args),
+        };
+    }
+    /**
+     * `/effort`'s levels for a backend this instance may move to, for the model that will run there (codex's levels are
+     * per model; null: its configured default). Empty: it has no effort setting. A file read, never a CLI.
+     */
+    backendEffortLevels(instanceName, backend, model = null) {
+        // codex: the model the NEXT launch runs, for the levels and the gate alike (#1807 review r2).
+        let runs = model;
+        if (backend === "codex") {
+            const next = this.prospectiveCodexModel(instanceName, model);
+            if (!next.proven)
+                return [];
+            runs = next.model;
+        }
+        let levels;
+        try {
+            const metadata = readEffortMetadata(backend, this.getInstanceDir(instanceName), runs);
+            levels = metadata.strategy === "unsupported" ? [] : metadata.levels;
+        }
+        catch {
+            return [];
+        }
+        // #1811: only the levels this host's launch of that backend will pass (launch-effort.ts, the gate the launch
+        // itself applies) — an effort chosen here reaches the new CLI with the one relaunch, or is not offered.
+        const takes = this.launchEffortGate(instanceName, backend, runs);
+        return levels.filter(takes);
+    }
+    /**
+     * #1808: whether a backend takes this model name — the one rule for /backend and update_instance_config's switch.
+     * The name must be one its launch line can carry (modelNameCarried); then its offered list (the cached CLI env), and
+     * claude-code's known names (without this instance's configured model, which belongs to the backend being left).
+     * With no list known, the backend's usual name pattern decides.
+     */
+    backendModelVerdict(instanceName, backend, model, 
+    /** The provider the backend will run on (default: this instance's own, else the fleet's). */
+    opts = { provider: this.customProviderFor(instanceName, backend) }) {
+        // A custom provider has its own catalog, which the CLI reads at launch and AgEnD cannot see before one (#1815
+        // review): only the launch-line rule applies — never the account's list or the default provider's naming pattern.
+        if (opts.provider)
+            return modelNameCarried(backend, model) ? { ok: true } : { ok: false, choices: [] };
+        const listed = this.readCliEnv(backend)?.models ?? [];
+        const choices = listed.slice(0, 24).map(o => o.id);
+        if (!modelNameCarried(backend, model))
+            return { ok: false, choices };
+        if (listed.some(o => o.id === model))
+            return { ok: true };
+        if (backend === "claude-code") {
+            const check = this.claudeModelKnown(instanceName, model, null);
+            return check.known ? { ok: true } : { ok: false, choices: check.names };
+        }
+        return listed.length === 0 && isModelCompatible(backend, model) ? { ok: true } : { ok: false, choices };
+    }
+    /**
+     * #1807 review r2: the model codex's next launch of this instance runs. Every launch's writeConfig copies the SHARED
+     * config.toml into the instance's codex home first, so that source decides — not the home's copy from an earlier
+     * launch. Read-only; a model chosen here (`-c model=…`) outranks it; a project file that could change it, unproven.
+     */
+    prospectiveCodexModel(instanceName, model) {
+        const { sharedHome } = codexMetadataHomes(this.getInstanceDir(instanceName));
+        return resolveCodexLaunchModel({
+            isolatedHome: sharedHome, sharedHome, model,
+            workingDirectory: this.fleetConfig?.instances[instanceName]?.working_directory,
+        });
+    }
+    /** #1811: whether a launch of `backend` here would pass a level: the same gate its builder applies. */
+    launchEffortGate(instanceName, backend, model) {
+        if (backend === "claude-code" || backend === "grok" || backend === "antigravity") {
+            const binary = BACKEND_INSTALLATION_INFO[backend]?.binary;
+            if (!binary)
+                return () => false;
+            const path = resolveBinary(binary);
+            return level => flagEffort(backend, level, path).arg !== null;
+        }
+        if (backend === "codex") {
+            // `model` is the next launch's, proven by the caller (prospectiveCodexModel); the catalog is codex's own cache.
+            if (!model)
+                return () => false;
+            const catalog = readCodexModelEffortLevels({ ...codexMetadataHomes(this.getInstanceDir(instanceName)), model });
+            return level => codexEffort(level, catalog).arg !== null;
+        }
+        // kiro-cli gates its own --effort by version at launch (a quiet console note otherwise); muse always passes it.
+        return () => true;
+    }
+    /** Installed the way the launch finds a CLI (resolveBinary): on PATH or in a known install directory. */
+    backendInstalledHere(backend) {
+        const binary = BACKEND_INSTALLATION_INFO[backend]?.binary;
+        return !!binary && resolveBinary(binary) !== binary;
+    }
+    /** The models `/model` would offer on a backend: the cached CLI env, else (live) a bounded probe. Never throws. */
+    async backendModelOptions(backend, opts) {
+        const cached = this.readCliEnv(backend);
+        if (!opts.live || (cached?.models.length && !this.cliEnvNeedsRefresh(cached)))
+            return cached?.models ?? [];
+        opts.onLiveProbe?.();
+        const env = await this.probeBackendBounded(backend).catch(() => null);
+        return env?.models.length ? env.models : cached?.models ?? [];
+    }
+    /**
+     * #1806 review: the instance a `/backend` was asked about is still this config entry — not one deleted and created
+     * again under the same name, or replaced by a Settings edit (both put a new object there), stopped or not.
+     */
+    backendTargetIs(instanceName, target) {
+        const instances = this.fleetConfig?.instances;
+        return !!target && !!instances && Object.prototype.hasOwnProperty.call(instances, instanceName) && instances[instanceName] === target;
+    }
+    /** `/backend` is for fleet.yaml instances: update_instance_config does not manage a ClassicBot agent. */
+    backendCommandRefusal(instanceName) {
+        return this.fleetConfig?.instances && Object.prototype.hasOwnProperty.call(this.fleetConfig.instances, instanceName)
+            ? null : t("backend.classic_unsupported", instanceName);
+    }
+    /**
+     * Apply a confirmed `/backend`: judged again first (a menu lives a minute — the backend may have moved, a CLI been
+     * removed), then update_instance_config's write: backend, model and effort at once, refused and rolled back whole
+     * (its credential-profile login gate included), then one fresh relaunch of a running instance.
+     */
+    async applyBackendSwitch(instanceName, args, from, stillCurrent) {
+        if (this.backendNameForInstance(instanceName) !== from)
+            return t("backend.changed", instanceName, from);
+        if (!stillCurrent())
+            return t("menu.click_stale");
+        const deps = this.backendCommandDeps(instanceName, { live: false });
+        const step = await backendStep(deps, instanceName, args);
+        if (step.kind !== "confirm")
+            return step.kind === "refuse" ? step.text : t("backend.usage");
+        // Asked again after the await, with nothing awaited between here and the write (applyInstanceConfigPatch writes
+        // synchronously): two switches confirmed together, or an instance changed meanwhile, never both succeed.
+        if (this.backendNameForInstance(instanceName) !== from)
+            return t("backend.changed", instanceName, from);
+        if (!stillCurrent())
+            return t("menu.click_stale");
+        const { plan } = step;
+        const shown = planDisplay(deps, plan);
+        const { value, error } = await new Promise(resolve => {
+            applyInstanceConfigPatch(this, instanceName, { backend: plan.backend, model: plan.model, effort: plan.effort }, (value, error) => resolve({ value, error }));
+        });
+        if (error)
+            return t("backend.refused", instanceName, error);
+        const result = (value ?? {});
+        if (result.warning)
+            return t("backend.restart_failed", instanceName, plan.backend, result.warning);
+        if (result.restarted)
+            return t("backend.switched", instanceName, plan.backend, shown.model, shown.effort);
+        return t("backend.switched_not_running", instanceName, plan.backend, shown.model, shown.effort, this.getInstanceStatus(instanceName));
+    }
+    /** A step's buttons: index callbacks (a model id can be longer than Telegram's 64-byte callback data allows). */
+    backendStepButtons(instanceName, nonce, step) {
+        if (step.kind === "choose")
+            return step.choices.map((c, i) => ({ id: `${BACKEND_SELECT_CALLBACK_PREFIX}${nonce}:${i}`, label: c.label }));
+        if (step.kind !== "confirm")
+            return [];
+        const running = this.getInstanceStatus(instanceName) === "running";
+        return [
+            { id: `${BACKEND_SELECT_CALLBACK_PREFIX}${nonce}:0`, label: t(running ? "backend.confirm_button" : "backend.confirm_button_stopped") },
+            { id: `${BACKEND_SELECT_CALLBACK_PREFIX}${nonce}:1`, label: t("backend.cancel_button") },
+        ];
+    }
+    /**
+     * Show a `/backend` step (a choice, or the confirmation) where the command was given: Discord edits its interaction
+     * reply; Telegram retires the previous step's keyboard and posts the next. One pending entry per step, under a fresh
+     * nonce: a click on an older step finds nothing.
+     */
+    async presentBackendStep(place, step) {
+        const nonce = randomBytes(6).toString("hex");
+        const buttons = this.backendStepButtons(place.instanceName, nonce, step);
+        const timer = setTimeout(() => {
+            const p = this.pendingBackendSelects.get(nonce);
+            if (!p)
+                return;
+            this.pendingBackendSelects.delete(nonce);
+            void this.endBackendMenu(p, t("backend.selection_expired")).catch(() => { });
+        }, CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        const pending = { ...place, step, timer };
+        this.pendingBackendSelects.set(nonce, pending);
+        try {
+            if (step.kind === "confirm" && place.respondButtons) {
+                await place.respondButtons(step.text, buttons);
+                return;
+            }
+            if (place.respondChoices) {
+                await place.respondChoices(step.text, buttons);
+                return;
+            }
+            if (!place.adapter || !place.adapterChatId)
+                throw new Error("no place to show the menu");
+            if (place.menuMessageId && place.adapter.editMessageRemoveButtons) {
+                const chosen = t("backend.chosen", joinBackendArgs(step.args));
+                await place.adapter.editMessageRemoveButtons(place.adapterChatId, place.menuMessageId, chosen, place.adapterThreadId).catch(() => { });
+            }
+            const menuMessageId = await place.adapter.promptUser(place.adapterChatId, step.text, buttons, { threadId: place.adapterThreadId });
+            const fresh = this.pendingBackendSelects.get(nonce);
+            if (fresh)
+                fresh.menuMessageId = menuMessageId;
+        }
+        catch (err) {
+            this.pendingBackendSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName: place.instanceName }, "backend menu failed");
+            await place.respond(t("backend.usage")).catch(() => { });
+        }
+    }
+    /** Close a `/backend` menu with a last word: its buttons go (Telegram edits them away), the text stays. Returns where it was said. */
+    async endBackendMenu(pending, text) {
+        if (pending.adapter && pending.adapterChatId) {
+            if (pending.menuMessageId && pending.adapter.editMessageRemoveButtons) {
+                try {
+                    await pending.adapter.editMessageRemoveButtons(pending.adapterChatId, pending.menuMessageId, text, pending.adapterThreadId);
+                    return pending.menuMessageId;
+                }
+                catch { /* say it in a new message */ }
+            }
+            return (await pending.adapter.sendText(pending.adapterChatId, text, { threadId: pending.adapterThreadId })).messageId;
+        }
+        if (pending.retireButtons)
+            await pending.retireButtons(text);
+        else
+            await pending.respond(text);
+        return undefined;
+    }
+    /** Start `/backend` for a fleet instance from Discord or Telegram; the caller has checked the channel admin. */
+    async beginBackendCommand(place, args) {
+        const refusal = this.backendCommandRefusal(place.instanceName);
+        if (refusal) {
+            await place.respond(refusal);
+            return;
+        }
+        if (!place.respondChoices && !(place.adapter && place.adapterChatId)) {
+            await place.respond(t("backend.usage"));
+            return;
+        }
+        place = { ...place, target: this.fleetConfig.instances[place.instanceName] };
+        const deps = this.backendCommandDeps(place.instanceName, {
+            live: true,
+            onLiveProbe: () => { void place.respond(t("model.refreshing")).catch(() => { }); },
+        });
+        const step = await backendStep(deps, place.instanceName, args);
+        if (step.kind === "refuse") {
+            await place.respond(step.text);
+            return;
+        }
+        await this.presentBackendStep(place, step);
+    }
+    /** `/backend` slash handler: channel admin, as `/model`. Options or typed text give the direct form. */
+    async handleBackendSlash(data, adapterId) {
+        if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
+            await data.respond(t("permission.denied"));
+            return;
+        }
+        const name = this.resolveSlashTarget(data.channelId, adapterId);
+        if (!name) {
+            await data.respond(t("classic.no_agent"));
+            return;
+        }
+        const option = (key) => typeof data.options?.[key] === "string" ? data.options[key].trim() : "";
+        const given = [option("backend"), option("model"), option("effort")];
+        // A later option without the one before it says nothing that can be judged in order.
+        if (given.some((value, i) => value && given.slice(0, i).some(before => !before))) {
+            await data.respond(t("backend.usage"));
+            return;
+        }
+        const args = given[0] ? given.filter(Boolean) : backendArgs(data.text ?? "");
+        await this.beginBackendCommand({ instanceName: name, userId: data.userId, channelId: data.channelId, adapterId, respond: data.respond, respondChoices: data.respondChoices,
+            respondButtons: data.respondButtons, retireButtons: data.retireButtons }, args);
+    }
+    /** Telegram `/backend` in a fleet topic (topic-commands) or a ClassicBot chat; the caller has checked the admin. */
+    async runBackendCommand(instanceName, text, userId, channelId, adapter, chatId, threadId, adapterId) {
+        const respond = async (reply) => (await adapter.sendText(chatId, reply, { threadId })).messageId;
+        await this.beginBackendCommand({ instanceName, userId, channelId, adapterId, respond, adapter, adapterChatId: chatId, adapterThreadId: threadId }, backendArgs(text.replace(/^\/backend(@\S+)?/, "")));
+    }
+    /** Consume a `/backend` click: the next step, or on the confirmation the switch itself. True for every backend-select id. */
+    async handleBackendSelection(data, adapterId) {
+        if (!data.callbackData.startsWith(BACKEND_SELECT_CALLBACK_PREFIX))
+            return false;
+        const match = data.callbackData.match(/^backend-select:([0-9a-f]+):(\d{1,2})$/);
+        if (!match)
+            return true;
+        const pending = this.pendingBackendSelects.get(match[1]);
+        if (!pending)
+            return true;
+        // As a /model click (#754 audit): the admin who opened it, through the same bot, in the same channel, still admin.
+        const cbChannel = data.threadId ?? data.chatId;
+        if (!data.userId || data.userId !== pending.userId
+            || (pending.adapterId !== undefined && pending.adapterId !== adapterId)
+            || (cbChannel !== pending.channelId && data.chatId !== pending.channelId)
+            || !this.menuClickStillCurrent(pending.instanceName, data.userId, pending.channelId, adapterId, pending.adapterChatId)) {
+            data.ack?.(t("buttons.admin_only"));
+            return true;
+        }
+        this.pendingBackendSelects.delete(match[1]);
+        clearTimeout(pending.timer);
+        if (!pending.menuMessageId && data.messageId)
+            pending.menuMessageId = data.messageId;
+        const index = Number(match[2]);
+        const { step } = pending;
+        if (step.kind === "choose") {
+            const choice = step.choices[index];
+            if (!choice)
+                return true;
+            if (!this.backendTargetIs(pending.instanceName, pending.target)) {
+                await this.endBackendMenu(pending, t("menu.click_stale")).catch(() => { });
+                return true;
+            }
+            const next = await backendStep(this.backendCommandDeps(pending.instanceName, { live: true }), pending.instanceName, [...step.args, choice.token]);
+            if (next.kind === "refuse") {
+                await this.endBackendMenu(pending, next.text).catch(() => { });
+                return true;
+            }
+            await this.presentBackendStep(pending, next);
+            return true;
+        }
+        if (index === 1) {
+            await this.endBackendMenu(pending, t("backend.cancelled")).catch(() => { });
+            return true;
+        }
+        if (index !== 0)
+            return true;
+        // Confirmed: say so at once, then switch in the background (the relaunch takes a while) and say how it went.
+        const progressId = await this.endBackendMenu(pending, t("backend.switching", pending.instanceName, step.plan.backend)).catch(() => undefined);
+        const say = async (text) => {
+            if (pending.adapter && pending.adapterChatId) {
+                if (progressId)
+                    await pending.adapter.editMessage(pending.adapterChatId, progressId, text, pending.adapterThreadId);
+                else
+                    await pending.adapter.sendText(pending.adapterChatId, text, { threadId: pending.adapterThreadId });
+            }
+            else
+                await pending.respond(text);
+        };
+        void (async () => {
+            let result;
+            try {
+                // Asked again after the awaits above: the instance may have moved, or the admin lost admin.
+                const stillCurrent = () => this.backendTargetIs(pending.instanceName, pending.target)
+                    && this.menuClickStillCurrent(pending.instanceName, data.userId, pending.channelId, adapterId, pending.adapterChatId);
+                result = stillCurrent()
+                    ? await withSpawnHoldReply(say, () => this.applyBackendSwitch(pending.instanceName, step.args, step.from, stillCurrent))
+                    : t("menu.click_stale");
+            }
+            catch (err) {
+                this.logger.error({ err, instance: pending.instanceName, backend: step.plan.backend }, "Backend switch failed");
+                result = t("backend.failed", pending.instanceName, step.plan.backend, err instanceof Error ? err.message : String(err));
+            }
+            await say(result).catch(() => {
+                if (pending.adapter && pending.adapterChatId)
+                    pending.adapter.sendText(pending.adapterChatId, result, { threadId: pending.adapterThreadId }).catch(() => { });
+            });
+        })();
+        return true;
+    }
     /** Read recent chat log for agent context */
     getRecentChatLog(instanceName, maxLines = 10) {
         const logDir = ClassicChannelManager.chatLogDir(instanceName);
@@ -15247,6 +16962,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
@@ -15363,7 +17081,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 */
@@ -15444,12 +17162,29 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const ch = this.classicChannels.unregister(channelId, adapterId);
         if (!ch)
             return t("classic.no_agent");
+        // #1664: the room is gone (not paused or stopped): nobody's favorite any more — unless the name is still an
+        // instance (fleet.yaml's, or another room's), so a later room of the same name does not inherit an old star.
+        if (!Object.hasOwn(this.fleetConfig?.instances ?? {}, ch.instanceName)
+            && !this.classicChannels.getAll().some((c) => c.instanceName === ch.instanceName)) {
+            try {
+                this.webPrefs.forgetInstance(ch.instanceName);
+            }
+            catch (err) {
+                this.logger.warn({ err: err.message, instanceName: ch.instanceName }, "Dropping a removed room from web favorites failed");
+            }
+        }
         this.instanceWorldBinding.delete(ch.instanceName);
-        await this.stopInstance(ch.instanceName).catch(err => this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to stop classic instance"));
+        // #1716: say so in the reply when background work was ended with the stop.
+        // Null-safe: a foreign stopInstance stub may resolve nothing at all.
+        const stopOutcome = await this.stopInstance(ch.instanceName).catch(err => {
+            this.logger.warn({ err, instanceName: ch.instanceName }, "Failed to stop classic instance");
+            return { backgroundWorkEnded: false };
+        });
         clearPausedMarker(this.getInstanceDir(ch.instanceName));
         this.reregisterClassicChannels();
         this.logger.info({ channelId, adapterId, instanceName: ch.instanceName }, "Classic channel stopped");
-        return t("classic.stopped");
+        return t("classic.stopped")
+            + (stopOutcome?.backgroundWorkEnded ? `\n${t("classic.stopped_bg_work")}` : "");
     }
     /**
      * Idempotent while in flight: SIGINT and SIGTERM share one handler and the
@@ -15545,6 +17280,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             clearInterval(this.eventLogPruneTimer);
             this.eventLogPruneTimer = null;
         }
+        this.logService?.unwatchAll(); // #1218: a Log's watch timers end with the fleet
         if (this.outboxPruneTimer) {
             clearInterval(this.outboxPruneTimer);
             this.outboxPruneTimer = null;
@@ -15644,8 +17380,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         this.controlClient = null;
         if (this.healthServer) {
             this.healthServerListening = false;
-            this.healthServer.close();
-            this.healthServer = null;
+            const server = this.healthServer;
+            const drain = this.healthServerDrain ?? trackWebServer(server);
+            await drain.close(this.sseClients);
+            if (this.healthServer === server) {
+                this.healthServer = null;
+                this.healthServerDrain = null;
+            }
         }
         this.stopPreviewListener();
         // The store writes lastSeen at most once a minute; what that debounce is still holding — and any
@@ -15974,8 +17715,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 if (old.backend !== backend || old.model !== model || old.autoPauseAfter !== autoPauseAfter || profile.changed) {
                     this.logger.info({ instanceName: ch.instanceName, ...(profile.changed ? { profileFrom: profile.from, profileTo: profile.to } : {}) }, "Classic cold config changed — restarting");
                     observe?.(ch.instanceName, "restart", "running");
+                    const launchedIn = this.daemons.get(ch.instanceName)?.getConfigSnapshot?.()?.working_directory;
                     await this.stopInstance(ch.instanceName).catch(() => { });
-                    if (profile.startsFresh)
+                    // #1753: the conversation goes along where it can; otherwise a switch that loses it starts fresh.
+                    if (profile.carry)
+                        await this.switchConversation(ch.instanceName, { ...profile.carry, workingDirectory: launchedIn });
+                    else if (profile.startsFresh)
                         this.writeFreshStartMarker(ch.instanceName);
                     await this.startClassicInstanceUnattended(ch, "classic instance after fleet reload");
                     observe?.(ch.instanceName, "restart", "done");
@@ -17614,7 +19359,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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)");
     }
     /** Shared handler dispatcher; gateway admission is enforced by its separate listener. */
-    dispatchWebHttp(req, res, port) {
+    dispatchWebHttp(req, res, port, closing = false) {
         try {
             res.setHeader("Content-Type", "application/json");
             // No Referer to a tunnel host, an upstream proxy, or any page linked from
@@ -17633,6 +19378,11 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 res.end(JSON.stringify({ error: WEB_HOST_REJECTED_MESSAGE }));
                 return;
             }
+            if (closing) {
+                res.writeHead(503, { Connection: "close", "Retry-After": "10" });
+                res.end(JSON.stringify({ error: "fleet stopping" }));
+                return;
+            }
             const requestPath = new URL(req.url ?? "/", `http://localhost:${port}`).pathname;
             // Branding is public, after Host admission: automatic favicon requests
             // must not become noisy web-token 401s in the browser console.
@@ -17818,14 +19568,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}` }));
                     }
@@ -17840,15 +19601,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}` }));
@@ -17931,7 +19701,10 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // Defensive for direct/unit callers; normal startup initializes these before adapters.
         if (!this.webToken || !this.webSessions)
             this.initializeWebAuthTokens();
-        this.healthServer = createServer((req, res) => this.dispatchWebHttp(req, res, port));
+        const server = createServer((req, res) => this.dispatchWebHttp(req, res, port, drain.closing));
+        const drain = trackWebServer(server);
+        this.healthServer = server;
+        this.healthServerDrain = drain;
         const markListening = (afterTakeover = false) => {
             this.healthServerListening = true;
             this.logger.info({ port }, afterTakeover
@@ -17940,7 +19713,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // Never the token: fleet.log is readable by anything that can read the
             // data dir, is copied into bug reports, and is tailed in shared terminals.
             // `/dashboard` and `agend web` are the ways to get an authorized link.
-            this.logger.info({ url: `http://localhost:${port}/ui` }, "Web UI available (open it with /dashboard or `agend web`)");
+            this.logger.info({ url: `http://localhost:${port}/ui` }, "Web UI available (open it with /web or `agend web`)");
             this.logger.info({ url: `http://localhost:${port}/view` }, "Web View available");
             // #1306: the preview listener starts once the web listener is bound — its frame-ancestors name the real port.
             const bound = this.healthServer?.address();
@@ -18017,7 +19790,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)
@@ -18066,6 +19841,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());
     }
@@ -18082,6 +19888,14 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // /api/profiles (resolveInstanceIdentity) — the sidebar groups, searches and labels with it on every page.
         const classicRooms = new Map((this.classicChannels?.getAll() ?? []).map(ch => [ch.instanceName, ch]));
         const profiles = profileIdentities(this.dataDir);
+        // #1630: decorative — whatever goes wrong deciding an avatar never costs the frame (every instance gets its first character).
+        let ownBots = new Map();
+        try {
+            ownBots = this.ownBots();
+        }
+        catch (err) {
+            this.logger.debug({ err }, "own bots unreadable (getUiStatus)");
+        }
         const instances = names.map(name => {
             const statusFile = join(this.getInstanceDir(name), "statusline.json");
             let cost = 0;
@@ -18119,9 +19933,19 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             const effort = (effortStrategy === "unsupported" || isAgy) ? null : effortResolved.effort;
             const effort_source = (effortStrategy === "unsupported" || isAgy) ? null : effortResolved.source;
             const identity = resolveInstanceIdentity({ cfg: this.fleetConfig?.instances[name], classic: classicRooms.get(name), profile: profiles.get(name) });
+            let image;
+            try {
+                image = this.webIdentityImage(name, identity.display_name, profiles.get(name)?.avatar_path, ownBots);
+            }
+            catch (err) {
+                this.logger.debug({ err, name }, "avatar unreadable (getUiStatus)");
+                image = { avatar: avatarFor({ name, displayName: identity.display_name }) };
+            }
             return {
                 name,
                 display_name: identity.display_name || undefined,
+                avatar: image.avatar,
+                ...(image.accent ? { accent: image.accent } : {}),
                 description: identity.description || undefined,
                 role: identity.role || undefined,
                 tags: identity.tags,
@@ -18144,6 +19968,11 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             uptime: Math.floor((Date.now() - this.startedAt) / 1000),
             // #1519 P7: how many chat connections are configured — 0 is a web-only fleet, which gets the first-run card.
             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(),
         };
     }
 }