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

package/dist/fleet-manager.js

@@ -1,3 +1,4 @@
+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";
@@ -8,6 +9,7 @@ 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";
@@ -30,7 +32,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, updateReceiptOf, } 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";
@@ -137,6 +139,7 @@ import { WebPrefsStore } from "./web-prefs.js";
 import { ReplyButtonStore, parseReplyButtons, replyButtonClickText, replyButtonsFallbackText, REPLY_BUTTON_PREFIX } from "./reply-buttons.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
 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";
@@ -170,6 +173,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";
@@ -203,7 +207,8 @@ 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 { cleanupWatchVerdict, formatRestartProgressCompletion, RESTART_PROGRESS_TERMINAL_TIMEOUT_MS, RestartProgress, } from "./restart-progress.js";
@@ -257,6 +262,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
@@ -621,6 +630,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
@@ -725,6 +739,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;
@@ -776,6 +791,10 @@ 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;
@@ -1176,7 +1195,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,
@@ -1185,7 +1204,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
@@ -1304,6 +1323,7 @@ export class FleetManager {
             deliveryId: admitted.delivery.deliveryId,
             state: admitted.delivery.state,
             duplicate: !admitted.inserted,
+            kind: admitted.delivery.kind,
         };
     }
     queryDurableDeliveryStatus(callerInstance, selector) {
@@ -1789,7 +1809,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
@@ -1829,20 +1849,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.
-        // #1660 exception: an update still owing its retire outcome keeps its
-        // receipt until the cleanup watch resolves it — deleting it here is what
-        // lost the warning. Terminal stages are still cleared unconditionally.
-        const leftover = readUpdateProgress(this.dataDir)?.progress;
-        if (!(leftover?.cleanup === "pending" && leftover.stage !== "failed" && leftover.stage !== "complete")) {
-            clearUpdateMarker(this.dataDir);
-        }
+        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;
@@ -2626,6 +2659,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
@@ -2961,7 +2996,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())
@@ -2996,7 +3031,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`);
@@ -3214,6 +3249,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);
@@ -3406,7 +3536,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") {
@@ -3551,7 +3681,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;
@@ -3561,7 +3692,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);
         }
@@ -3571,14 +3702,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);
         }
@@ -3878,12 +4010,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));
@@ -4516,6 +4652,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);
@@ -4523,6 +4662,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);
@@ -4537,6 +4680,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);
@@ -4545,6 +4698,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,
@@ -4553,6 +4708,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);
@@ -4622,10 +4779,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);
@@ -4638,8 +4826,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;
@@ -4660,6 +4850,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");
@@ -4767,6 +4994,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({
@@ -4781,13 +5063,13 @@ 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 => this.logger.info({ event, exposureId: id }, "Public web link") });
+                    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");
@@ -4944,7 +5226,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;
@@ -4952,7 +5238,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)
@@ -4963,7 +5249,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) => {
@@ -5026,6 +5312,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())
@@ -5051,6 +5339,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);
@@ -5096,14 +5385,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;
     }
@@ -5352,6 +5649,39 @@ export class FleetManager {
      * 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)
@@ -5514,6 +5844,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"
@@ -5947,32 +6279,37 @@ export class FleetManager {
             const _require = createRequire(import.meta.url);
             const agendVersion = _require("../package.json").version ?? "unknown";
             await progressStart;
-            // #1660: when the adopted update still owes its retire outcome, the
-            // completion posts without the warning and this same summary object is
-            // kept for the watch to append it to the same receipt later. Waiting
-            // for cleanup before READY would deadlock with the updater (it retires
-            // only after the restart returns), so READY and cleanup notification
-            // have separate lifecycles (review checklist 3/5).
+            // #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);
-            if (pendingUpdateProgress && pendingProgressOperation === "update"
-                && pendingUpdateProgress.progress.cleanup === "pending") {
-                const receipt = updateReceiptOf(pendingUpdateProgress);
-                if (receipt)
-                    this.armCleanupWatch(receipt, 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") {
@@ -5982,6 +6319,7 @@ export class FleetManager {
                         version: agendVersion,
                         pausedNames,
                         failedNames,
+                        backgroundWorkEndedNames,
                     }, pendingUpdateProgress.startedAt);
                 }
                 else if (failedNames.length === 0 && pausedNames.length === 0) {
@@ -5994,9 +6332,18 @@ export class FleetManager {
                     text = t("fleet.ready_with_failed", started, total, agendVersion, failedNames.join(", "))
                         + (pausedNames.length > 0 ? `\n⏸ Paused: ${pausedNames.join(", ")}` : "");
                 }
-                // #1660: a pending cleanup warning cannot be present yet (the updater
-                // retires only after the restart returns); the watch appends it to
-                // the adopted message when the outcome lands. Nothing to add here.
+                // #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.
@@ -6018,7 +6365,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
@@ -7266,10 +7613,18 @@ 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));
-        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
@@ -7303,6 +7658,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.
@@ -7434,10 +7798,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;
                     }
@@ -7701,7 +8072,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,
@@ -7722,7 +8093,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)}`);
@@ -7802,7 +8173,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
@@ -7821,7 +8192,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();
@@ -7864,9 +8235,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 */
@@ -8124,7 +8500,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");
@@ -8177,6 +8553,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
@@ -8194,27 +8571,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) {
@@ -11679,7 +12103,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"));
         }
     }
@@ -11982,7 +12407,7 @@ export class FleetManager {
             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",
+                threadId: topicId != null ? String(topicId) : undefined, adapterId: this.getAdapterForInstance(instance)?.id ?? "", source: "web", humanOrigin: webHumanOrigin(true),
             };
         };
         const choicesFromCache = (instance) => {
@@ -12013,8 +12438,8 @@ export class FleetManager {
                 return { current, options: levels.map(l => ({ id: l, label: this.effortChoiceLabel(l, current) })) };
             },
             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) => {
@@ -13810,16 +14235,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)
@@ -14610,12 +15045,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) {
@@ -16118,11 +16553,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
@@ -16317,8 +16758,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
@@ -16647,8 +17093,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");
@@ -18287,7 +18737,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
@@ -18306,6 +18756,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.
@@ -18624,7 +19079,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