@songsid/agend 2.2.0-beta.4 → 2.2.0-beta.6

package/dist/fleet-manager.js

@@ -8,8 +8,11 @@ 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";
@@ -28,7 +31,7 @@ import { join, dirname, basename, delimiter, isAbsolute, resolve as resolvePath
 import { fileURLToPath } from "node:url";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
 import { fleetLabel } from "./fleet-label.js";
-import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, setUpdateProgressStage, updateProgressOperation, } from "./update-marker.js";
+import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, 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";
@@ -168,6 +171,7 @@ 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";
@@ -191,7 +195,7 @@ import { localSessionPolicy, tokenEpoch, WebSessionStore } from "./web-session.j
 import { WebLoginCodes, LOGIN_CODE_TTL_MS } from "./web-login.js";
 import { CodeRequestLimiter, ReturningDevices } from "./web-returning-device.js";
 import { allowedHostNames, applyWebSecurityHeaders, hostnameOf, isHostAllowed, WEB_HOST_REJECTED_MESSAGE } from "./web-host-guard.js";
-import { createPreviewListener, previewAvailability, previewSettings } from "./web-preview.js";
+import { createPreviewListener, normalizeOrigin, previewAvailability, previewSettings } from "./web-preview.js";
 import { fleetLevelDifferences, fleetLevelSignature, appendedConnections } from "./fleet-level-config.js";
 import { checkSelfRestartAllowance, recordSelfRestartAttempt } from "./self-restart-limit.js";
 import { SecretStore } from "./secret-store.js";
@@ -201,10 +205,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 { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, 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";
@@ -255,6 +260,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
@@ -619,6 +628,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
@@ -723,6 +737,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;
@@ -735,6 +750,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;
@@ -1780,7 +1802,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
@@ -1790,14 +1812,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
@@ -1817,14 +1842,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;
@@ -2608,6 +2652,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
@@ -3860,12 +3906,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));
@@ -4498,6 +4548,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);
@@ -4505,6 +4558,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);
@@ -4519,6 +4576,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);
@@ -4527,6 +4594,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,
@@ -4535,6 +4604,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);
@@ -4604,10 +4675,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);
@@ -4620,8 +4722,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;
@@ -4642,6 +4746,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");
@@ -4705,7 +4846,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") }));
@@ -4743,6 +4890,61 @@ export class FleetManager {
         }
         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) {
+        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 };
+        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 ?? "") : 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({
@@ -4758,6 +4960,13 @@ export class FleetManager {
                     this.logger.warn("Public session revocation could not be saved; exposure remains closed");
             },
             log: (event, exposureId) => this.logger.info({ event, exposureId }, "Public web link"),
+            createPreview: ({ id, expiresAt, binary, protocol, dashboardOrigin, isCurrent }) => {
+                if (!publicPreviewWanted(this.fleetConfig?.web))
+                    return null;
+                return new PublicPreview({ exposureId: id, expiresAt, dashboardOrigin, isCurrent, manager: this.getPreviewTunnel(),
+                    provider: () => new CloudflaredProvider({ binaryName: binary, protocol }),
+                    log: event => this.logger.info({ event, exposureId: id }, "Public web link") });
+            },
             onCleanupUnconfirmed: (result, owner) => {
                 this.logger.warn({ pid: result.confirmed ? null : result.pid }, "Public web access closed; tunnel cleanup unconfirmed");
                 const world = this.worlds.get(owner.adapterId);
@@ -4913,7 +5122,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;
@@ -4921,7 +5134,7 @@ export class FleetManager {
         const adapter = owner.binding;
         const status = this.getPublicWebStatus();
         const publicAllowed = publicLinkSettings(this.fleetConfig?.web).allowed;
-        const tgHint = adapter.type === "telegram" ? this.tgStartWebUrl(owner.adapterId) : null;
+        const 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)
@@ -4932,7 +5145,7 @@ export class FleetManager {
             ...(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) => {
@@ -4995,6 +5208,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())
@@ -5020,6 +5235,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);
@@ -5065,14 +5281,22 @@ 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
         // #1686: attach the deep-link button on the failure outcome (Telegram only; Discord and the editClicked path ignore urlButtons).
-        const failUrlButtons = (!ok && owner.binding.type === "telegram")
-            ? (() => { const u = this.tgStartWebUrl(adapterId); return u ? [{ label: t("dashboard.start_web_label"), url: u }] : undefined; })()
-            : undefined;
+        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;
     }
@@ -5315,6 +5539,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);
@@ -5328,6 +5632,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)
@@ -5394,6 +5740,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"
@@ -5827,19 +6175,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") {
@@ -5849,6 +6215,7 @@ export class FleetManager {
                         version: agendVersion,
                         pausedNames,
                         failedNames,
+                        backgroundWorkEndedNames,
                     }, pendingUpdateProgress.startedAt);
                 }
                 else if (failedNames.length === 0 && pausedNames.length === 0) {
@@ -5861,6 +6228,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.
@@ -5882,7 +6261,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
@@ -7132,8 +7511,15 @@ export class FleetManager {
     async handleInboundMessage(msg) {
         if (msg.isBotMessage)
             return withSpawnHoldReply(undefined, () => this.handleInboundMessageCore(msg));
-        const adapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapters.get(msg.adapterId ?? "") ?? this.adapter;
-        return withSpawnHoldReply(text => adapter?.sendText(msg.chatId, text, { threadId: msg.threadId }) ?? Promise.resolve(), () => this.handleInboundMessageCore(msg));
+        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
@@ -7167,6 +7553,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.
@@ -7298,10 +7693,17 @@ export class FleetManager {
                     // #1686: intercept /start web before the ClassicBot admission flow runs.
                     // /start alone already opens the DM for future bot-to-user messages — no further action needed.
                     const requestedBackend = text.slice("/start".length).trim().split(/\s+/, 1)[0] || undefined;
-                    if (requestedBackend === "web" && isPrivateChat) {
-                        if (this.isFleetAdmin(msg.userId, msg.adapterId ?? "")) {
-                            await msgAdapter?.sendText(chatId, t("dashboard.start_web_ack"));
-                        }
+                    // #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;
                     }
@@ -7728,9 +8130,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 */
@@ -11543,7 +11950,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"));
         }
     }
@@ -15982,11 +16390,17 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             }
         }
         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
@@ -16181,8 +16595,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
@@ -16511,8 +16930,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");
@@ -18151,7 +18574,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
@@ -18170,6 +18593,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.
@@ -18488,7 +18916,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
@@ -18574,7 +19005,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)
@@ -18623,6 +19056,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());
     }