@songsid/agend 2.3.1 → 2.3.2-beta.10

package/dist/fleet-manager.js

@@ -1,3 +1,7 @@
+import { hasLegacyOffice, normalizeOfficeStorage } from "./dashboard-permissions.js";
+import { loginNoticeMode, normalizeNoticeDelivery, setNoticeMode } from "./notice-delivery.js";
+import { DEFAULT_REPLY_TRIGGERS } from "./reply-triggers.js";
+import { WorkingRecoveryCoordinator, WORKING_RECOVERY_KIND, buildWorkingRecoveryPrompt } from "./working-recovery.js";
 import { PUBLIC_TUNNEL_TOKEN_ENV, PUBLIC_TUNNEL_TOKEN_HINT, normalizePublicTunnelToken } from "./public-tunnel-config.js";
 import { humanOwnerObjectId, webHumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsBaselines } from "./settings-baseline.js";
@@ -18,6 +22,9 @@ import { PublicLinkAutoOpen } from "./public-link-auto-open.js";
 import { clearPublicLinkOwner, readPublicLinkOwner, writePublicLinkOwner } from "./public-link-owner.js";
 import { PUBLIC_PREVIEW_FRAME_SRC, PUBLIC_PREVIEW_TUNNEL_DIR, PublicPreview, publicPreviewWanted } from "./public-preview.js";
 import { CloudflaredProvider } from "./tunnel/cloudflared.js";
+import { ensureCloudflared } from "./tunnel/cloudflared-install.js";
+import { OFFICE_SHARE_TUNNEL_DIR, OfficeShareService } from "./office-share-service.js";
+import { ALL_OFFICES } from "./office-share.js";
 import { TunnelPurposeLane } from "./tunnel/purpose-lane.js";
 import { ManagedTunnel } from "./tunnel/manager.js";
 import { withinBudget } from "./monotonic-budget.js";
@@ -27,13 +34,16 @@ import { ProfileControlServer } from "./profile-control.js";
 import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, lstatSync, constants as fsConstants, closeSync } from "node:fs";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { freemem, totalmem, cpus, homedir } from "node:os";
+import { freemem, totalmem, homedir } from "node:os";
+import { effectiveCpuCount } from "./cpu-quota.js";
 import { createServer } from "node:http";
 import { Worker } from "node:worker_threads";
 import { ProbeWorkerPool } from "./probe-worker-pool.js";
 import { join, dirname, basename, delimiter, isAbsolute, relative, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
+import { applyKiroMigration, kiroMigrationPrompt, planKiroMigration } from "./kiro-migrate.js";
 import { fleetLabel } from "./fleet-label.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";
@@ -52,7 +62,7 @@ const __dirname = dirname(__filename);
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
 import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiImageUrl, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
 import { isProbeableRouteTarget } from "./fleet-context.js";
-import { getEffectiveInstanceDefaults, loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
+import { getEffectiveInstanceDefaults, loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG, autoGeneralInstanceConfig } from "./config.js";
 import { EventLog } from "./event-log.js";
 import { binaryProbe } from "./binary-probe.js";
 import { AVAILABILITY_STALE_MS, BackendAvailabilityStore, hostAvailabilityProbes } from "./backend-availability.js";
@@ -158,6 +168,8 @@ import { agendVersion } from "./agent-whats-new.js";
 import { OwnerCssStore } from "./web-owner-css-store.js";
 import { ThemeStore } from "./web-theme-store.js";
 import { OfficeStore, OfficeWriteLimiter } from "./web-office-store.js";
+import { OfficeSkinStore } from "./web-office-skins.js";
+import { OfficeActs } from "./web-office-acts.js";
 import { WebAppearance } from "./web-appearance.js";
 import { WebEffectLibrary } from "./web-effect-library.js";
 import { WebEffectTrials } from "./web-effect-trials.js";
@@ -187,7 +199,7 @@ import { discordGeneralChannelId } from "./discord-general.js";
 import { parseEnvText } from "./env-file.js";
 import { isDisallowedIntentsError, isRejectedTokenError } from "./discord-permissions.js";
 import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
-import { LOGIN_FLOWS, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
+import { LOGIN_FLOWS, checkAuthStatus, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
 import { LoginSession } from "./login-manager.js";
 import { runOnLoginShell } from "./login-shell.js";
 import { tightenInstanceDirs } from "./private-dir.js";
@@ -207,12 +219,16 @@ import { admitProfileLogin, LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOG
 import { WebBackendLogins, dashboardSignInSupported } from "./web-backend-login.js";
 import { runBeforeDeadline } from "./deadline.js";
 import { LoginWindowLock } from "./login-window-lock.js";
+import { BrowserBackendSignIns } from "./browser-backend-signins.js";
+import { createStructuredSignInTransport } from "./structured-signin-transport.js";
+import { ONBOARDING_BACKENDS, readPendingBackendSignIns } from "./backend-signin-pending.js";
+import { structuredSignInSupported } from "./structured-signin.js";
 import { handleSettingsRequest } from "./settings-api.js";
 import { setLocale, detectLocale, getLocale, t } from "./locale.js";
 import { recentChatContext } from "./log-tail.js";
 import { describeSignalSource, recordInternalRequest, withOrigin } from "./fleet-control-audit.js";
 import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
-import { ClassicChannelManager, classicWebEchoOn, getClassicBackendChoices, inferClassicChannelType, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
+import { ClassicChannelManager, classicWebEchoOn, getClassicBackendChoices, inferClassicChannelType, isSelectableClassicBackend, readClassicLastActivityAt, readClassicRoomNames } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
 import { KNOWN_BACKENDS, validateFleetConfig } from "./config-validator.js";
 import { isRemovedBackend, removedBackendMessage } from "./backend/removed.js";
@@ -270,6 +286,7 @@ import { PROVIDER_SECRET_SPECS, PUBLIC_TUNNEL_SECRET_SPEC, providerSecretSpec, p
 /** 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 { kiroHome } from "./backend/kiro-kas-store.js";
 import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileLogin, credentialProfileLoginCommand, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
 import { carryClaudeConversation } from "./backend/claude-carry.js";
 import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
@@ -467,6 +484,10 @@ const OOM_RETRY_CALLBACK_PREFIX = "oom-retry:";
 const NEEDS_PAUSE_TTL_MS = 10_000;
 const HANG_CALLBACK_PREFIX = "hang:";
 const CLEAR_CONFIRM_CALLBACK_PREFIX = "clear-confirm:";
+/** #2598 B2: a kiro classic → TUI move's Confirm in General. "kiro-migrate:" (13) + 32 hex + ":confirm" (8) = 53 bytes. */
+const KIRO_MIGRATE_CALLBACK_PREFIX = "kiro-migrate:";
+/** Long enough for an admin to read the prompt; the move is judged again on the click. */
+const KIRO_MIGRATE_TIMEOUT_MS = 10 * 60_000;
 /**
  * The prompts the web dashboard also offers: the ones about an instance's own health, which a dashboard
  * user — holding the full-fleet web credential — may answer exactly as a fleet admin on the platform may.
@@ -562,6 +583,7 @@ export const CLI_ENV_PROBE_DEADLINE_MS = 16_000;
  * started ten CLIs together, saturated the CPU, and healthy starts then missed
  * their startup budget — which used to cost the user their conversation. Cores
  * bound how many can actually make progress; memory bounds how many fit.
+ * `cores` is what this process may use (cpuset and cgroup quota, #749), not the host's count.
  */
 export function deriveSpawnConcurrency(freeMemMB, cores) {
     const byMemory = Math.floor(freeMemMB / 300);
@@ -605,6 +627,99 @@ export class FleetManager {
     managerBootId = randomUUID();
     deliveryOutbox = null;
     deliveryOutboxRecovered = false;
+    workingRecovery = null;
+    workingRecoveryTimer = null;
+    workingRecoveryCause = "unknown_interruption";
+    workingRecoveryGroup = this.managerBootId;
+    recoveryEnabled(name) {
+        const own = this.fleetConfig?.instances[name]?.resume_interrupted_work;
+        return own ?? this.fleetConfig?.defaults?.resume_interrupted_work ?? true;
+    }
+    initializeWorkingRecovery(outbox) {
+        const store = outbox.workingRecovery;
+        this.workingRecoveryCause = store.beginRun(this.managerBootId, process.pid, Date.now());
+        this.workingRecovery = new WorkingRecoveryCoordinator({
+            store, now: () => performance.now(), active: () => this.startupComplete && !this.shuttingDown && outbox.isOpen,
+            pressure: () => {
+                const p = this.memoryPressure.snapshot();
+                return p.sampledAt === null || Date.now() - p.sampledAt > 60_000 ? { ...p, level: "unknown" } : p;
+            }, storm: () => this.stormWindow.isActive(),
+            enabled: name => this.recoveryEnabled(name),
+            live: name => {
+                const daemon = this.daemons.get(name);
+                if (this.sessionOomStopped(name))
+                    return { owner: "", configuration: "", sessionId: null, idle: false,
+                        paused: false, stopped: true, legacyPending: false, legacyCovered: false, nativeWork: false, cancelled: false, background: null };
+                return daemon?.getWorkingRecoveryState?.() ?? null;
+            },
+            card: id => this.scheduler?.db.board.findCard(id) ?? (this.scheduler ? undefined : null),
+            laneFree: name => !this.isInstanceRestarting(name) && !this.activeDurableTargets.has(name)
+                && outbox.countForTarget(name, ["queued", "retry_wait", "delivering", "submission_started", "reconciliation_pending"]) === 0,
+            admit: (episode, tasks, advisory) => outbox.admitWorkingRecovery(episode, buildWorkingRecoveryPrompt(tasks, this.workingRecoveryCause, advisory), advisory),
+            summary: (group, rows) => {
+                const general = this.findGeneralInstance();
+                if (!general || !this.daemons.has(general))
+                    return;
+                // Our own informational notice must not supersede General's recovery
+                // as unrelated pending work before it crosses the input boundary.
+                const generalEpisode = store.get(general);
+                if (generalEpisode?.outcome === "admitted" && generalEpisode.deliveryId) {
+                    const state = outbox.get(generalEpisode.deliveryId)?.state;
+                    if (!state || !["delivered", "uncertain", "failed", "cancelled"].includes(state))
+                        return;
+                }
+                const deferredAdvisories = rows.filter(row => row.outcome === "deferred"
+                    && (this.daemons.get(row.instance)?.getWorkingRecoveryState?.().background ?? null) === null)
+                    .map(row => `${row.instance} (${row.reason})`);
+                const posted = store.summary(group, () => outbox.admitSystemNotice(general, `working-recovery-summary:${group}`, `[system:working-recovery-summary] Observed cause: unknown interruption${this.workingRecoveryCause === "unknown_interruption" ? "" : `; prior requested action: ${this.workingRecoveryCause}`}. ${rows.length} interrupted instances; continuation queued ${rows.filter(r => r.outcome === "admitted").length}, excluded ${rows.filter(r => r.outcome === "excluded").length}, still deferred ${rows.filter(r => r.outcome === "deferred").length}. ${rows.filter(r => r.reason === "advisory_background_unknown").length ? `Advisory, background unknown: ${rows.filter(r => r.reason === "advisory_background_unknown").map(r => r.instance).join(", ")}. ` : ""}${deferredAdvisories.length ? `Deferred advisory candidates (background unknown; all other gates still apply): ${deferredAdvisories.join(", ")}. ` : ""}Details are in the Log. Deferred work remains eligible; no action or confirmation is requested.`));
+                if (posted) {
+                    const counts = { interrupted: rows.length, queued: rows.filter(row => row.outcome === "admitted").length,
+                        excluded: rows.filter(row => row.outcome === "excluded").length, deferred: rows.filter(row => row.outcome === "deferred").length };
+                    const requestedAction = this.workingRecoveryCause === "unknown_interruption" ? null : this.workingRecoveryCause;
+                    this.logger.info({ group, ...counts, observedCause: "unknown_interruption", requestedAction }, "Interrupted work recovery summary queued for General");
+                    this.eventLog?.insert(general, "working_state", { reason: "recovery_summary", group, ...counts,
+                        observedCause: "unknown_interruption", requestedAction,
+                        message: `Interrupted work summary queued for General: ${counts.interrupted} interrupted; ${counts.queued} queued, ${counts.excluded} excluded, ${counts.deferred} deferred.` });
+                }
+            },
+            log: (episode, outcome, reason) => {
+                const requestedAction = this.workingRecoveryCause === "unknown_interruption" ? null : this.workingRecoveryCause;
+                this.logger.info({ name: episode.instance, episode: episode.key, outcome, reason,
+                    observedCause: "unknown_interruption", requestedAction }, "Interrupted work recovery decision");
+                this.eventLog?.insert(episode.instance, "working_state", {
+                    message: `Interrupted work: ${outcome} (${reason}); observed cause unknown_interruption${requestedAction ? `; prior requested action ${requestedAction}` : ""}.`,
+                    reason, outcome, observedCause: "unknown_interruption", requestedAction
+                });
+            },
+        });
+        if (this.workingRecoveryTimer)
+            clearInterval(this.workingRecoveryTimer);
+        this.workingRecoveryTimer = setInterval(() => {
+            if (!outbox.isOpen || this.shuttingDown)
+                return;
+            try {
+                this.workingRecovery?.tick();
+                this.scheduleDeliveryOutboxPump();
+            }
+            catch {
+                this.logger.warn("Working recovery deferred: prerequisites or durable store unavailable");
+            }
+        }, 1_000);
+        this.workingRecoveryTimer.unref?.();
+    }
+    recoveryDeliveryEligible(row, writing = false) {
+        if (row.kind !== WORKING_RECOVERY_KIND)
+            return true;
+        const outbox = this.deliveryOutbox, episode = outbox?.workingRecovery.get(row.targetInstance);
+        if (!episode || episode.deliveryId !== row.deliveryId
+            || outbox.hasOtherPendingWork(row.targetInstance, row.deliveryId)
+            || this.workingRecovery?.verdict(episode).outcome === "excluded") {
+            outbox?.withdrawWorkingRecovery(row.deliveryId, "recovery superseded or no longer authorized before input");
+            return false;
+        }
+        return (writing ? this.workingRecovery?.accepts(row.targetInstance, episode.key)
+            : this.workingRecovery?.canDispatch(row.targetInstance, episode.key)) === true;
+    }
     /** Phase 2b: wakes paused targets for queued durable work (delivery_worker ≠ off). */
     wakeCoordinator = null;
     /**
@@ -796,6 +911,8 @@ export class FleetManager {
     pendingBackendSelects = new Map();
     /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
     pendingNonceButtons = new Map();
+    /** #2598 B2: the kiro moves waiting on a fleet admin's Confirm in General, by prompt nonce. */
+    pendingKiroMigrations = new Map();
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     needsYou = null;
     /** When the fleet first saw an instance crashed, for its "Needs you" age; cleared when it is not. */
@@ -1054,9 +1171,106 @@ export class FleetManager {
     }
     officeStoreInstance;
     /** Fleet → Org chart → Office: the offices people made (web-offices.json, beside web-themes.json). */
-    get officeStore() { return (this.officeStoreInstance ??= new OfficeStore(this.dataDir)); }
+    get officeStore() { return (this.officeStoreInstance ??= new OfficeStore(this.dataDir, id => this.officeSkins.pack(id))); }
+    officeSkinsInstance;
+    /** #2513: the Office view's uploaded skin packs (<AGEND_HOME>/web-office-skins/). */
+    get officeSkins() { return (this.officeSkinsInstance ??= new OfficeSkinStore(this.dataDir)); }
+    /** How often a person may upload or delete a skin pack; memory only, as the offices' limiter. */
+    officeSkinWrites = new OfficeWriteLimiter(undefined, { perWindow: 10, windowMs: 60_000 });
     /** How often a person may save the offices (PUT /ui/offices); memory only, as the appearance limiter. */
     officeWrites = new OfficeWriteLimiter();
+    officeSharesInstance;
+    /**
+     * #2636: Office share links — the live Office view for people outside the fleet, read-only, on a quick tunnel of
+     * their own (a manager and lease of its own: never the fleet's one tunnel lane nor the public link's preview tunnel).
+     */
+    get officeShares() {
+        return (this.officeSharesInstance ??= new OfficeShareService({
+            source: {
+                status: () => this.getUiStatus(),
+                org: () => this.orgChart(),
+                offices: () => this.officeStore.list(),
+                acts: () => this.officeActs.live(),
+                traffic: () => this.trafficSnapshot(),
+                needs: () => this.needsYouItems().map(i => i.instance),
+                hidden: name => crossInstanceVisibility(this.fleetConfig, name) === "hidden",
+                skins: this.officeSkins,
+            },
+            manager: new ManagedTunnel({ dataDir: join(this.dataDir, OFFICE_SHARE_TUNNEL_DIR), log: () => this.logger.warn("Office share tunnel cleanup requires attention") }),
+            ensure: signal => ensureCloudflared({ dataDir: this.dataDir, pinnedOnly: true, signal }),
+            provider: binary => new CloudflaredProvider({ binaryName: binary, protocol: this.fleetConfig?.web?.public_link?.protocol ?? "http2" }),
+            config: () => this.fleetConfig?.web?.office_share,
+            officeExists: id => this.officeStore.list().offices.some(o => o.id === id),
+            ownerCurrent: owner => this.officeShareOwnerCurrent(owner),
+            changed: () => this.emitSseEvent("office_shares", {}),
+            log: (event, detail) => this.logger.info({ event, ...(detail ? { detail } : {}) }, "Office share link"),
+        }));
+    }
+    /**
+     * #2636: a share made or ended — said in General, as a sign-in is (who, which office, for how long; never its URL).
+     * `share` null with `count`: "Revoke all".
+     */
+    officeShareNotice(event, who, share, count) {
+        const office = !share ? "" : share.office === ALL_OFFICES ? t("office_share.all") : this.officeStore.list().offices.find(o => o.id === share.office)?.name ?? share.office;
+        const minutes = share ? Math.round((share.expiresAt - share.createdAt) / 60_000) : 0;
+        const text = event === "created" ? t("office_share.created_notice", who, office, minutes < 60 ? `${minutes} min` : `${Math.round(minutes / 60)} h`)
+            : share ? t("office_share.revoked_notice", who, office) : t("office_share.revoked_all_notice", who, count);
+        this.notifyFleetError(text, { throttle: false });
+    }
+    /** A share's owner: a person (`person:<adapter>:<user>`) still a fleet admin there; the host's own admin session stays. */
+    officeShareOwnerCurrent(owner) {
+        const m = /^person:([^:]+):(.+)$/.exec(owner);
+        if (!m)
+            return owner === "admin-session";
+        return this.hasFleetAdmins(m[1]) && this.isFleetAdmin(m[2], m[1]);
+    }
+    officeActsInstance;
+    /** #2578: the agents' acts in the Office view (office_view / office_set), memory only; every change is `office_acts`. */
+    get officeActs() {
+        return (this.officeActsInstance ??= new OfficeActs({
+            offices: () => this.officeStore.list().offices,
+            pack: id => this.officeSkins.pack(id),
+            chart: () => { const c = this.orgChart(); return { names: Object.keys(c.instances), teams: c.teams }; },
+            people: () => this.officePeople(),
+            changed: acts => this.emitSseEvent("office_acts", { acts, now: Date.now() }),
+        }));
+    }
+    /**
+     * #2578: each instance's state as the org chart shows it (fleet-org.js orgState, from the same fields the status
+     * frame and the Needs-you list carry) and its display name (resolveInstanceIdentity, as getUiStatus) — read once.
+     */
+    officePeople() {
+        const needs = new Map();
+        for (const item of this.needsYouItems())
+            needs.set(item.instance, (needs.get(item.instance) ?? 0) + 1);
+        const classicRooms = new Map((this.classicChannels?.getAll() ?? []).map(ch => [ch.instanceName, ch]));
+        let profiles = null;
+        return {
+            stateOf: name => {
+                if (!this.isKnownInstance(name))
+                    return "missing";
+                const p = this.instancePresentation(name), status = this.getInstanceStatus(name);
+                if (p.state === "awaiting_input" || (needs.get(name) ?? 0) > 0)
+                    return "needs";
+                if (p.startup_phase === "queued" || p.startup_phase === "starting")
+                    return p.startup_phase;
+                if (status === "crashed" || status === "paused")
+                    return status;
+                if (status !== "running")
+                    return "stopped";
+                return p.execution_state === "stuck" || p.execution_state === "working" ? p.execution_state : "idle";
+            },
+            displayName: name => {
+                try {
+                    profiles ??= profileIdentities(this.dataDir);
+                    return resolveInstanceIdentity({ cfg: this.fleetConfig?.instances[name], classic: classicRooms.get(name), profile: profiles.get(name) }).display_name || undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            },
+        };
+    }
     /** #1629: the theme tools, a person's reset and lock, and the one appearance rate limiter (shared with effects). */
     get webAppearance() {
         return (this.webAppearanceService ??= new WebAppearance(this.themeStore, () => this.fleetConfig?.web ?? null, () => { try {
@@ -1582,6 +1796,74 @@ export class FleetManager {
         // No platform confirmation was reachable. Host inspection is still required.
         this.logger.info({ id: view.id }, "Settings change requires local `agend settings confirm <id>`");
     }
+    kiroMigrateDeps() {
+        return {
+            agendHome: getAgendHome(),
+            fleetConfig: () => this.fleetConfig,
+            saveFleetConfig: () => this.saveFleetConfig(),
+            status: name => this.getInstanceStatus(name),
+            restart: name => this.restartSingleInstance(name, { explicit: true }),
+        };
+    }
+    /**
+     * #2598 B2, migrate_kiro_instance: judge the move, then ask in General for a fleet admin's Confirm. Nothing changes
+     * here; the move runs on the Confirm (handleKiroMigrateCallback), judged again then.
+     */
+    async requestKiroMigration(name, startFresh) {
+        const judged = planKiroMigration(this.kiroMigrateDeps(), name, startFresh);
+        if (!judged.ok)
+            return judged;
+        const general = this.findGeneralInstance();
+        const adapterId = general ? this.getInstanceAdapterId(general) : undefined;
+        const adapter = general ? this.getAdapterForInstance(general) : undefined;
+        const chatId = general ? this.getGroupIdForInstance(general) : undefined;
+        const topic = general ? String(this.fleetConfig?.instances[general]?.topic_id ?? "") : "";
+        if (!general || !adapterId || !adapter || !chatId)
+            return { ok: false, error: t("kiro_migrate.no_general") };
+        const { plan } = judged;
+        try {
+            const nonce = await this.postNonceButtonPromptOrThrow({
+                prefix: KIRO_MIGRATE_CALLBACK_PREFIX, alertType: "clear_confirm", instanceName: name, adapter, adapterId, chatId,
+                ...(topic ? { threadId: topic } : {}),
+                message: kiroMigrationPrompt(plan, this.getInstanceStatus(name) === "running"),
+                choices: [{ action: "confirm", label: t("kiro_migrate.confirm_button") }, { action: "cancel", label: t("kiro_migrate.cancel_button") }],
+                expiredText: t("kiro_migrate.expired", name),
+                timeoutMs: KIRO_MIGRATE_TIMEOUT_MS,
+            });
+            this.pendingKiroMigrations.set(nonce, plan);
+            const expiry = setTimeout(() => this.pendingKiroMigrations.delete(nonce), KIRO_MIGRATE_TIMEOUT_MS + 60_000);
+            expiry.unref?.();
+        }
+        catch (err) {
+            return { ok: false, error: `${t("kiro_migrate.no_general")} (${err.message})` };
+        }
+        return { ok: true, text: t("kiro_migrate.requested"), classic_conversation: plan.classicId };
+    }
+    /** A fleet admin's Confirm or Cancel on a kiro move. Any fleet admin (the default nonce authorization), in General. */
+    async handleKiroMigrateCallback(data, adapterId, adapter) {
+        const claimed = this.consumeNonceCallback(KIRO_MIGRATE_CALLBACK_PREFIX, /^kiro-migrate:([0-9a-f]{32}):(confirm|cancel)$/, data, adapterId, adapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry, action } = claimed;
+        const nonce = data.callbackData.slice(KIRO_MIGRATE_CALLBACK_PREFIX.length, KIRO_MIGRATE_CALLBACK_PREFIX.length + 32);
+        const plan = this.pendingKiroMigrations.get(nonce);
+        this.pendingKiroMigrations.delete(nonce);
+        const messageId = entry.messageId ?? data.messageId;
+        if (action === "cancel" || !plan) {
+            await this.retireNonceButtons(entry, messageId, t(plan ? "kiro_migrate.cancelled" : "kiro_migrate.expired", entry.instanceName));
+            return true;
+        }
+        this.eventLog?.insert(plan.name, "kiro_migrate", { classicId: plan.classicId, userId: data.userId });
+        await this.retireNonceButtons(entry, messageId, t("kiro_migrate.applying", plan.name));
+        const outcome = await applyKiroMigration(this.kiroMigrateDeps(), plan);
+        this.logger.info({ name: plan.name, ok: outcome.ok, classicId: plan.classicId }, "kiro classic → TUI move");
+        this.notifyFleetError(outcome.text);
+        if (outcome.ok)
+            this.notifyInstanceTopic(plan.name, outcome.text);
+        return true;
+    }
     async handleSettingsChangeCallback(data, adapterId, adapter) {
         const result = this.consumeNonceCallback("settings-confirm:", /^settings-confirm:([0-9a-f]{32}):(confirm|reject)$/, data, adapterId, adapter, undefined, (userId, entry) => entry.confirmationAdmin?.(userId) === true);
         if (!result)
@@ -1846,6 +2128,7 @@ export class FleetManager {
         }
         this.deliveryOutbox = outbox;
         this.deliveryOutboxRecovered = true;
+        this.initializeWorkingRecovery(outbox);
         outbox.on("working_references", (names) => {
             for (const name of names)
                 this.observeWorkingState(name, "obligations");
@@ -2124,6 +2407,10 @@ export class FleetManager {
                 lastActivityAt: this.lastActivity.get(name) ?? null, references, totalReferences, unavailable });
             if (!entry)
                 return;
+            if (reason === "cancelled")
+                outbox.workingRecovery.cancel(name, observation.configuration, observation.sessionId);
+            if (entry.prior)
+                outbox.workingRecovery.discover(name, entry.prior, this.workingRecoveryGroup);
             const state = entry.current.observation.executionState ?? "unknown";
             const counts = { tasks: entry.current.references.filter(r => r.kind === "task").length,
                 owed: entry.current.references.filter(r => r.kind === "owed").length,
@@ -2217,7 +2504,7 @@ export class FleetManager {
                 // Phase 2c: a lane a queue worker owns is never claimed here.
                 target => this.queueWorkers.has(target) || this.isInstanceRestarting(target) || this.wakeCoordinator?.blocksClaim(target)
                     ? null
-                    : this.daemons.get(target)?.bootId ?? null, this.activeDurableTargets);
+                    : this.daemons.get(target)?.bootId ?? null, this.activeDurableTargets, row => this.recoveryDeliveryEligible(row));
                 if (!claimed)
                     break;
                 this.activeDurableTargets.add(claimed.targetInstance);
@@ -2279,7 +2566,7 @@ export class FleetManager {
             available: () => !this.shuttingDown && this.deliveryOutbox?.isOpen === true,
             blocked: () => this.isInstanceRestarting(target) || this.wakeCoordinator?.blocksClaim(target) === true,
             daemonBootId: () => this.daemons.get(target)?.bootId ?? null,
-            claim: bootId => this.deliveryOutbox?.claimNext(this.managerBootId, candidate => candidate === target ? bootId : null, new Set()),
+            claim: bootId => this.deliveryOutbox?.claimNext(this.managerBootId, candidate => candidate === target ? bootId : null, new Set(), row => this.recoveryDeliveryEligible(row)),
             tryAcquireBudget: () => {
                 if (this.activeDurableTargets.size >= 8)
                     return false;
@@ -2320,7 +2607,24 @@ export class FleetManager {
         // including time spent waiting for a handoff/idle gate to return.
         try {
             let sent;
-            if (claimed.kind === "raw_paste") {
+            if (claimed.kind === WORKING_RECOVERY_KIND) {
+                const daemon = this.daemons.get(target), key = claimed.sourceKey.replace(/^working-recovery:/, "");
+                if (!daemon || typeof payload.content !== "string")
+                    throw new Error("Working recovery owner unavailable");
+                const release = this.workingRecovery?.reserveDispatch(target, key);
+                if (!release) {
+                    outbox.retryBeforeBegin(claimed.deliveryId, daemon.bootId, claimed.attemptNo, "working recovery pace or prerequisites pending", 5_000);
+                    return;
+                }
+                try {
+                    await daemon.deliverWorkingRecovery(payload.content, claimed, () => this.daemons.get(target) === daemon && this.recoveryDeliveryEligible(claimed, true));
+                }
+                finally {
+                    release();
+                }
+                sent = true;
+            }
+            else if (claimed.kind === "raw_paste") {
                 if (payload.type !== "raw_paste" || typeof payload.content !== "string") {
                     throw new Error("Durable raw_paste row has an invalid payload");
                 }
@@ -2413,7 +2717,7 @@ export class FleetManager {
         const explicit = this.fleetConfig?.defaults?.startup?.concurrency;
         if (explicit != null)
             return Math.max(1, Math.min(20, explicit));
-        return deriveSpawnConcurrency(Math.round(freemem() / (1024 * 1024)), cpus().length);
+        return deriveSpawnConcurrency(Math.round(freemem() / (1024 * 1024)), effectiveCpuCount());
     }
     /** #1685: "elevated" or "critical" while host memory pressure slows or holds new agents; otherwise null (an
      *  unknown macOS reading — the advisory case — is unknown, so null too). */
@@ -2630,8 +2934,9 @@ export class FleetManager {
         // the next tunnel and says so, it does not block the fleet.
         this.announceToolPermissionsChange();
         this.tightenInstanceDirectories();
-        // #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)]) {
+        // #1723: the public link's preview tunnel keeps its own lease beside it; a leftover one is reaped the same way (and
+        // #2636's Office share tunnel's).
+        for (const leaseDir of [this.dataDir, join(this.dataDir, PUBLIC_PREVIEW_TUNNEL_DIR), join(this.dataDir, OFFICE_SHARE_TUNNEL_DIR)]) {
             void reapStaleTunnel(leaseDir)
                 .then(outcome => {
                 if (outcome.kind === "manual")
@@ -3004,6 +3309,7 @@ export class FleetManager {
     }
     /** SIGUSR1: full process reload. Names who asked (#1120). */
     onFullRestartSignal() {
+        this.recordWorkingRestartIntent("manual_restart");
         this.logger.info(`Received SIGUSR1, initiating full restart (process reload)... ${describeSignalSource(this.dataDir, "SIGUSR1")}`);
         this.gracefulShutdownForReload()
             .then(() => {
@@ -3195,7 +3501,7 @@ export class FleetManager {
                 await data.respond(t("permission.denied"));
                 return;
             }
-            this.fleetConfig.defaults.tips = mode === "on";
+            setNoticeMode(this.fleetConfig, "tips", mode === "on");
             this.saveFleetConfig();
             await data.respond(t(mode === "on" ? "tips.enabled" : "tips.disabled"));
             return;
@@ -4866,7 +5172,7 @@ export class FleetManager {
         return new WakeCoordinator({
             mode: target => this.deliveryWorkerMode(target),
             available: () => !this.shuttingDown && this.deliveryOutbox?.isOpen === true,
-            listPending: () => this.deliveryOutbox?.listPending() ?? [],
+            listPending: () => this.deliveryOutbox?.listPending().filter(row => row.kind !== WORKING_RECOVERY_KIND) ?? [],
             isPaused: target => !this.sessionOomStopped(target) && this.lifecycle.isPaused(target),
             pauseReason: target => readPauseReason(this.getInstanceDir(target)),
             isRestarting: target => this.isInstanceRestarting(target),
@@ -4985,6 +5291,7 @@ export class FleetManager {
     }
     classicBehaviorUpdate(instanceName) {
         return {
+            reply_triggers: this.classicChannels?.getReplyTriggersByInstance(instanceName, this.fleetConfig?.defaults?.reply_triggers) ?? DEFAULT_REPLY_TRIGGERS,
             tool_progress: this.classicChannels?.getToolProgressByInstance(instanceName, this.fleetConfig?.defaults?.tool_progress) ?? "off",
             reply_completion_guard: this.classicChannels?.getReplyCompletionGuardByInstance(instanceName, this.fleetConfig?.defaults?.reply_completion_guard) ?? true,
         };
@@ -5283,36 +5590,40 @@ export class FleetManager {
      * config file races. Stagger applies between outer lifecycle admissions.
      * TODO: per-instance startup timeout (existing issue, not introduced here)
      */
-    async startInstancesWithConcurrency(entries, topicMode, onReady) {
+    async startInstancesWithConcurrency(entries, topicMode, onReady, classic = []) {
         // Persisted pauses are intentionally preserved across fleet restarts. Filter
         // them before grouping/staggering: startInstance() retains its own guard as
         // a final backstop, but putting a no-op entry in this queue still consumes a
         // full stagger slot for every distinct working directory.
         const runnableEntries = entries.filter(([name]) => !this.lifecycle.isPaused(name));
+        // ClassicBot rooms queue with the fleet instances, at the same pressure pacing (#2642 follow-up): they used to start
+        // only after the whole fleet, the chat connections, topics and icons. A name the fleet also configures is the fleet's.
+        const fleetNames = new Set(entries.map(([name]) => name));
+        const runnableClassic = classic.filter(ch => !this.lifecycle.isPaused(ch.instanceName) && !fleetNames.has(ch.instanceName));
         const pausedCount = entries.length - runnableEntries.length;
         if (pausedCount > 0) {
             this.logger.info({ pausedCount }, "Paused instances excluded from startup queue");
         }
-        if (runnableEntries.length === 0)
+        if (runnableEntries.length === 0 && runnableClassic.length === 0)
             return;
         if (this.fleetConfig?.defaults?.startup?.concurrency == null) {
             this.logger.info({
                 concurrency: this.spawnConcurrency(),
                 freeMemMB: Math.round(freemem() / (1024 * 1024)),
-                totalInstances: runnableEntries.length,
+                totalInstances: runnableEntries.length + runnableClassic.length,
             }, "Adaptive startup concurrency");
         }
         const startedAt = performance.now();
         let active = 0, peakConcurrentStarts = 0, readyInstances = 0;
-        await Promise.all(runnableEntries.map(([name, config]) => this.spawnGate.run({
+        const admit = (name, workingDirectory, start) => this.spawnGate.run({
             instanceName: name,
-            workingDirectory: config.working_directory,
+            workingDirectory,
             reason: "startup",
             stage: "lifecycle",
         }, async () => {
             peakConcurrentStarts = Math.max(peakConcurrentStarts, ++active);
             try {
-                if (await this.startInstanceUnattended(name, config, topicMode, "instance")) {
+                if (await start()) {
                     readyInstances++;
                     onReady?.(name);
                 }
@@ -5320,9 +5631,13 @@ export class FleetManager {
             finally {
                 active--;
             }
-        })));
+        });
+        await Promise.all([
+            ...runnableEntries.map(([name, config]) => admit(name, config.working_directory, () => this.startInstanceUnattended(name, config, topicMode, "instance"))),
+            ...runnableClassic.map(ch => admit(ch.instanceName, join(getAgendHome(), "workspaces", ch.instanceName), () => this.startClassicInstanceUnattended(ch, "classic instance"))),
+        ]);
         this.logger.info({
-            totalInstances: runnableEntries.length, readyInstances,
+            totalInstances: runnableEntries.length + runnableClassic.length, classicInstances: runnableClassic.length, readyInstances,
             elapsedSeconds: Math.round((performance.now() - startedAt) / 100) / 10,
             peakConcurrentStarts,
         }, "Fleet startup batch completed");
@@ -6722,7 +7037,8 @@ export class FleetManager {
                 const [adapterId, userId] = k.split("\u0000");
                 accounts.set(k, { adapterId, userId, sessions: 0, lastSeen: null });
             }
-        for (const key of Object.keys(cfg?.narrow ?? {})) {
+        // #2348: every granted account is listed too, signed in or not.
+        for (const key of [...Object.keys(cfg?.narrow ?? {}), ...Object.keys(cfg?.grants ?? {})]) {
             const at = key.indexOf(":"), adapterId = key.slice(0, at), userId = key.slice(at + 1), k = `${adapterId}\u0000${userId}`;
             if (at > 0 && !accounts.has(k))
                 accounts.set(k, { adapterId, userId, sessions: 0, lastSeen: null });
@@ -6731,10 +7047,166 @@ export class FleetManager {
             const owner = { adapterId: a.adapterId, userId: a.userId };
             const badge = this.guestBadge(owner);
             // `reach`: before narrowing — what Settings offers to narrow to (#2104 review: never an agent it cannot reach).
+            const grant = own(cfg?.grants, `${a.adapterId}:${a.userId}`);
+            const sent = this.guestCodeSent.get(`${a.adapterId}:${a.userId}`);
             return { ...a, name: badge.name, platform: badge.platform, scope: [...this.guestScope(owner)].sort(), reach: [...this.guestReach(owner)].sort(),
-                devices: devices.get(k) ?? 0, narrow: own(cfg?.narrow, `${a.adapterId}:${a.userId}`) ?? null };
+                devices: devices.get(k) ?? 0, narrow: own(cfg?.narrow, `${a.adapterId}:${a.userId}`) ?? null,
+                // #2348: the grant as fleet.yaml has it (null: none), and the last code an admin sent from Settings.
+                grant: grant ? { ...(grant.name ? { name: grant.name } : {}), instances: [...grant.instances] } : null,
+                ...(sent ? { code: { at: sent.at, outcome: sent.outcome.kind, ...(sent.outcome.kind === "sent" ? { expiresAt: sent.at + sent.outcome.expiresInMs } : {}),
+                        ...(sent.outcome.kind === "dm_failed" ? { reason: sent.outcome.reason, platform: sent.outcome.platform, ...(sent.outcome.startUrl ? { startUrl: sent.outcome.startUrl } : {}) } : {}) } } : {}) };
         }).sort((x, y) => (y.lastSeen ?? -1) - (x.lastSeen ?? -1));
-        return { enabled: cfg?.enabled === true, chat: cfg?.chat !== false, instances: Object.keys(this.fleetConfig?.instances ?? {}).sort(), connections, guests };
+        // #2348: `explicit` — grants are the scope (default deny); false: the derived scope of #1920, until grants are saved.
+        // #2667: the ClassicBot rooms there are now, apart from fleet.yaml's instances (a grant may name either: guestReach),
+        // with its display name as the sidebar resolves it (a profile alias, else the room's own), when it has one.
+        const profiles = profileIdentities(this.dataDir);
+        const rooms = (this.classicChannels?.getAll() ?? []).filter((r) => !Object.hasOwn(this.fleetConfig?.instances ?? {}, r.instanceName))
+            .map((r) => {
+            const shown = resolveInstanceIdentity({ classic: r, profile: profiles.get(r.instanceName) }).display_name;
+            return { name: r.instanceName, ...(shown && shown !== r.instanceName ? { display_name: shown } : {}) };
+        })
+            .sort((x, y) => (x.name < y.name ? -1 : x.name > y.name ? 1 : 0));
+        return { enabled: cfg?.enabled === true, chat: cfg?.chat !== false, explicit: cfg?.grants !== undefined, instances: Object.keys(this.fleetConfig?.instances ?? {}).sort(), rooms, connections, guests,
+            audit: this.guestAudit() };
+    }
+    /** #2667: the ClassicBot rooms' instance names now — what a settings save's validation knows besides fleet.yaml's instances. */
+    classicRoomNames() {
+        return (this.classicChannels?.getAll() ?? []).map((r) => r.instanceName);
+    }
+    /**
+     * #2499 review: the guest audit an admin reads — the newest grant changes and admin-sent codes from the event log
+     * (`fleet` rows: no agent's Log shows them). Through guestOverview only: Settings' admin gate, never over the public
+     * link, never a guest's. The person's name as the card shows it; a session handle stays on the server (`by` → whether
+     * a person saved it here or it was confirmed in General).
+     */
+    guestAudit(limit = FleetManager.GUEST_AUDIT_SHOWN) {
+        if (!this.eventLog)
+            return [];
+        // One read, newest first by row id: a total order (created_at is to the second), so the cap never drops a newer row.
+        let rows = [];
+        try {
+            rows = this.eventLog.latestOfTypes("fleet", ["guest_grant_changed", "guest_code_sent"], limit);
+        }
+        catch {
+            return [];
+        }
+        const names = (list) => (Array.isArray(list) ? list.filter((n) => typeof n === "string") : []);
+        return rows.flatMap((r) => {
+            const p = r.payload ?? {}, account = typeof p.account === "string" ? p.account : "";
+            const at = account.indexOf(":");
+            if (at <= 0)
+                return [];
+            const name = this.webPerson({ adapterId: account.slice(0, at), userId: account.slice(at + 1) }).name;
+            const when = Date.parse(r.created_at.includes("T") ? r.created_at : `${r.created_at.replace(" ", "T")}Z`);
+            return r.event_type === "guest_grant_changed"
+                ? [{ kind: "grant", at: when, account, name, via: p.via === "confirmed" ? "confirmed" : "direct", added: names(p.added), removed: names(p.removed),
+                        endedSessions: typeof p.endedSessions === "number" ? p.endedSessions : 0 }]
+                : [{ kind: "code", at: when, account, name, outcome: typeof p.outcome === "string" ? p.outcome : "unknown" }];
+        });
+    }
+    static GUEST_AUDIT_SHOWN = 20;
+    /**
+     * #2348: Settings → Guests' picker — the people AgEnD has seen in chat (seen_people, from human receipts: never a bot,
+     * never the web), without fleet admins (they sign in as admins) or accounts of a connection the fleet no longer has.
+     * Admin only (settings-api.ts), never over the public link.
+     */
+    guestPeople() {
+        const seen = this.deliveryOutbox?.isOpen ? this.deliveryOutbox.seenPeople() : [];
+        const people = seen.filter((p) => this.worlds.has(p.adapterId) && !this.isFleetAdmin(p.userId, p.adapterId)).map((p) => {
+            const owner = { adapterId: p.adapterId, userId: p.userId };
+            return { adapterId: p.adapterId, userId: p.userId, platform: this.worlds.get(p.adapterId)?.adapter.type ?? p.adapterId, username: p.username,
+                name: this.webPerson(owner).name, lastSeen: p.lastSeen, instances: p.instances.map((i) => i.name) };
+        });
+        return { people };
+    }
+    /**
+     * #2348: why this account may not be given a grant, or null. Only someone AgEnD has seen in chat, on a connection the
+     * fleet runs, who is not a fleet admin of it (an admin is never a guest).
+     */
+    guestGrantRefusal(adapterId, userId) {
+        if (!this.worlds.has(adapterId) && !this.fleetConfig?.channels?.some((c) => (c.id ?? c.type) === adapterId))
+            return "no such connection in this fleet";
+        if (this.isFleetAdmin(userId, adapterId))
+            return "a fleet admin signs in as an admin, not as a guest";
+        if (!this.deliveryOutbox?.isOpen || !this.deliveryOutbox.isSeenPerson(adapterId, userId))
+            return "only someone AgEnD has seen in chat can be given guest access";
+        return null;
+    }
+    /**
+     * #2348 delta §5: a grant changed with a save — one event-log entry per person, shown in Settings → Guests' Recent
+     * changes (guestOverview: admin-only, never over the public link or to a guest): who saved it (an admin's
+     * session handle, the header token, or null when replayed for a confirmation), whether it applied at once or was
+     * confirmed in General, the agents added and taken away, and the sessions a removal ended. Never message content.
+     */
+    noteGuestGrantChange(change) {
+        this.logger.info({ account: change.account, via: change.via, added: change.added.length, removed: change.removed.length }, "Guest access changed in Settings");
+        try {
+            this.eventLog?.insert("fleet", "guest_grant_changed", { ...change });
+        }
+        catch { /* the log line stands */ }
+    }
+    /** #2348: an admin's Send sign-in code, per admin (the caller): at most this many in ADMIN_CODE_WINDOW_MS. */
+    static ADMIN_CODE_MAX = 10;
+    static ADMIN_CODE_WINDOW_MS = 10 * 60_000;
+    adminCodeSends = new Map();
+    /** #2348: the last admin-sent code per account, for the Settings card ("Code sent 18:42 · expires 18:52", or why not). */
+    guestCodeSent = new Map();
+    /**
+     * #2348: Settings → Guests' "Send sign-in code" — a guest code to an account an admin granted access, by DM only (no
+     * chat to answer in, nothing posted anywhere). The same issuance as the person's own /web (one code per account, the
+     * code store's caps and breaker, the public link's audience when it is open) and the same once-a-minute limit per
+     * account, plus a per-admin cap. Refused without guest sign-in, for a fleet admin, or with nothing granted. Audited.
+     */
+    async sendGuestCodeByAdmin(owner, by, 
+    /** #2365 review: the initiating admin is still signed in and still an admin (settings-api re-checks the session). */
+    current = () => true) {
+        const guests = this.fleetConfig?.web?.guests;
+        if (guests?.enabled !== true)
+            return { status: 409, body: { ok: false, outcome: "guests_off", error: "Guest sign-in is off" } };
+        if (this.isFleetAdmin(owner.userId, owner.adapterId))
+            return { status: 409, body: { ok: false, outcome: "admin", error: "A fleet admin signs in as an admin" } };
+        if (!this.guestScope(owner).size)
+            return { status: 409, body: { ok: false, outcome: "nothing", error: "Nothing is granted to this person yet: save their access first" } };
+        const token = this.webToken;
+        const adapter = this.adapters.get(owner.adapterId);
+        if (this.shuttingDown || !token || !adapter)
+            return { status: 503, body: { ok: false, outcome: "starting", error: "AgEnD is starting or this connection is not running" } };
+        const key = `${owner.adapterId}\u0000${owner.userId}`, asked = this.guestCodeAskedAt.get(key);
+        const now = performance.now();
+        if (this.guestCodeInFlight.has(key) || (asked !== undefined && now - asked < 60_000)) {
+            return { status: 429, body: { ok: false, outcome: "wait", retryAfterMs: asked !== undefined ? Math.max(0, 60_000 - (now - asked)) : 60_000 } };
+        }
+        const mine = (this.adminCodeSends.get(by) ?? []).filter((at) => now - at < FleetManager.ADMIN_CODE_WINDOW_MS);
+        if (mine.length >= FleetManager.ADMIN_CODE_MAX)
+            return { status: 429, body: { ok: false, outcome: "admin_limit", retryAfterMs: FleetManager.ADMIN_CODE_WINDOW_MS - (now - mine[0]) } };
+        this.adminCodeSends.set(by, [...mine, now]);
+        while (this.adminCodeSends.size > 256)
+            this.adminCodeSends.delete(this.adminCodeSends.keys().next().value);
+        let outcome = { kind: "busy" };
+        this.guestCodeInFlight.add(key);
+        try {
+            await this.issueGuestCode({ replyHere: async () => undefined }, owner, key, adapter, token, (o) => { outcome = o; }, current);
+        }
+        finally {
+            this.guestCodeInFlight.delete(key);
+        }
+        const done = outcome;
+        // #2365 review: the admin's session ended (or stopped being an admin's) while the code was on its way: nothing was
+        // sent, or what was made is withdrawn — the answer says so, as to anyone no longer signed in.
+        if (done.kind === "revoked" && !current())
+            return { status: 401, body: { ok: false, outcome: "revoked", error: "no longer authorized" } };
+        this.guestCodeSent.set(`${owner.adapterId}:${owner.userId}`, { at: Date.now(), outcome: done });
+        while (this.guestCodeSent.size > 512)
+            this.guestCodeSent.delete(this.guestCodeSent.keys().next().value);
+        // Audited: who asked, for whom, what happened (never the code).
+        this.logger.info({ by, adapterId: owner.adapterId, outcome: done.kind }, "Guest sign-in code sent by an admin from Settings");
+        try {
+            this.eventLog?.insert("fleet", "guest_code_sent", { by, account: `${owner.adapterId}:${owner.userId}`, outcome: done.kind, instances: this.guestScope(owner).size });
+        }
+        catch { /* the log line stands */ }
+        const status = done.kind === "sent" ? 200 : done.kind === "dm_failed" ? 502 : 409;
+        return { status, body: { ok: done.kind === "sent", outcome: done.kind, ...(done.kind === "sent" ? { expiresAt: Date.now() + done.expiresInMs, publicLink: done.publicLink } : {}),
+                ...(done.kind === "dm_failed" ? { platform: done.platform, reason: done.reason, ...(done.startUrl ? { startUrl: done.startUrl } : {}) } : {}) } };
     }
     /** #1920 phase 3 (the app shell): a guest's chip — its web name, and its connection's platform (discord, telegram). */
     guestBadge(owner) {
@@ -6803,24 +7275,35 @@ export class FleetManager {
         return true;
     }
     /** guestWebCommand's issuance, one per account at a time; a revoke made meanwhile (either kind) ends it unissued. */
-    async issueGuestCode(ask, owner, key, adapter, token) {
+    async issueGuestCode(ask, owner, key, adapter, token, 
+    /** #2348: how it ended, for a caller with no chat to answer in (Settings → Guests' Send sign-in code). */
+    report = () => { }, 
+    /**
+     * #2365 review: the one who asked may still ask — for an admin's Send sign-in code, that admin's session as it is
+     * now. Asked with the revocation checks, after every wait: false ends the issuance, and withdraws its code if one was made.
+     */
+    stillAllowed = () => true) {
         const say = (text) => ask.replyHere(text).catch(() => undefined);
         const revokes = this.guestRevokes, accountRevokes = this.guestAccountRevokes.get(key) ?? 0;
-        const unrevoked = () => this.guestRevokes === revokes && (this.guestAccountRevokes.get(key) ?? 0) === accountRevokes;
+        const unrevoked = () => this.guestRevokes === revokes && (this.guestAccountRevokes.get(key) ?? 0) === accountRevokes && stillAllowed();
         // §3.2: its rooms are read at sign-in (bounded; never longer than the reads' own deadline).
         await withinBudget(this.refreshGuestRooms(owner, { mode: "force" }), performance.now() + 6_000).catch(() => undefined);
-        if (!unrevoked())
-            return; // revoked while its rooms were read: no code
+        if (!unrevoked()) {
+            report({ kind: "revoked" });
+            return;
+        } // revoked while its rooms were read: no code
         const scope = this.guestScope(owner);
         if (!scope.size) {
             const open = this.worlds.get(owner.adapterId)?.accessManager.getMode() === "open";
             await say(t(open ? "web.guest_not_set_up" : "web.guest_nothing"));
+            report({ kind: "nothing" });
             return;
         }
         this.initializeWebSessions();
         const codes = this.webGuestLoginCodes;
         if (codes.pausedForMs() > 0) {
             await say(t("web.guest_paused"));
+            report({ kind: "paused" });
             return;
         }
         // §5.5 (step 4b): with the public link open, the code works through it too (an admin opened it; a guest is still a
@@ -6831,6 +7314,7 @@ export class FleetManager {
             recipient: { adapterId: owner.adapterId, userId: owner.userId, ...(ask.username ? { username: ask.username } : {}) } });
         if (!login) {
             await say(t("web.guest_busy"));
+            report({ kind: "busy" });
             return;
         }
         this.guestCodeAskedAt.delete(key);
@@ -6865,13 +7349,17 @@ export class FleetManager {
                     throw new Error("guest no longer admitted");
                 await say(t("web.guest_sent"));
             }
+            report({ kind: "sent", expiresInMs: LOGIN_CODE_TTL_MS, publicLink: !!open });
         }
         catch (err) {
             codes.revokeIfCurrent(login.issuanceId); // this flow's code only, never a later one's
             this.logger.info({ err: err?.message, adapterId: owner.adapterId }, "Guest sign-in code was not delivered privately");
-            if (!unrevoked())
-                return; // revoked meanwhile: the revoke's own answer said so
+            if (!unrevoked()) {
+                report({ kind: "revoked" });
+                return;
+            } // revoked meanwhile: the revoke's own answer said so
             const start = adapter.type === "telegram" ? this.tgStartWebUrl(owner.adapterId) : null;
+            report({ kind: "dm_failed", platform: adapter.type, reason: String(err?.message ?? err).slice(0, 200), ...(start ? { startUrl: start } : {}) });
             // #1742 for guests (step 4b-3): its START button (a bare /start, or the link's /start web) then asks again, from
             // the DM — once, within the window.
             if (adapter.type === "telegram")
@@ -7039,7 +7527,8 @@ export class FleetManager {
             this.notifyFleetError(t("web.guest_login_notice", this.webPerson(info.owner).name, info.label, this.guestScope(info.owner).size, info.handle.slice(0, 8)));
             return;
         }
-        if (this.fleetConfig?.web?.notify_login === false)
+        // Never by DM (hmsg-3b8ac2af: Telegram cannot DM a user who has not started the bot); a legacy "dm" reads as on.
+        if (!loginNoticeMode(this.fleetConfig?.web))
             return;
         // The session handle makes each notice distinct: notifyFleetError throttles by text, and a second
         // sign-in from the same kind of browser is exactly the one the operator most needs to hear about.
@@ -7413,11 +7902,13 @@ export class FleetManager {
         }
     }
     async startAllWithinDeadline(configPath, deadline) {
-        this.loginWindow.reopen(); // a stopAll → startAll restart must accept login windows again
+        if (!this.structuredLoginCleanupFailed)
+            this.loginWindow.reopen(); // a stopAll → startAll restart must accept login windows again
         this.loginController?.reopen();
         const startupStartedAt = Date.now();
         FleetManager.signalTarget = this;
         this.startupComplete = false;
+        this.workingRecovery?.reset();
         this.startupDashboard = null;
         // Cleared here, not at the end of doStopAll: a stop has an async tail, and
         // anything arriving during it is still part of the stop.
@@ -7673,12 +8164,7 @@ export class FleetManager {
             mkdirSync(generalDir, { recursive: true, mode: 0o700 });
             const backendName = fleet.defaults.backend ?? "claude-code";
             this.ensureGeneralInstructions(generalDir, backendName, name);
-            fleet.instances[name] = {
-                ...DEFAULT_INSTANCE_CONFIG,
-                working_directory: generalDir,
-                general_topic: true,
-                channel_id: need.adapterId,
-            };
+            fleet.instances[name] = autoGeneralInstanceConfig(fleet.defaults, generalDir, need.adapterId); // #2598: its kiro_ui is the fleet's
             generalsCreated = true;
         }
         if (generalsCreated)
@@ -7824,9 +8310,11 @@ export class FleetManager {
             this.rotateAllInstanceLogs();
         }, 24 * 60 * 60_000);
         this.logRotateTimer.unref?.();
-        // Phase 2: Start remaining instances with staggered concurrency
-        if (others.length > 0) {
-            await this.startInstancesWithConcurrency(others, topicMode, () => startupProgress.markReady());
+        // Phase 2: Start remaining instances, and the ClassicBot rooms with them, with staggered concurrency. A room needs no
+        // chat connection to spawn: its open-list is set above (reregisterClassicChannels) and inbound queues until it is up.
+        const classicAtBoot = topicMode && (fleet.channel || fleet.channels?.length) ? this.classicChannels?.getAll() ?? [] : [];
+        if (others.length > 0 || classicAtBoot.length > 0) {
+            await this.startInstancesWithConcurrency(others, topicMode, () => startupProgress.markReady(), classicAtBoot);
         }
         if (topicMode && (fleet.channel || fleet.channels?.length)) {
             await adapterStartup;
@@ -7868,22 +8356,7 @@ export class FleetManager {
             // IPC is already wired by startInstancesWithConcurrency → startInstance →
             // connectIpcToInstance. The previous 3s sleep + connectToInstances loop
             // was redundant.
-            // Start classic channel instances (parallel, concurrency 3)
-            if (this.classicChannels) {
-                const fleetBackend = this.fleetConfig?.defaults?.backend;
-                const channels = this.classicChannels.getAll()
-                    .filter(ch => !this.lifecycle.isPaused(ch.instanceName));
-                const concurrency = 3;
-                let idx = 0;
-                while (idx < channels.length) {
-                    const batch = channels.slice(idx, idx + concurrency);
-                    await Promise.allSettled(batch.map(async (ch) => {
-                        if (await this.startClassicInstanceUnattended(ch, "classic instance"))
-                            startupProgress.markReady();
-                    }));
-                    idx += concurrency;
-                }
-            }
+            // The ClassicBot rooms started in Phase 2, with the fleet.
             for (const name of Object.keys(fleet.instances)) {
                 this.startStatuslineWatcher(name);
             }
@@ -7996,12 +8469,17 @@ export class FleetManager {
         // health server — so `systemctl start` returned success while the fleet was
         // still deaf: no path existed for a user message to arrive.
         sdNotify("READY=1");
+        this.workingRecovery?.ready();
         // #2481: this version runs — the CLI's start-failure banner stops, and this is the version to go back to later.
         try {
             const { ownPackage, recordStarted } = await import("./start-failure.js");
             const version = ownPackage().version;
             if (version)
                 recordStarted(this.dataDir, version, process.pid, Date.now());
+            // #2481: a start completed — the failed tree an automatic restore kept for a report can go.
+            const prefix = ownPackage().prefix;
+            if (prefix)
+                void (await import("./mac-auto-restore.js")).pruneFailedTrees(prefix).catch(() => { });
         }
         catch (err) {
             this.logger.debug({ err }, "fleet-started record not written");
@@ -8145,25 +8623,43 @@ export class FleetManager {
         if (channelConfigs.length === 0)
             return;
         // Start ALL adapters in parallel — any single failure doesn't block others.
-        const results = await Promise.allSettled(channelConfigs.map((cfg, i) => i === 0
+        const settled = channelConfigs.map(() => false);
+        // Each connection is recorded (connected, or retrying with its retry scheduled) as its own login settles.
+        const recorded = channelConfigs.map((cfg, i) => (i === 0
             ? this.startSingleAdapter(fleet, cfg)
-            : this.startAdditionalAdapter(cfg)));
-        // Track state + schedule background retry for failures.
-        for (let i = 0; i < channelConfigs.length; i++) {
-            const adapterId = channelConfigs[i].id ?? channelConfigs[i].type;
-            if (results[i].status === "fulfilled") {
-                this.adapterState.set(adapterId, { status: "connected", retryCount: 0 });
-            }
-            else {
-                const err = results[i].reason;
-                this.logger.error({ adapterId, err: err?.message ?? err }, "Adapter startup failed — scheduling background retry");
-                this.adapterState.set(adapterId, { status: "retrying", retryCount: 0, lastError: err?.message ?? String(err) });
-                this.scheduleAdapterRetry(adapterId);
-                // Notify admin via whichever adapter is already up
-                this.notifyAdapterFailure(adapterId, err?.message ?? String(err));
-            }
+            : this.startAdditionalAdapter(cfg)).then(() => ({ status: "fulfilled" }), (reason) => ({ status: "rejected", reason }))
+            .then(result => { settled[i] = true; this.recordAdapterStartup(cfg, result); })
+            .catch(err => this.logger.error({ err }, "Recording a chat connection's startup failed")));
+        // #2642: bounded. Startup continues past a connection still logging in after this long (ClassicBot instances,
+        // READY); that connection is recorded, or retried, when its login settles, and joins the fleet as it would anyway.
+        let timer;
+        const inTime = await Promise.race([
+            Promise.all(recorded).then(() => true),
+            new Promise(resolve => { timer = setTimeout(() => resolve(false), FleetManager.ADAPTER_STARTUP_WAIT_MS); timer.unref?.(); }),
+        ]).finally(() => clearTimeout(timer));
+        if (!inTime) {
+            this.logger.warn({
+                pending: channelConfigs.filter((_, i) => !settled[i]).map(cfg => cfg.id ?? cfg.type),
+                waitedMs: FleetManager.ADAPTER_STARTUP_WAIT_MS,
+            }, "Chat connection still connecting — fleet startup continues without waiting for it");
         }
     }
+    /** How long fleet startup waits for its chat connections before it continues without the slow ones (#2642). */
+    static ADAPTER_STARTUP_WAIT_MS = 60_000;
+    /** Track a connection's startup outcome; a failure gets the background retry. */
+    recordAdapterStartup(cfg, result) {
+        const adapterId = cfg.id ?? cfg.type;
+        if (result.status === "fulfilled") {
+            this.adapterState.set(adapterId, { status: "connected", retryCount: 0 });
+            return;
+        }
+        const err = result.reason;
+        this.logger.error({ adapterId, err: err?.message ?? err }, "Adapter startup failed — scheduling background retry");
+        this.adapterState.set(adapterId, { status: "retrying", retryCount: 0, lastError: err?.message ?? String(err) });
+        this.scheduleAdapterRetry(adapterId);
+        // Notify admin via whichever adapter is already up
+        this.notifyAdapterFailure(adapterId, err?.message ?? String(err));
+    }
     /** Keep trying while the fleet runs, with a five-minute cap even after a long outage. */
     scheduleAdapterRetry(adapterId) {
         const INITIAL_DELAY_MS = 5_000;
@@ -10666,6 +11162,7 @@ export class FleetManager {
                         // overwritten with coordinates the target's adapter cannot address.
                         ...(foreignWorld ? {} : { chat_id: reply_chat_id, thread_id: reply_thread_id }),
                         user: "scheduler",
+                        source: "schedule",
                         ...(adapterId ? { adapter_id: adapterId } : {}),
                     },
                 }, { waitForIdle: true, ...(retryCurrent ? { stillCurrent: retryCurrent } : {}) });
@@ -10842,7 +11339,7 @@ export class FleetManager {
         if (!ipc || !fleetRequestId)
             return;
         const type = String(msg.type);
-        const responseType = isCanvasWorkerTool(type.replace(/^fleet_/, "")) ? "fleet_web_theme_response"
+        const responseType = isCanvasWorkerTool(type.replace(/^fleet_/, "")) || type === "fleet_office_view" || type === "fleet_office_set" ? "fleet_web_theme_response"
             : type.startsWith("fleet_schedule_") ? "fleet_schedule_response"
                 : type.startsWith("fleet_decision_") ? "fleet_decision_response"
                     : type === "fleet_task" ? "fleet_task_response"
@@ -10896,7 +11393,8 @@ export class FleetManager {
             || type === "fleet_get_web_appearance" || type === "fleet_preview_web_appearance"
             || type === "fleet_set_web_widget" || type === "fleet_remove_web_widget"
             || type === "fleet_set_web_ambient" || type === "fleet_clear_web_ambient"
-            || type === "fleet_export_web_mod" || type === "fleet_propose_web_mod") {
+            || type === "fleet_export_web_mod" || type === "fleet_propose_web_mod"
+            || type === "fleet_office_view" || type === "fleet_office_set") {
             this.handleWebTheme(name, msg);
             return;
         }
@@ -10917,7 +11415,8 @@ export class FleetManager {
             const result = tool === "get_web_appearance" || tool === "preview_web_appearance"
                 ? this.appearanceTools.handle(instanceName, tool, args)
                 : tool === "export_web_mod" || tool === "propose_web_mod" ? this.agentMods.handle(instanceName, tool, args)
-                    : this.webAppearance.handleTool(instanceName, tool, args);
+                    : tool === "office_view" || tool === "office_set" ? this.officeActs.handle(instanceName, tool, args)
+                        : this.webAppearance.handleTool(instanceName, tool, args);
             ipc.send({ type: "fleet_web_theme_response", fleetRequestId, result });
         }
         catch (err) {
@@ -11353,6 +11852,8 @@ export class FleetManager {
             return this.appearanceTools.handle(instance, tool, args);
         if (tool === "export_web_mod" || tool === "propose_web_mod")
             return this.agentMods.handle(instance, tool, args);
+        if (tool === "office_view" || tool === "office_set")
+            return this.officeActs.handle(instance, tool, args); // #2578
         return this.webAppearance.handleTool(instance, tool, args);
     }
     async handlePreviewEmojisHttp(instance, args) {
@@ -11787,6 +12288,24 @@ export class FleetManager {
             return;
         if (!this.savedFleetConfigSnapshot)
             this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
+        normalizeNoticeDelivery(this.fleetConfig);
+        normalizeOfficeStorage(this.fleetConfig);
+        explicitPatches = explicitPatches.flatMap(patch => {
+            const path = patch.path;
+            if (path.at(-2) === "dashboard" && path.at(-1) === "office" && !patch.remove) {
+                return [{ ...patch, path: [...path.slice(0, -2), "office_access"] }, { path, remove: true }];
+            }
+            if (path.at(-1) === "dashboard" && patch.value && typeof patch.value === "object" && Object.hasOwn(patch.value, "office")) {
+                const { office, ...dashboard } = patch.value;
+                return [{ ...patch, value: dashboard }, { path: [...path.slice(0, -1), "office_access"], value: office, remove: office === null }];
+            }
+            // #2581's DM choice was withdrawn: an old string is just "on", posted in the topic, and its route is dropped.
+            if (patch.path.join(".") === "web.notify_login" && patch.value === "dm")
+                return [{ ...patch, value: true }, { path: ["web", "notice_delivery", "login"], remove: true }];
+            if (patch.path.join(".") === "defaults.tips" && patch.value === "dm")
+                return [{ ...patch, value: true }, { path: ["web", "notice_delivery", "tips"], remove: true }];
+            return [patch];
+        });
         // Re-read immediately before patching so an unrelated concurrent/manual
         // edit is retained. Invalid concurrent YAML is never overwritten.
         const source = existsSync(this.configPath) ? readFileSync(this.configPath, "utf-8") : "{}\n";
@@ -11862,9 +12381,46 @@ export class FleetManager {
             },
         });
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
+        // The instance map is defaults-expanded. A defaults edit changes that view even when it writes no instance
+        // leaves. Re-resolve from the committed YAML so inherited values cannot become stale overrides on the next save.
+        // Keep the FleetConfig object itself: Settings and other request contexts hold it.
+        const resolvedInstances = loadFleetConfig(this.configPath).instances;
+        for (const [name, resolved] of Object.entries(resolvedInstances)) {
+            const current = this.fleetConfig.instances[name];
+            if (!current) {
+                this.fleetConfig.instances[name] = resolved;
+                continue;
+            }
+            // Lifecycle rollback fences hold these object identities across save. Refresh their values, not their owner.
+            for (const key of Object.keys(current))
+                if (!Object.hasOwn(resolved, key))
+                    delete current[key];
+            Object.assign(current, resolved);
+        }
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
+        this.refreshSavedDashboardPermissions();
         this.logger.info({ path: this.configPath, strippedDefaults: redundantPaths.length }, "Saved fleet config (lossless patch)");
     }
+    /** A permission tightening is effective when its save returns, independently of the later apply job or IPC. */
+    refreshSavedDashboardPermissions() {
+        if (!this.fleetConfig)
+            return;
+        const classicNames = new Set(this.classicChannels?.getAll().map(ch => ch.instanceName) ?? []);
+        for (const [name, daemon] of this.daemons) {
+            const next = this.fleetConfig.instances[name] ?? (classicNames.has(name) ? getEffectiveInstanceDefaults(this.fleetConfig.defaults) : undefined);
+            const previous = daemon.getConfigSnapshot?.();
+            if (!next || !previous)
+                continue;
+            if (isDeepStrictEqual(previous.dashboard, next.dashboard) && previous.office_access === next.office_access)
+                continue;
+            // Only permissions are adopted here. Cold fields retain the live daemon's old snapshot, so reconcile still
+            // detects that they require a restart. MCP menus also watch the raw file; this updates the next spawn's env.
+            daemon.applyConfigUpdate({ dashboard: next.dashboard ?? null, office_access: next.office_access ?? null });
+            if (taskBoardSwitchedOn(previous.dashboard, next.dashboard)) {
+                this.admitTaskBoardNotice(name, TASK_BOARD_ON_NOTICE, `task-board-on:${name}:${Date.now()}`);
+            }
+        }
+    }
     /** Why the config written to `candidate` must not replace fleet.yaml, or null: it does not load, or it adds errors. */
     savedFleetConfigProblem(candidate) {
         let after;
@@ -11893,7 +12449,7 @@ export class FleetManager {
     logConfigWarningsAtStartup() {
         let warnings = [];
         try {
-            warnings = validateFleetConfig(this.rawFleetConfig).warnings;
+            warnings = validateFleetConfig(this.rawFleetConfig, { rooms: readClassicRoomNames(this.dataDir) }).warnings;
         }
         catch (err) {
             this.logger.debug({ err }, "fleet.yaml validation failed (startup warnings)");
@@ -11902,7 +12458,44 @@ export class FleetManager {
             this.logger.warn({ path: w.path }, `fleet.yaml: ${w.path ? `${w.path}: ` : ""}${w.message}`);
     }
     /** One-time upgrade migration; invalid YAML is never rewritten. */
+    migrateNoticeDeliveryStorage() {
+        if (this.fleetConfig && this.configPath && (this.fleetConfig.web?.notify_login === "dm" || this.fleetConfig.defaults.tips === "dm"
+            || this.fleetConfig.web?.notice_delivery !== undefined)
+            && validateFleetConfig(this.rawFleetConfig).valid) {
+            try {
+                this.writeFleetConfigBackup(readFileSync(this.configPath, "utf8"));
+                this.saveFleetConfig();
+                this.logger.info("Notices no longer go by DM: stored them as topic booleans and dropped the old DM routing");
+            }
+            catch (err) {
+                this.logger.warn({ err }, "Could not migrate DM notice routing; keeping the original file");
+            }
+        }
+    }
+    migrateOfficeStorage() {
+        if (!this.fleetConfig || !this.configPath || !hasLegacyOffice(this.rawFleetConfig) || !validateFleetConfig(this.rawFleetConfig).valid)
+            return;
+        try {
+            this.writeFleetConfigBackup(readFileSync(this.configPath, "utf8"));
+            const patches = [];
+            const raw = this.rawFleetConfig;
+            for (const [path, item] of [[["defaults"], raw.defaults], ...Object.entries(raw.instances ?? {}).map(([name, value]) => [["instances", name], value])]) {
+                if (!item?.dashboard || !Object.hasOwn(item.dashboard, "office"))
+                    continue;
+                patches.push({ path: [...path, "dashboard", "office"], remove: true });
+                if (!Object.hasOwn(item, "office_access") && typeof item.dashboard.office === "boolean")
+                    patches.push({ path: [...path, "office_access"], value: item.dashboard.office });
+            }
+            this.saveFleetConfig(patches);
+            this.logger.info("Stored Office access outside dashboard for downgrade compatibility");
+        }
+        catch (err) {
+            this.logger.warn({ err }, "Could not migrate Office access; keeping the original file");
+        }
+    }
     slimFleetConfigAtStartup() {
+        this.migrateOfficeStorage();
+        this.migrateNoticeDeliveryStorage();
         const redundantPaths = collectRedundantInstanceDefaultPaths(this.rawFleetConfig);
         if (redundantPaths.length === 0)
             return;
@@ -12125,6 +12718,7 @@ export class FleetManager {
             this.effectToolsService?.forget(name);
             this.mods.forgetInstance(name);
             this.agentMods.forget(name);
+            this.officeActsInstance?.forget(name);
         }
         catch (err) {
             this.logger.warn({ err: err.message, name }, "Dropping a removed instance's web theme failed");
@@ -13931,6 +14525,8 @@ export class FleetManager {
             return true;
         if (await this.handleSettingsChangeCallback(data, adapterId, adapter))
             return true;
+        if (await this.handleKiroMigrateCallback(data, adapterId, adapter))
+            return true;
         if (await this.handleDashboardCallback(data, adapterId, adapter))
             return true;
         if (await this.handleClassicApproval(data, adapterId, adapter))
@@ -14051,6 +14647,7 @@ export class FleetManager {
         const fleet = Object.entries(this.fleetConfig?.instances ?? {}).map(([name, cfg]) => ({
             name, backend: this.backendNameOf(name), workingDirectory: cfg.working_directory, ledgerPath: join(this.getInstanceDir(name), "cache-ledger.json"),
             claudeConfigDir: this.claudeConfigDirOf(name), profile: this.usageProfileOf(name, this.backendNameOf(name)),
+            kiroDbPath: this.kiroDbPathOf(name, this.backendNameOf(name)),
         }));
         const taken = new Set(fleet.map(i => i.name));
         const classic = (this.classicChannels?.getAll() ?? []).filter(ch => !taken.has(ch.instanceName)).map(ch => ({
@@ -14060,6 +14657,7 @@ export class FleetManager {
             ledgerPath: join(this.getInstanceDir(ch.instanceName), "cache-ledger.json"),
             claudeConfigDir: this.claudeConfigDirOf(ch.instanceName),
             profile: this.usageProfileOf(ch.instanceName, this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code"),
+            kiroDbPath: this.kiroDbPathOf(ch.instanceName, this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code"),
         }));
         return [...fleet, ...new Map(classic.map(c => [c.name, c])).values()];
     }
@@ -14080,8 +14678,19 @@ export class FleetManager {
             return this.credentialProfileOf(name, "claude-code") ?? "default";
         if (backend === "codex")
             return "unrecorded";
+        if (backend === "kiro-cli")
+            return this.credentialProfileOf(name, "kiro-cli") ?? "default";
+        if (backend === "grok" || backend === "muse" || backend === "opencode" || backend === "antigravity")
+            return "default";
         return undefined;
     }
+    /** #2122 §10: a Kiro instance with a credential profile writes its classic store in that profile's home. */
+    kiroDbPathOf(name, backend) {
+        if (backend !== "kiro-cli")
+            return undefined;
+        const profile = this.credentialProfileOf(name, "kiro-cli");
+        return profile ? join(credentialProfileStoreHome(getAgendHome(), "kiro-cli", profile), "data.sqlite3") : undefined;
+    }
     /** #2122: the fleet's day boundary zone — defaults.scheduler.default_timezone, else this host's. */
     usageZone() {
         return this.fleetConfig?.defaults?.scheduler?.default_timezone?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -14124,6 +14733,19 @@ export class FleetManager {
             rolloutsUnreadable: root => sharedRolloutIndex(root).unreadable,
             metaPath: join(this.dataDir, "cache-codex-rollouts.json"),
             zone: () => this.usageZone(),
+            // #2122 §10: Kiro's shared classic store (XDG_DATA_HOME, as kiro-cli resolves it) and its KIRO_HOME.
+            kiroDbPath: () => join(process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share"), "kiro-cli", "data.sqlite3"),
+            kiroHome: () => kiroHome(),
+            // #2122 §10 step 3: grok keeps its sessions under ~/.grok (grok.ts reads them there too).
+            grokSessionsDir: () => join(homedir(), ".grok", "sessions"),
+            // #2122 §10 step 4: muse keeps sessions under $XDG_DATA_HOME/muse (else ~/.local/share/muse), as muse.ts reads them.
+            // #2122 §10 step 5: OpenCode's database, under XDG_DATA_HOME as opencode resolves it.
+            // #2122 §10 step 6: agy's conversations, under ~/.gemini as the antigravity backend reads its settings.
+            antigravityDir: () => join(homedir(), ".gemini", "antigravity-cli", "conversations"),
+            // The version AgEnD's CLI probe last recorded for agy: its cache file, whatever its age (never runs agy).
+            antigravityVersion: () => this.lastRecordedCliVersion("antigravity"),
+            opencodeDbPath: () => join(process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share"), "opencode", "opencode.db"),
+            museSessionsDir: () => join(process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share"), "muse", "sessions"),
             log: (level, msg, extra) => this.logger[level](extra ?? {}, msg),
         });
     }
@@ -14244,6 +14866,7 @@ export class FleetManager {
                 return this.deliveryOutbox.acknowledge(deliveryId, by);
             },
             tasks: () => this.needsYouTaskItems(),
+            backendSignIns: () => this.needsYouBackendSignIns(),
             taskAction: action => this.taskActionFromChat(action),
             settings: () => ({
                 liveMessage: this.fleetConfig?.needs_you?.live_message !== false,
@@ -14760,7 +15383,7 @@ export class FleetManager {
             ...(input.instance !== undefined ? { target: { adapterId: this.getInstanceAdapterId(input.instance) } } : {}),
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: input.session ? this.sessionAuthorizationStore()?.get(input.session.handle) ?? null : null,
-            policy: { ...webAuthorityPolicy(this.fleetConfig?.web), enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink }, epoch: state.epoch, now: Date.now(),
+            policy: { ...webAuthorityPolicy(this.fleetConfig?.web), enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink, quickLink: state.quickLink }, epoch: state.epoch, now: Date.now(),
         });
     }
     sessionAuthorizations = null;
@@ -14785,13 +15408,13 @@ export class FleetManager {
             session, gateway, peer, tokenEpoch: this.webToken ? tokenEpoch(this.webToken) : null,
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: { handle: session.handle, owner: session.owner, authorizedAt: now, until: now + policy.maxSessionMs, epoch: state.epoch },
-            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink }, epoch: state.epoch, now,
+            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink, quickLink: state.quickLink }, epoch: state.epoch, now,
         });
         if (check.refusal)
             return { ok: false, refusal: check.refusal };
         const live = new Set(this.webSessions?.list(undefined, () => true).map(r => r.handle) ?? []);
         store.prune(a => a.epoch === state.epoch && now <= Math.min(a.until, a.authorizedAt + policy.maxSessionMs) && live.has(a.handle));
-        return { ok: true, ...store.authorize(session.handle, session.owner, now, state.epoch, now + policy.maxSessionMs) };
+        return { ok: true, ...store.authorize(session.handle, session.owner, now, state.epoch, now + policy.maxSessionMs, peer) };
     }
     authorityStateStore = null;
     /**
@@ -14800,13 +15423,24 @@ export class FleetManager {
      */
     webAuthorityState() {
         if (!this.dataDir)
-            return { enabled: false, loopbackOnly: true, namedLink: false, epoch: 0 };
+            return { enabled: false, loopbackOnly: true, namedLink: false, quickLink: false, epoch: 0 };
         this.authorityStateStore ??= new AuthorityStateStore(join(this.dataDir, "web-authority.json"), this.logger, undefined, undefined, () => { this.ensureDeliveryOutbox?.(); return this.deliveryOutbox?.maxWebAuthorityEpoch() ?? 0; });
         const state = this.authorityStateStore.current(this.fleetConfig?.web?.verified_authority);
-        // #2453 (§0.2): the named-link option seen going off — the authority of every session over the link ends now, for
-        // good: their authorizations go (a later "on" can never bring one back without its account's Confirm).
-        if (state.namedLinkClosed)
-            this.sessionAuthorizationStore()?.prune(a => this.webSessions?.findByHandle(a.handle)?.surface === "local");
+        // #2453 (§0.2) / §0.3: a link's option seen going off — the authority of every session over that link ends now, for
+        // good: their authorizations go (a later "on" can never bring one back without its account's Confirm). A record from
+        // before §0.3 has no peer: over the gateway, only a named-link session could have been authorized then.
+        if (state.namedLinkClosed || state.quickLinkClosed) {
+            const ended = (a) => {
+                const session = this.webSessions?.findByHandle(a.handle);
+                if (!session)
+                    return true;
+                if (session.surface === "local")
+                    return false;
+                const peer = a.peer ?? "named_link";
+                return (!!state.namedLinkClosed && peer === "named_link") || (!!state.quickLinkClosed && peer === "quick_link");
+            };
+            this.sessionAuthorizationStore()?.prune(a => !ended(a));
+        }
         return state;
     }
     /**
@@ -14839,7 +15473,8 @@ export class FleetManager {
             .filter(a => a.epoch === state.epoch && sessions.has(a.handle) && now <= Math.min(a.until, a.authorizedAt + maxMs))
             .map(a => ({ handle: a.handle, label: sessions.get(a.handle).label, account: `${a.owner.adapterId}:${a.owner.userId}`, authorizedAt: a.authorizedAt,
             until: Math.min(a.until, a.authorizedAt + maxMs, sessions.get(a.handle).absoluteExpiry),
-            ...(sessions.get(a.handle).surface === "gateway" ? { named: true } : {}) })) : [];
+            // Over a link: the temporary one (§0.3), else the named one (a record from before §0.3 has no peer).
+            ...(sessions.get(a.handle).surface === "gateway" ? (a.peer === "quick_link" ? { quick: true } : { named: true }) : {}) })) : [];
         const host = this.fleetConfig?.web?.public_link?.hostname;
         return { state, configured, hours: VERIFIED_SESSION_HOURS, lanHosts, authorized, namedHost: typeof host === "string" && host ? host : null };
     }
@@ -14854,9 +15489,17 @@ export class FleetManager {
         const adapterOf = (adapterId) => this.adapters.get(adapterId) ?? this.worlds.get(adapterId)?.adapter;
         // The host's clock, with its zone: the person may read the DM on a phone in another one.
         const when = (ms) => new Date(ms).toLocaleString(undefined, { timeZoneName: "short" });
+        const quickHost = () => { try {
+            const u = this.publicWebLink?.openSignin()?.url;
+            return u ? new URL(u).host : "?";
+        }
+        catch {
+            return "?";
+        } };
         const where = (peer) => peer === "named_link"
             ? t("web_auth.peer_named_link", String(this.fleetConfig?.web?.public_link?.hostname ?? "?")) // §0.2: the internet
-            : t(peer === "loopback" ? "web_auth.peer_loopback" : "web_auth.peer_lan");
+            : peer === "quick_link" ? t("web_auth.peer_quick_link", quickHost()) // §0.3: the internet
+                : t(peer === "loopback" ? "web_auth.peer_loopback" : "web_auth.peer_lan");
         return this.authorizationRequests = new SessionAuthorizationRequests({
             now: () => performance.now(), wallNow: () => Date.now(),
             maxSessionMs: () => webAuthorityPolicy(this.fleetConfig?.web).maxSessionMs,
@@ -14890,8 +15533,8 @@ export class FleetManager {
                 const record = this.webSessions?.findByHandle(handle);
                 if (!record)
                     return { ok: false, refusal: "session_gone" };
-                // §0.2: a named-link session is judged as the gateway request it is (its exposure still the current one).
-                const r = this.authorizeWebSession(record, peer, peer === "named_link");
+                // §0.2 / §0.3: a session over a link is judged as the gateway request it is (its exposure still the current one).
+                const r = this.authorizeWebSession(record, peer, peer === "named_link" || peer === "quick_link");
                 // What the card says: the end of the authorization, or the session's own end when that comes first.
                 return r.ok ? { ok: true, until: Math.min(r.authorization.until, record.absoluteExpiry) } : { ok: false, refusal: r.refusal };
             },
@@ -14937,7 +15580,7 @@ export class FleetManager {
             session: s, gateway: input.gateway, peer: input.peer, tokenEpoch: this.webToken ? tokenEpoch(this.webToken) : null,
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: s?.owner ? { handle: s.handle, owner: s.owner, authorizedAt: now, until: now + policy.maxSessionMs, epoch: state.epoch } : null,
-            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink }, epoch: state.epoch, now,
+            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink, quickLink: state.quickLink }, epoch: state.epoch, now,
         });
         return r.refusal;
     }
@@ -16228,6 +16871,55 @@ export class FleetManager {
         }
         return this.loginController;
     }
+    browserBackendSignInsInstance = null;
+    structuredLoginCleanupFailed = false;
+    pendingBackendSince = new Map();
+    browserSignInOwnerCurrent(owner) {
+        const record = owner;
+        return !this.shuttingDown && typeof record.handle === "string" && this.webSessions?.findByHandle(record.handle) === owner
+            && this.isLocalAdminSession(record.handle);
+    }
+    /** #2599: default-account controls share the exact writer reservation with chat/profile/install. */
+    get browserBackendSignIns() {
+        return this.browserBackendSignInsInstance ??= new BrowserBackendSignIns({
+            dataDir: this.dataDir, lock: this.loginWindow,
+            current: owner => this.browserSignInOwnerCurrent(owner),
+            installed: async () => ONBOARDING_BACKENDS.filter(backend => this.isCliInstalled(backend)),
+            checkAuth: backend => checkAuthStatus(LOGIN_FLOWS[backend].authCheck),
+            checkConsoleAuth: () => checkAuthStatus(LOGIN_FLOWS.antigravity.authCheck),
+            transport: () => createStructuredSignInTransport(),
+            changed: (event, owner, launched) => {
+                try {
+                    this.eventLog?.insert("login", "browser_backend_signin", event);
+                }
+                catch { /* safe metadata only */ }
+                broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed"));
+                this.needsYou?.poke();
+                if (!this.browserSignInOwnerCurrent(owner))
+                    return;
+                if (event.phase === "starting") {
+                    const record = owner;
+                    this.notifyFleetError(t("login.web_dashboard_notice", event.backend, record.label, record.handle.slice(0, 8)));
+                }
+                if (event.phase === "done") {
+                    void this.backendAvailability.refresh([event.backend], { force: true }).catch(() => { });
+                    if (launched)
+                        void this.recoverBackendInstances(event.backend, undefined, null).catch(() => this.logger.warn({ backend: event.backend }, "Post sign-in recovery failed"));
+                }
+            },
+        });
+    }
+    needsYouBackendSignIns() {
+        const pending = readPendingBackendSignIns(this.dataDir).pending;
+        for (const backend of this.pendingBackendSince?.keys() ?? [])
+            if (!pending.includes(backend))
+                this.pendingBackendSince.delete(backend);
+        return pending.map(backend => {
+            if (!this.pendingBackendSince.has(backend))
+                this.pendingBackendSince.set(backend, Date.now());
+            return { backend, since: this.pendingBackendSince.get(backend), browser: structuredSignInSupported(backend) };
+        });
+    }
     /** #2233: sign-ins started from the web dashboard (local admin sessions), on the same controller as chat's. */
     webBackendLoginsInstance = null;
     get webBackendLogins() {
@@ -16580,6 +17272,14 @@ export class FleetManager {
         // "cancelled" is the detail both legacy onDone handlers keep quiet about —
         // a stopping fleet must not announce "login failed — fleet shutdown".
         await Promise.all([
+            bounded(this.browserBackendSignInsInstance?.close().then(confirmed => {
+                if (confirmed)
+                    this.browserBackendSignInsInstance = null;
+                else {
+                    this.structuredLoginCleanupFailed = true;
+                    this.logger.error("Structured login cleanup failed; sign-in admission remains closed until the host is restarted.");
+                }
+            }), "browser-controls"),
             bounded(this.loginController?.shutdown(), "web-login"),
             bounded(this.activeInstall?.session.cancel("cancelled"), "install"),
         ]);
@@ -16596,6 +17296,13 @@ export class FleetManager {
             this.installHandoff = null;
             return t("login.cancelled", backend);
         }
+        const browserLogin = this.browserBackendSignInsInstance, browserBackend = browserLogin?.activeBackend;
+        if (browserLogin && browserBackend) {
+            const confirmed = await browserLogin.close();
+            if (confirmed)
+                this.browserBackendSignInsInstance = null;
+            return confirmed ? t("login.cancelled", browserBackend) : t("login.browser_cleanup_failed");
+        }
         if (this.loginController?.isActive())
             return this.loginController.cancel();
         return t("login.no_session");
@@ -16767,7 +17474,7 @@ export class FleetManager {
         // session only judges that verdict; it does not read the output for URLs or prompts.
         const flow = {
             backend,
-            command: info.install,
+            command: info.unattended ?? info.install,
             successPattern: /$^/,
             timeoutMs: 10 * 60 * 1000,
         };
@@ -17764,7 +18471,15 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             const isPrimaryAdapter = !mentionWorld || mentionWorld.adapter === this.adapter;
             const adapterBotUserId = mentionWorld?.botUserId ?? (isPrimaryAdapter ? this.botUserId : undefined);
             const mentionTag = adapterBotUserId ? `<@${adapterBotUserId}>` : null;
-            const isMentioned = mentionTag && text.includes(mentionTag);
+            // #2551: a native reply to one of THIS bot's messages is addressed to it, as a mention is (a Discord reply carries
+            // its ping in the reference, not the text). One hop only: a reply to a message of ours that itself answered a bot
+            // (or the sender) is a chain of bots answering each other — a mention still carries it on. A reply to our answer
+            // to a person is the ordinary handoff, and is addressed.
+            const replyTriggers = this.classicChannels?.getReplyTriggers(channelId, msg.adapterId, this.fleetConfig?.defaults?.reply_triggers) ?? DEFAULT_REPLY_TRIGGERS;
+            const repliesToUs = replyTriggers && !!adapterBotUserId && msg.replyToAuthorId === adapterBotUserId && msg.replyToChain !== true;
+            // Snapshot/quoted content is context, never the forwarder's own mention.
+            const addressText = msg.source === "discord" ? (msg.humanOriginalBody ?? text) : text;
+            const isMentioned = (mentionTag && addressText.includes(mentionTag)) || repliesToUs;
             if (!isMentioned) {
                 // Bare attachment (no @mention) — already saved above; just acknowledge.
                 if (saved) {
@@ -18099,6 +18814,19 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         catch { /* missing / stale / corrupt */ }
         return null;
     }
+    /**
+     * #2122 §10: the version the CLI probe last recorded for a backend — its cache file read whatever its age (the usage
+     * reader's version gate needs the last known version, not a fresh one); null when none was recorded. Never a probe.
+     */
+    lastRecordedCliVersion(backend) {
+        try {
+            const v = JSON.parse(readFileSync(this.cliEnvPath(backend), "utf-8")).version;
+            return typeof v === "string" && v.trim() ? v.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
     /** Return cached CLI versions immediately. Refresh is started after /sysinfo is sent. */
     getBackendCliVersionSnapshot() {
         const snapshot = {};
@@ -20033,6 +20761,23 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     tmuxExecHelperTimer = null;
     stopAllInFlight = null;
+    /** Signal-handler continuation, after successful graceful shutdown only. */
+    noteRequestedShutdown() {
+        const progress = readUpdateProgress(this.dataDir)?.progress;
+        // Host CLI updates carry a generic marker with no chat progress target.
+        const update = progress ? updateProgressOperation(progress) === "update"
+            && ["installed", "stopping", "starting"].includes(progress.stage) : isUpdateInProgress(this.dataDir);
+        this.recordWorkingRestartIntent(update ? "update" : "manual_restart");
+    }
+    recordWorkingRestartIntent(cause) {
+        this.workingRecoveryCause = cause;
+        try {
+            this.deliveryOutbox?.workingRecovery.requested(this.managerBootId, cause);
+        }
+        catch {
+            this.logger.warn("Could not record requested restart; next recovery will report an unknown interruption");
+        }
+    }
     /** Stops release memory. Reassess between batches without waiting for recovery. */
     async stopInstancesInBatches(entries, stop) {
         let index = 0;
@@ -20050,15 +20795,25 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
     }
     async doStopAll() {
+        // The scheduler closes before individual daemons stop. Preserve the owned
+        // task/reply boundary while those stores are still available, not a later
+        // shutdown snapshot whose unavailable sources cannot authorize recovery.
+        for (const name of this.daemons.keys())
+            this.observeWorkingState(name, "before_stop");
         this.startupMemoryDeadline?.stop();
         this.startupMemoryDeadline = null;
         this.startupComplete = false;
+        this.workingRecovery?.reset();
         this.startupDashboard = null;
         this.reloadPending = false;
         // Before anything is stopped: everything that dies from here on dies
         // because we asked it to. Set synchronously — doStopAll runs to its first
         // await in the same tick as the signal handler, so no event can slip in.
         this.shuttingDown = true;
+        this.workingRecovery?.reset();
+        if (this.workingRecoveryTimer)
+            clearInterval(this.workingRecoveryTimer);
+        this.workingRecoveryTimer = null;
         if (this.updateProgressTimer) {
             clearInterval(this.updateProgressTimer);
             this.updateProgressTimer = null;
@@ -20071,6 +20826,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const settingsControlStopped = settingsControl?.close();
         this.publicLinkAutoOpen?.stop();
         const publicStopped = this.publicWebLink?.close("fleet shutdown");
+        const sharesStopped = this.officeSharesInstance?.close(); // #2636: every Office share ends, and its tunnel
         // #1386: every live "Needs you" message says the fleet stopped (capabilities revoked first) — while the
         // adapters can still edit. Bounded: a platform that does not answer must not hold the shutdown.
         const needsStopped = this.stopNeedsYou();
@@ -20109,6 +20865,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // timer and HTTP listener living in THIS process: without an explicit
         // shutdown it would outlive us as an owner-less login CLI (sol B3).
         await publicStopped;
+        await sharesStopped?.catch(() => { });
         await profileStopped;
         await needsStopped;
         await settingsControlStopped;
@@ -20461,6 +21218,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             // mark every row done and tell the user "changes applied".
             return { rejected: why };
         }
+        this.migrateOfficeStorage();
+        this.migrateNoticeDeliveryStorage();
         if (canvasWorkerEnabled(oldConfig?.web) !== this.canvasWorkerEnabled()) {
             this.canvasWorkerSettingChanged();
         }
@@ -20738,6 +21497,27 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     fleetSignatureMismatchKeys() {
         return this.fleetSignatureMismatch;
     }
+    /**
+     * #2347 restart flow: saved changes that take effect only after AgEnD restarts — the startup-only keys fleet.yaml
+     * now differs on, and the newest apply job whose fleet row can carry the restart (`job_id`, null when none can: a
+     * hand edit, or a job past its retention). Null when nothing is pending, and when a restart could not clear it
+     * (the signature mismatch the panel reports instead). The same test requestSettingsSelfRestart makes.
+     */
+    settingsRestartPending() {
+        if (this.appliedFleetLevel === null || this.fleetSignatureMismatch)
+            return null;
+        const next = this.nextFleetConfig();
+        if (this.appliedFleetLevel === this.fleetLevelSignature(next))
+            return null;
+        let job = null;
+        // A job whose restart was asked for already has its row in flight ("running"), so it is never offered again.
+        for (const candidate of this.applyJobs.all()) {
+            const row = candidate.targets.find(item => item.target === APPLY_FLEET_TARGET);
+            if (row?.status === "restart-required" && (!job || candidate.startedAt >= job.startedAt))
+                job = candidate;
+        }
+        return { keys: fleetLevelDifferences(this.startupFleetConfig, next), job_id: job ? job.id : null };
+    }
     /**
      * Restart AgEnD itself on behalf of a Settings apply.
      *
@@ -21988,6 +22768,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             this.logger.info("No instances to restart");
             return;
         }
+        this.workingRecoveryGroup = randomUUID();
+        this.recordWorkingRestartIntent("manual_restart");
+        this.workingRecovery?.reset();
         this.logger.info(`Graceful restart: waiting for ${instanceNames.length} instances to idle...`);
         const groupId = this.fleetConfig?.channel?.group_id;
         const generalName = this.findGeneralInstance();
@@ -22061,34 +22844,32 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         // General is ready again; now its topic can own the live progress message.
         await restartProgress.start(progressTarget);
-        if (restartOthers.length > 0) {
-            await this.startInstancesWithConcurrency(restartOthers, topicMode, () => restartProgress.markReady());
+        // The ClassicBot rooms (killed during orphan cleanup) restart with the fleet instances, in the same queue; their
+        // open-lists are refreshed first so a room's inbound is never dropped while it starts.
+        const restartClassic = topicMode ? this.classicChannels?.getAll() ?? [] : [];
+        if (restartClassic.length > 0)
+            this.reregisterClassicChannels();
+        if (restartOthers.length > 0 || restartClassic.length > 0) {
+            await this.startInstancesWithConcurrency(restartOthers, topicMode, () => restartProgress.markReady(), restartClassic);
         }
         if (topicMode) {
             this.routing.rebuild(this.fleetConfig);
             this.reregisterClassicChannels();
             // startInstance already calls connectIpcToInstance, no need for connectToInstances here
-            // Restart classic channel instances (killed during orphan cleanup)
-            if (this.classicChannels) {
-                const fleetBackend = this.fleetConfig?.defaults?.backend;
-                const channels = this.classicChannels.getAll()
-                    .filter(ch => !this.lifecycle.isPaused(ch.instanceName));
-                const concurrency = 3;
-                let idx = 0;
-                while (idx < channels.length) {
-                    const batch = channels.slice(idx, idx + concurrency);
-                    await Promise.allSettled(batch.map(async (ch) => {
-                        if (await this.startClassicInstanceUnattended(ch, "classic instance"))
-                            restartProgress.markReady();
-                    }));
-                    idx += concurrency;
-                }
-            }
             for (const name of Object.keys(fleet.instances)) {
                 this.startStatuslineWatcher(name);
             }
         }
+        this.workingRecovery?.ready();
         this.logger.info("Graceful restart complete");
+        // The in-process interval keeps its label, but a later unrelated process
+        // crash must not inherit this completed request as its shutdown intent.
+        try {
+            this.deliveryOutbox?.workingRecovery.clearRequested(this.managerBootId);
+        }
+        catch {
+            this.logger.warn("Could not clear completed in-process restart intent");
+        }
         const configuredNames = this.configuredStartupInstanceNames(fleet, topicMode);
         const total = configuredNames.length;
         const started = configuredNames.filter(name => this.daemons.has(name)).length;
@@ -22143,6 +22924,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     }
                     const ipc = this.instanceIpcClients.get(name);
                     if (ipc?.connected) {
+                        daemon?.noteLegacyRestartReminder?.();
                         ipc.send({
                             type: "fleet_inbound",
                             content: msg,
@@ -22290,6 +23072,11 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const guests = this.fleetConfig?.web?.guests;
         if (!owner || guests?.enabled !== true)
             return NO_GUEST_SCOPE;
+        // #2348: explicit grants, once the key exists, are the whole scope — no narrowing on top (a grant is already exact).
+        if (guests.grants !== undefined) {
+            const granted = this.guestReach(owner);
+            return granted.size ? granted : NO_GUEST_SCOPE;
+        }
         const scope = new Set(this.guestReach(owner));
         const narrow = guests.narrow && Object.hasOwn(guests.narrow, `${owner.adapterId}:${owner.userId}`) ? guests.narrow[`${owner.adapterId}:${owner.userId}`] : undefined;
         if (narrow) {
@@ -22310,6 +23097,20 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const scope = new Set();
         if (guests?.enabled !== true)
             return scope;
+        // #2348: with explicit grants, what an admin granted this account — of the instances that exist now (fleet.yaml's, or
+        // a ClassicBot room's) — and nothing else: no connection access, no room membership, no open_instances.
+        if (guests.grants !== undefined) {
+            const key = `${owner.adapterId}:${owner.userId}`;
+            const grant = Object.hasOwn(guests.grants, key) ? guests.grants[key] : undefined;
+            if (!grant || !Array.isArray(grant.instances))
+                return scope;
+            const rooms = new Set((this.classicChannels?.getAll() ?? []).map((r) => r.instanceName));
+            for (const name of grant.instances) {
+                if ((this.fleetConfig?.instances && Object.hasOwn(this.fleetConfig.instances, name)) || rooms.has(name))
+                    scope.add(name);
+            }
+            return scope;
+        }
         const own = (map, key) => (map && Object.hasOwn(map, key) ? map[key] : undefined);
         const world = this.worlds.get(owner.adapterId);
         if (world && world.accessManager.isAllowed(owner.userId)) {
@@ -22351,7 +23152,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const owner = record.owner;
         if (this.guestScope(owner).size)
             return "ok";
-        if (owner && this.fleetConfig?.web?.guests?.enabled === true) {
+        // #2348: with explicit grants no room's membership can give anything: nothing granted is gone, not pending. Nor does
+        // a connection's start matter: grants are config (and ClassicBot rooms), read without the adapter.
+        if (owner && this.fleetConfig?.web?.guests?.enabled === true && this.fleetConfig.web.guests.grants === undefined) {
             // Before adapters initialize, topic scope is unknown, not revoked. Keep the returning cookie but grant no
             // request until its configured world exists. Removed connections and initialized denied access stay final.
             const channels = this.fleetConfig.channels ?? (this.fleetConfig.channel ? [this.fleetConfig.channel] : []);