@songsid/agend 2.1.10 → 2.1.11-beta.2

package/dist/fleet-manager.js

@@ -1,9 +1,10 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, constants as fsConstants } from "node:fs";
-import { randomBytes, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { freemem, totalmem, cpus, homedir } from "node:os";
 import { createServer } from "node:http";
 import { Worker } from "node:worker_threads";
+import { ProbeWorkerPool } from "./probe-worker-pool.js";
 import { join, dirname, basename, delimiter, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
@@ -12,6 +13,7 @@ import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProg
 import { formatUpdateProgress } from "./update-progress.js";
 import { sdNotify, sdNotifyBlocking } from "./sd-notify.js";
 import { readFleetMemory } from "./process-memory.js";
+import { MemoryPressure } from "./memory-pressure.js";
 import { ReplyDeduper } from "./reply-dedup.js";
 import { isMap, isScalar, parseDocument } from "yaml";
 const __filename = fileURLToPath(import.meta.url);
@@ -30,13 +32,14 @@ import { IpcClient } from "./channel/ipc-bridge.js";
 import { createAdapter } from "./channel/factory.js";
 import { TelegramAdapter } from "./channel/adapters/telegram.js";
 import { createBackend } from "./backend/factory.js";
+import { readEffortMetadata } from "./backend/effort-metadata.js";
 import { isModelCompatible, SYSINFO_BACKEND_IDS, UnsupportedCliError } from "./backend/types.js";
 import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { Scheduler } from "./scheduler/index.js";
 import { DEFAULT_SCHEDULER_CONFIG } from "./scheduler/index.js";
-import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, SAVE_FILENAME_RE, resolveInstanceContext, forgetInstanceContext, readStatuslineModel } from "./topic-commands.js";
+import { TopicCommands, saveCommandForBackend, parseSaveFilename, parsePauseWakeCommand, parseCompactCommand, SAVE_FILENAME_RE, resolveInstanceContext, forgetInstanceContext, readStatuslineModel } from "./topic-commands.js";
 import { DailySummary } from "./daily-summary.js";
 import { WebhookEmitter } from "./webhook-emitter.js";
 import { TmuxControlClient } from "./tmux-control.js";
@@ -55,14 +58,18 @@ export const DURABLE_DELIVERY_LANE_ALERT_MS = 35 * 60_000;
 import { handleWebRequest, broadcastSseEvent } from "./web-api.js";
 import { handleViewRequest, isViewPath } from "./view-api.js";
 import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
-import { LOGIN_FLOWS, LOGIN_BACKEND_ALIASES, checkAuthStatus } from "./login-flows.js";
+import { LOGIN_FLOWS, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
 import { LoginSession } from "./login-manager.js";
 import { tightenInstanceDirs } from "./private-dir.js";
-import { LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS, announcePostLoginRecovery } from "./login-controller.js";
+import { decideSlash } from "./slash-authz.js";
+import { commandSpec, decideCommand } from "./command-table.js";
+import { LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS } from "./login-controller.js";
 import { runBeforeDeadline } from "./deadline.js";
 import { LoginWindowLock } from "./login-window-lock.js";
 import { handleSettingsRequest } from "./settings-api.js";
 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, getClassicBackendChoices, isSelectableClassicBackend, readClassicLastActivityAt } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
@@ -223,12 +230,17 @@ const CLEAR_CONFIRM_CALLBACK_PREFIX = "clear-confirm:";
 const TIP_DISMISS_CALLBACK_PREFIX = "tip-dismiss:";
 const TIP_UNLOCK_CALLBACK_PREFIX = "tip-unlock:";
 export const LOGIN_CALLBACK_PREFIX = "login:";
-/** Prompt kinds `/install-cli` used, before it became part of `/login` (#1131). */
-const RETIRED_PROMPT_PREFIXES = ["install-select:", "install-login:"];
+/**
+ * Prompt kinds that no longer exist: `/install-cli` (#1131) and the relay-mode login's
+ * provider picker (#1139). Their buttons may still be on screen after an upgrade.
+ */
+const RETIRED_PROMPT_PREFIXES = ["install-select:", "install-login:", "login-menu:"];
 const NEVER_MATCHES = /(?!)/;
 const CLASSIC_APPROVE_CALLBACK_PREFIX = "classic-approve:";
-const LOGIN_MENU_CALLBACK_PREFIX = "login-menu:";
 const LOGIN_CONFIRM_CALLBACK_PREFIX = "login-confirm:";
+/** How much of the end of a Classic chat log is read for context, and the most it grows to. */
+const CHAT_LOG_TAIL_BYTES = 64 * 1024;
+const CHAT_LOG_TAIL_MAX_BYTES = 4 * 1024 * 1024;
 const CLEAR_CONFIRM_TIMEOUT_MS = 15_000;
 /** Default lifetime for long-lived nonce prompts (clear overrides this to 15s). */
 const NONCE_BUTTON_TIMEOUT_MS = 15 * 60_000;
@@ -292,6 +304,7 @@ export class FleetManager {
     lifecycle;
     stormWindow;
     spawnGate;
+    memoryPressure;
     /** Fleet-level backend reachability memory (fed by pty_error / startup panes). */
     backendOutage = new BackendOutageTracker();
     /** Stable for this FleetManager OS-process lifetime; Daemon objects have their own boot IDs. */
@@ -445,6 +458,7 @@ export class FleetManager {
     startupRetryNotices = new Map();
     /** Unsupported-CLI refusals waiting to go out, grouped by reason (#1109). */
     unsupportedCliNotices = new Map();
+    kiroIncompatNotices = new Map();
     /** Backoff between automatic startup retries; the last step repeats while the backend is down. */
     static STARTUP_RETRY_BACKOFF_MS = [60_000, 5 * 60_000, 15 * 60_000];
     /** Hard cap on automatic startup retries (3 backoff steps + up to 3 more during a backend outage). */
@@ -537,6 +551,11 @@ export class FleetManager {
     watchdogTimer = null;
     startedAt = 0;
     stormOpenNotifyTimer = null;
+    memoryLogAt = null;
+    memoryDebugAt = null;
+    memoryLogLevel = null;
+    memoryNoticeAt = null;
+    memoryNoticeLevel = null;
     // Mirror topic: buffer cross-instance messages, flush every 3s
     mirrorBuffer = [];
     mirrorTimer = null;
@@ -575,8 +594,10 @@ export class FleetManager {
             FleetManager.sighupHandlerInstalled = true;
         }
         this.stormWindow = new StormWindow();
+        this.memoryPressure = new MemoryPressure({ onSample: snapshot => this.reportMemoryPressure(snapshot) });
         this.spawnGate = new SpawnGate({
             storm: this.stormWindow,
+            memoryPressure: this.memoryPressure,
             concurrency: () => this.spawnConcurrency(),
             staggerMs: () => this.fleetConfig?.defaults?.startup?.stagger_delay_ms ?? 500,
         });
@@ -956,9 +977,54 @@ export class FleetManager {
             return Math.max(1, Math.min(20, explicit));
         return deriveSpawnConcurrency(Math.round(freemem() / (1024 * 1024)), cpus().length);
     }
+    /** Separate cooldown: changing measurements must not create new text-throttle keys. */
+    reportMemoryPressure(snapshot) {
+        if (this.shuttingDown)
+            return;
+        const now = Date.now();
+        if (this.memoryDebugAt === null || now - this.memoryDebugAt >= 30_000) {
+            this.memoryDebugAt = now;
+            this.logger.debug({ hostMemory: snapshot }, "Host memory sample");
+        }
+        const changed = snapshot.level !== this.memoryLogLevel;
+        if (snapshot.level === "normal") {
+            if (this.memoryLogLevel === "critical" || this.memoryLogLevel === "elevated") {
+                this.logger.info({ hostMemory: snapshot }, "Host memory recovered");
+            }
+            this.memoryLogLevel = snapshot.level;
+            return;
+        }
+        if (changed || this.memoryLogAt === null || now - this.memoryLogAt >= 10 * 60_000) {
+            this.memoryLogAt = now;
+            this.logger.warn({ hostMemory: snapshot }, snapshot.level === "critical"
+                ? "Host memory critical — deferring new CLI spawns"
+                : snapshot.level === "elevated" ? "Host memory pressure — slowing new CLI spawns"
+                    : "Host memory sample unavailable — slowing new CLI spawns");
+        }
+        this.memoryLogLevel = snapshot.level;
+        if (!snapshot.memory || snapshot.level === "unknown" || (!this.adapter && this.adapters.size === 0))
+            return;
+        const escalation = snapshot.level === "critical" && this.memoryNoticeLevel !== "critical";
+        if (!escalation && this.memoryNoticeAt !== null && now - this.memoryNoticeAt < 10 * 60_000)
+            return;
+        const size = (bytes) => bytes === null ? t("memory.unknown") : `${Math.round(bytes / 1024 / 1024)} MiB`;
+        const text = t("memory.pressure", t(snapshot.memory.availableKind === "available" ? "memory.available" : "memory.free", size(snapshot.memory.availableBytes)), size(snapshot.memory.swapFreeBytes), t(snapshot.level === "critical" ? "memory.holding" : "memory.slowing"));
+        if (this.notifyFleetError(text, { throttle: false })) {
+            this.memoryNoticeAt = now;
+            this.memoryNoticeLevel = snapshot.level;
+        }
+    }
     /** Wire the one fleet-wide storm into notification and recovery surfaces. */
     bindStormWindowEvents() {
         this.stormWindow.on("opened", (snapshot) => {
+            if (snapshot.kind === "window_loss") {
+                // The server is fine and nothing is held: only the instances that lost
+                // their window are affected, they respawn at the storm rate, and their
+                // per-instance incident notices fold into this one (#1127).
+                this.logger.error({ ...snapshot }, "several instances lost their tmux window at once — recovering at a reduced rate");
+                this.notifyFleetError(t("storm.window_loss", snapshot.affected.length, Math.round(this.stormWindow.windowLossWindowMs / 1000), this.stormWindowLossRecoveryConcurrency()));
+                return;
+            }
             for (const [name, daemon] of this.daemons) {
                 if (!daemon.isPaused)
                     this.stormWindow.addAffected(name);
@@ -986,6 +1052,10 @@ export class FleetManager {
             this.notifyFleetError(t(reason === "timeout" ? "storm.timed_out" : "storm.recovered", snapshot.recovered.length, snapshot.affected.length, unresolved.length > 0 ? unresolved.join(", ") : t("storm.none")));
         });
     }
+    /** What the gate allows while any storm window is open (see SpawnGate.pump). */
+    stormWindowLossRecoveryConcurrency() {
+        return Math.min(4, this.spawnConcurrency());
+    }
     formatStormDelay(ms) {
         if (ms >= 60_000)
             return `${Math.round(ms / 60_000)}m`;
@@ -1226,8 +1296,17 @@ export class FleetManager {
         this.rawFleetConfig = raw;
         this.fleetConfig = loaded;
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
+        this.warnAboutRemovedLoginMode(loaded);
         return this.fleetConfig;
     }
+    relayLoginModeWarned = false;
+    /** `login.mode: relay` was removed (#1139). Still accepted so an upgrade cannot stop a fleet from starting. */
+    warnAboutRemovedLoginMode(config) {
+        if (config.login?.mode !== "relay" || this.relayLoginModeWarned)
+            return;
+        this.relayLoginModeWarned = true;
+        this.logger.warn("fleet.yaml sets login.mode: relay — the chat-relay login was removed; /login always uses the web terminal. Remove the setting.");
+    }
     /**
      * A channel's configurable bot_token_env is an env-key writer too.  Refuse
      * an overlap with a registry API key (or a process-reserved key) before the
@@ -1349,7 +1428,7 @@ export class FleetManager {
         const action = data.command;
         const classicName = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
         if (classicName) {
-            if (!this.classicChannels?.isAdmin(data.userId)) {
+            if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
                 await data.respond(t("permission.denied"));
                 return;
             }
@@ -1380,10 +1459,30 @@ export class FleetManager {
         }
         await data.respond(await this.topicCommands.runPauseWake(target, action));
     }
+    /** SIGUSR2: restart the instances inside this process. Names who asked (#1120). */
+    onGracefulRestartSignal(rearm) {
+        this.logger.info(`Received SIGUSR2, initiating graceful restart... ${describeSignalSource(this.dataDir, "SIGUSR2")}`);
+        this.restartInstances()
+            .catch(err => this.logger.error({ err }, "Graceful restart failed"))
+            .finally(rearm);
+    }
+    /** SIGUSR1: full process reload. Names who asked (#1120). */
+    onFullRestartSignal() {
+        this.logger.info(`Received SIGUSR1, initiating full restart (process reload)... ${describeSignalSource(this.dataDir, "SIGUSR1")}`);
+        this.gracefulShutdownForReload()
+            .then(() => {
+            this.logger.info("Full restart: shutdown complete, exiting for reload");
+            process.exit(0);
+        })
+            .catch(err => {
+            this.logger.error({ err }, "Full restart: graceful shutdown failed");
+            process.exit(1);
+        });
+    }
     async handleUpdateSlash(data, adapterId) {
-        const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-        if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-            await data.respond(t("not_authorized"));
+        const gate = this.fleetAdminGate(data.userId, adapterId);
+        if (gate !== "ok") {
+            await data.respond(t(gate === "disabled" ? "update.disabled" : "not_authorized"));
             return;
         }
         const messageId = await data.respond(t("update.progress.preparing", 0));
@@ -1395,7 +1494,11 @@ export class FleetManager {
         const { spawn } = await import("node:child_process");
         const currentVersion = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8")).version ?? "";
         const command = currentVersion.includes("beta") ? "agend update --beta" : "agend update";
-        const child = spawn("sh", ["-c", `sleep 2 && ${command}`], { detached: true, stdio: "ignore" });
+        const origin = `slash /update by ${adapterId}:${data.userId}`;
+        recordInternalRequest(this.dataDir, "update", origin);
+        const child = spawn("sh", ["-c", `sleep 2 && ${command}`], {
+            detached: true, stdio: "ignore", env: withOrigin(origin),
+        });
         child.once("error", err => this.failUpdateProgress(err.message));
         child.unref();
     }
@@ -1404,6 +1507,7 @@ export class FleetManager {
             await data.respond(t("not_authorized"));
             return;
         }
+        recordInternalRequest(this.dataDir, "restart", `slash /restart ${String(data.options?.mode ?? "graceful")} by ${adapterId}:${data.userId}`);
         if (data.options?.mode !== "full") {
             await data.respond(t("restart.graceful"));
             process.kill(process.pid, "SIGUSR2");
@@ -2102,6 +2206,288 @@ export class FleetManager {
         const allowed = this.getChannelConfig(adapterId)?.access?.allowed_users ?? [];
         return allowed.some(entry => String(entry) === String(userId));
     }
+    /** Whether this adapter has any fleet admin at all (an empty allowlist means the admin commands are off). */
+    hasFleetAdmins(adapterId) {
+        return (this.getChannelConfig(adapterId)?.access?.allowed_users ?? []).length > 0;
+    }
+    /**
+     * The one question the privileged commands (/update, /doctor, /dashboard, /collab) ask: may THIS caller,
+     * through THIS adapter, run it. `disabled` is "nobody can" — an empty list — and is told apart from
+     * `denied` only so the reply can say so. An empty list never means "everyone": these commands used to read
+     * the primary channel's list and treat empty as open, so on a fleet that had not set one anyone who could
+     * type a slash command could `/update` the host.
+     */
+    fleetAdminGate(userId, adapterId) {
+        if (!this.hasFleetAdmins(adapterId))
+            return "disabled";
+        return this.isFleetAdmin(userId, adapterId) ? "ok" : "denied";
+    }
+    /**
+     * Every Discord slash command, for every adapter, in one place (it used to be two copies that could drift).
+     *
+     * Two checks before any command's own code runs, and the order matters: the DOOR (src/slash-authz.ts — may
+     * this caller speak here at all) and then the COMMAND TABLE (src/command-table.ts — does this command apply
+     * in this kind of channel, and which kind of admin does it need). The table can only narrow what the door
+     * let through. A command nobody registered is answered, not left to time out.
+     */
+    async dispatchSlash(data, adapterId, adapter) {
+        const scope = await this.authorizeSlash(data, adapterId);
+        if (!scope)
+            return;
+        const spec = commandSpec(data.command);
+        if (!spec) {
+            this.logger.info({ command: data.command, adapterId }, "Slash command is not in the command table");
+            await data.respond(t("slash.unknown_command")).catch(() => { });
+            return;
+        }
+        const decision = decideCommand(spec, scope, {
+            fleetAdmin: () => this.fleetAdminGate(data.userId, adapterId),
+            channelAdmin: () => this.isModelAdmin(data.userId, data.channelId, adapterId),
+            classicAdmin: () => !!this.classicChannels?.isAdmin(data.userId),
+        });
+        if (!decision.allow) {
+            this.logger.info({ command: data.command, adapterId, scope, reply: decision.reply[0] }, "Slash command refused by the command table");
+            const [key, ...args] = decision.reply;
+            await data.respond(t(key, ...args)).catch(() => { });
+            return;
+        }
+        if (data.command === "start") {
+            await this.handleClassicStartSlash(data, adapterId);
+        }
+        else if (data.command === "stop") {
+            const reply = await this.handleClassicStop(data.channelId, adapterId);
+            await data.respond(reply);
+        }
+        else if (data.command === "pause" || data.command === "wake") {
+            await this.handlePauseWakeSlash(data, adapterId);
+        }
+        else if (data.command === "chat") {
+            const text = data.text ?? "";
+            if (!text) {
+                await data.respond(t("chat.usage"));
+                return;
+            }
+            const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent_start"));
+                return;
+            }
+            const status = this.resolveStatusEmojisFor(name, adapterId, adapter);
+            const replyMsgId = await data.respond(textForm(status.platform, status.received));
+            const username = data.username ?? data.userId;
+            ClassicChannelManager.logMessage(name, username, `/chat ${text}`, new Date());
+            await this.forwardToClassicInstance(name, text, {
+                chatId: data.channelId,
+                threadId: data.channelId,
+                messageId: replyMsgId ?? "",
+                userId: data.userId,
+                username,
+                source: "discord",
+                timestamp: new Date(),
+            });
+        }
+        else if (data.command === "save") {
+            await this.handleSlashSave(data, adapterId);
+        }
+        else if (data.command === "load") {
+            // load is kiro-cli/classic only — no claude-code equivalent. (Classic admins only: the command table.)
+            const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent_start"));
+                return;
+            }
+            const filename = data.options?.filename;
+            if (!SAVE_FILENAME_RE.test(filename ?? "")) {
+                await data.respond(t("filename.invalid"));
+                return;
+            }
+            this.pasteRawToClassicInstance(name, `/chat load ${filename}`);
+            await data.respond(t("save.sent", `/chat load ${filename}`, name));
+        }
+        else if (data.command === "model") {
+            await this.handleModelSlash(data, adapterId);
+        }
+        else if (data.command === "clear") {
+            await this.handleClearSlash(data, adapterId);
+        }
+        else if (data.command === "effort") {
+            await this.handleEffortSlash(data, adapterId);
+        }
+        else if (data.command === "cancel") {
+            const name = this.resolveSlashTarget(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent"));
+                return;
+            }
+            const ok = this.cancelInstance(name);
+            await data.respond(ok ? t("cancel.sent", name) : t("cancel.not_running", name));
+        }
+        else if (data.command === "ctx") {
+            const name = this.resolveSlashTarget(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent"));
+                return;
+            }
+            // Single source of truth (statusline.json + robust tmux pane fallback).
+            await data.respond(await this.topicCommands.getCtxText(name));
+        }
+        else if (data.command === "collab") {
+            // The scope the door and the table authorized is the scope this acts in. A channel can be in both the
+            // ClassicBot registry and the routing table (two configurations that each validate); the door and
+            // `isModelAdmin` read the registry first, so a ClassicBot admin was judged for the ClassicBot channel
+            // here and must not be handed the fleet instance's collab switch by a second, routing-first lookup.
+            const collabTarget2 = scope === "classic" ? undefined : this.routing.resolve(data.channelId);
+            if (collabTarget2) {
+                const isCollab = this.toggleFleetCollab(collabTarget2.name);
+                await data.respond(isCollab ? t("collab.on") : t("collab.off"));
+                return;
+            }
+            if (!this.classicChannels?.isClassicChannel(data.channelId, adapterId)) {
+                await data.respond(t("classic.no_agent_start"));
+                return;
+            }
+            const newState = this.classicChannels.toggleCollab(data.channelId, adapterId);
+            await data.respond(newState
+                ? t("collab.on.classic")
+                : t("collab.off.classic"));
+        }
+        else if (data.command === "update") {
+            await this.handleUpdateSlash(data, adapterId);
+        }
+        else if (data.command === "doctor") {
+            await data.respond(await this.runBackendDoctor());
+        }
+        else if (data.command === "usage") {
+            // Same permission level as /ctx (none). The reply is still ephemeral —
+            // the adapter defers non-chat commands that way — so it never spams the
+            // channel either way.
+            try {
+                const { getUsageSnapshot } = await import("./usage/usage-api.js");
+                const { renderUsageMarkdown } = await import("./usage/format-rich.js");
+                // slash_command is Discord-only; editReply renders Markdown natively.
+                await data.respond(renderUsageMarkdown(await getUsageSnapshot(false, this.getActiveUsageProviderIds())));
+            }
+            catch (err) {
+                await data.respond(t("usage.failed", err.message));
+            }
+        }
+        else if (data.command === "tips") {
+            await this.handleTipsSlash(data, adapterId);
+        }
+        else if (data.command === "status") {
+            // Admin-gated (like the topic path): the merged table shows every
+            // instance's cost and IPC health.
+            if (!this.isFleetAdmin(data.userId, adapterId)) {
+                await data.respond(t("cmd.admin_required", "/status"));
+                return;
+            }
+            const text = await this.topicCommands.getStatusText();
+            await data.respond(text);
+        }
+        else if (data.command === "sysinfo") {
+            // Slash commands are Discord-only; use plain lines (no markdown table)
+            await this.topicCommands.sendSysInfo(text => data.respond(text), { platform: "discord" });
+        }
+        else if (data.command === "dashboard") {
+            // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
+            // the web-token-bearing URLs are only visible to the caller.
+            await data.respond(this.topicCommands.getDashboardText());
+        }
+        else if (data.command === "restart") {
+            await this.handleRestartSlash(data, adapterId);
+        }
+        else if (data.command === "compact") {
+            const name = this.resolveSlashTarget(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent"));
+                return;
+            }
+            const result = await this.topicCommands.sendCompact(name, String(data.options?.instructions ?? ""));
+            await data.respond(result);
+        }
+        else if (data.command === "steer") {
+            const name = this.resolveSlashTarget(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent"));
+                return;
+            }
+            const steerText = String(data.options?.message ?? "").trim();
+            if (!steerText) {
+                await data.respond(t("steer.usage"));
+                return;
+            }
+            // chat_id/message_id stay empty: a slash interaction has no channel
+            // message to react to, and an empty chat_id keeps updateLastChat from
+            // rerouting the instance's replies to the slash context.
+            const result = this.topicCommands.sendSteer(name, steerText, {
+                chatId: "", messageId: "", username: data.username ?? "user",
+                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+            });
+            await data.respond(result);
+        }
+        else if (data.command === "btw") {
+            const name = this.resolveSlashTarget(data.channelId, adapterId);
+            if (!name) {
+                await data.respond(t("classic.no_agent"));
+                return;
+            }
+            const btwText = String(data.options?.message ?? "").trim();
+            if (!btwText) {
+                await data.respond(t("btw.usage"));
+                return;
+            }
+            const result = this.topicCommands.sendBtw(name, btwText, {
+                chatId: "", messageId: "", username: data.username ?? "user",
+                userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
+            });
+            await data.respond(result);
+        }
+        else if (data.command === "login") {
+            await this.handleLoginSlash(data, adapterId, adapter);
+        }
+    }
+    /**
+     * The door every Discord slash command goes through (src/slash-authz.ts has the rule and the reasoning).
+     * Answers the caller itself when it refuses, so a refused command costs one reply and does nothing else.
+     */
+    async authorizeSlash(data, adapterId) {
+        const channelId = data.channelId;
+        const classic = !!this.classicChannels?.isClassicChannel(channelId, adapterId);
+        const fleetTarget = classic ? undefined : this.routing.resolve(channelId);
+        const scope = classic ? "classic" : fleetTarget ? "fleet" : "none";
+        // The table tells the General dispatcher from an instance's own channel; the door does not need to.
+        const commandScope = classic ? "classic" : fleetTarget ? (fleetTarget.kind === "general" ? "general" : "fleet") : "none";
+        let speaker = "denied";
+        if (scope !== "classic") {
+            // The same world the typed-message path would consult: the adapter that owns the channel's instance,
+            // else the one the command arrived on.
+            const ownerId = fleetTarget ? this.getInstanceAdapterId(fleetTarget.name) : undefined;
+            const ownerWorld = ownerId ? this.worlds.get(ownerId) : undefined;
+            if (ownerId && !ownerWorld) {
+                speaker = "owner-not-running";
+            }
+            else {
+                const am = ownerWorld?.accessManager ?? this.worlds.get(adapterId)?.accessManager ?? this.accessManager;
+                // An explicit fleet admin always speaks, even if the access state file disagrees with the config.
+                speaker = this.isFleetAdmin(data.userId, adapterId) || (am?.isAllowed(data.userId) ?? false) ? "allowed" : "denied";
+            }
+        }
+        const facts = {
+            command: data.command,
+            guildId: data.guildId,
+            primaryGuildId: String(this.getChannelConfig(adapterId)?.group_id ?? ""),
+            scope,
+            speaker,
+        };
+        const decision = decideSlash(facts);
+        if (decision.allow)
+            return commandScope;
+        this.logger.info({ command: data.command, reason: decision.reason, adapterId, guildId: data.guildId ?? null, channelId, scope }, "Slash command refused");
+        await data.respond(t(decision.reason === "dm" ? "slash.dm_unsupported"
+            : decision.reason === "wrong-guild" ? "slash.wrong_server"
+                : "not_authorized")).catch(() => { });
+        return null;
+    }
     /** Phase 2: delivery_worker for a target (instance override → fleet default → wake_only). */
     deliveryWorkerMode(target) {
         return resolveDeliveryWorkerMode(this.fleetConfig, target);
@@ -2334,6 +2720,10 @@ export class FleetManager {
     resumePaused = false, 
     /** Phase 2a: the caller's transition, for a start made from inside a restart or wake. */
     transition) {
+        // CLI single-instance cold starts bypass startAll. Start diagnostics before
+        // any lifecycle/wake work; a shutdown must not revive the stopped sampler.
+        if (!this.shuttingDown)
+            this.memoryPressure?.start();
         // Any start supersedes a pending automatic retry (it would otherwise fire
         // into a running instance — harmless, but noisy — or race this start).
         this.cancelStartupRetry(name);
@@ -2448,6 +2838,7 @@ export class FleetManager {
             instanceName: name,
             workingDirectory: config.working_directory,
             reason: "startup",
+            stage: "lifecycle",
         }, async () => {
             if (await this.startInstanceUnattended(name, config, topicMode, "instance"))
                 onReady?.(name);
@@ -2587,6 +2978,7 @@ export class FleetManager {
                 instanceName: name,
                 workingDirectory: this.fleetConfig?.instances[name]?.working_directory || this.getInstanceDir(name),
                 reason: "recovery",
+                stage: "lifecycle",
             }, () => this.startConfiguredInstance(name, topicMode));
             if (this.daemons.has(name)) {
                 this.logger.info({ name, attempt: attempt + 1 }, "Automatic startup retry succeeded");
@@ -2704,8 +3096,58 @@ export class FleetManager {
             return false;
         this.logger.error({ name, reason: err.message }, `Not starting ${what}: the installed CLI cannot run it as configured`);
         this.queueUnsupportedCliNotice(name, err.message);
+        this.queueKiroIncompatNotice(name, err.message);
         return true;
     }
+    /**
+     * LifecycleContext: a kiro instance the installed kiro-cli cannot run as
+     * configured (#1109) — at start, or at a respawn after kiro-cli replaced
+     * itself. The operator already gets the plain notice; this tells every
+     * General, as an agent, so it can explain the kiro engine move when asked.
+     * One notice per refusal reason, like the operator's.
+     */
+    queueKiroIncompatNotice(name, reason) {
+        // The effective backend, ClassicBot channels included: they are not in fleetConfig.instances.
+        if (this.backendNameForInstance(name) !== "kiro-cli")
+            return;
+        const pending = this.kiroIncompatNotices.get(reason);
+        if (pending) {
+            if (!pending.names.includes(name))
+                pending.names.push(name);
+            return;
+        }
+        const timer = setTimeout(() => {
+            const entry = this.kiroIncompatNotices.get(reason);
+            this.kiroIncompatNotices.delete(reason);
+            if (entry)
+                this.sendKiroIncompatToGenerals(entry.names, reason);
+        }, FleetManager.STARTUP_RETRY_NOTICE_AGGREGATE_MS);
+        timer.unref?.();
+        this.kiroIncompatNotices.set(reason, { names: [name], timer });
+    }
+    /**
+     * Held in the delivery outbox until each General takes it: the same kiro-cli
+     * may have stopped the General too, and it should still hear once it is back.
+     * Admitted once per day per refusal (reason + names) and General.
+     */
+    sendKiroIncompatToGenerals(names, reason, now = new Date()) {
+        const generals = Object.entries(this.fleetConfig?.instances ?? {})
+            .filter(([, config]) => config.general_topic === true).map(([general]) => general);
+        if (generals.length === 0)
+            return;
+        try {
+            this.ensureDeliveryOutbox();
+            const sorted = [...names].sort();
+            const digest = createHash("sha256").update(`${reason}\u0000${sorted.join(",")}`).digest("hex").slice(0, 16);
+            const content = t("fleet.kiro_incompat_general", sorted.join(", "), reason);
+            for (const general of generals) {
+                this.deliveryOutbox.admitSystemNotice(general, `kiro-incompat:${now.toISOString().slice(0, 10)}:${digest}:${general}`, content, now);
+            }
+        }
+        catch (err) {
+            this.logger.warn({ err, names }, "Could not queue the kiro incompatibility notice for General");
+        }
+    }
     /**
      * One notice per refusal reason: a kiro-cli that dropped the legacy UI
      * refuses every kiro instance at once, and that is one message, not ten.
@@ -2879,6 +3321,7 @@ export class FleetManager {
             instanceName: name,
             workingDirectory,
             reason: "restart",
+            stage: "lifecycle",
         }, () => this.doRestartSingleInstance(name, opts, transition)))
             .finally(() => {
             this.restartsInFlight.delete(name);
@@ -3254,6 +3697,9 @@ export class FleetManager {
             setUpdateProgressStage(this.dataDir, "starting", { version: pendingUpdateProgress.progress.version });
         }
         this.initializeWebAuthTokens();
+        // Must run before the first General/CLI spawn: pressure can hold startup.
+        // Logs remain available even before the adapters and health listener exist.
+        this.memoryPressure.start();
         const topicMode = fleet.channel?.mode === "topic" || !!fleet.channels?.some(ch => ch.mode === "topic");
         // Set tmux socket isolation for custom AGEND_HOME
         const { getTmuxSocketName: getSocket } = await import("./paths.js");
@@ -3696,27 +4142,10 @@ export class FleetManager {
             this.checkForUpdates();
             this.updateCheckTimer = setInterval(() => this.checkForUpdates(), 24 * 60 * 60 * 1000);
         }, 60 * 60 * 1000);
-        const onRestart = () => {
-            this.logger.info("Received SIGUSR2, initiating graceful restart...");
-            this.restartInstances()
-                .catch(err => this.logger.error({ err }, "Graceful restart failed"))
-                .finally(() => process.once("SIGUSR2", onRestart));
-        };
+        const onRestart = () => this.onGracefulRestartSignal(() => process.once("SIGUSR2", onRestart));
         process.once("SIGUSR2", onRestart);
         // SIGUSR1: full process reload (graceful stop → exit → CLI restarts)
-        const onFullRestart = () => {
-            this.logger.info("Received SIGUSR1, initiating full restart (process reload)...");
-            this.gracefulShutdownForReload()
-                .then(() => {
-                this.logger.info("Full restart: shutdown complete, exiting for reload");
-                process.exit(0);
-            })
-                .catch(err => {
-                this.logger.error({ err }, "Full restart: graceful shutdown failed");
-                process.exit(1);
-            });
-        };
-        process.once("SIGUSR1", onFullRestart);
+        process.once("SIGUSR1", () => this.onFullRestartSignal());
         // A SIGHUP may arrive after the PID/general is available but before the
         // rest of startup finishes. Replay one coalesced reload only after all
         // startup-owned lifecycle work and signal handlers are in place.
@@ -4002,6 +4431,10 @@ export class FleetManager {
                 connected++;
         }
         const problems = [];
+        const hostMemory = this.memoryPressure.snapshot();
+        if (hostMemory.level === "critical" || hostMemory.level === "elevated") {
+            problems.push(`host memory pressure is ${hostMemory.level}`);
+        }
         if (this.adapterState.size > 0 && connected === 0)
             problems.push("no channel adapter is connected");
         if (counts.crashed > 0)
@@ -4024,6 +4457,7 @@ export class FleetManager {
             adapters: { total: this.adapterState.size, connected, states, details },
             startupComplete: this.startupComplete,
             memory: readFleetMemory(),
+            hostMemory,
             problems,
         };
     }
@@ -4074,273 +4508,7 @@ export class FleetManager {
         this.adapter.on("slash_command", safeHandler(async (data) => {
             if (!isCurrentAdapter())
                 return;
-            if (data.command === "start") {
-                await this.handleClassicStartSlash(data, adapterId);
-            }
-            else if (data.command === "stop") {
-                const reply = await this.handleClassicStop(data.channelId, adapterId);
-                await data.respond(reply);
-            }
-            else if (data.command === "pause" || data.command === "wake") {
-                await this.handlePauseWakeSlash(data, adapterId);
-            }
-            else if (data.command === "chat") {
-                const text = data.text ?? "";
-                if (!text) {
-                    await data.respond(t("chat.usage"));
-                    return;
-                }
-                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent_start"));
-                    return;
-                }
-                const replyMsgId = await data.respond("👀");
-                const username = data.username ?? data.userId;
-                ClassicChannelManager.logMessage(name, username, `/chat ${text}`, new Date());
-                await this.forwardToClassicInstance(name, text, {
-                    chatId: data.channelId,
-                    threadId: data.channelId,
-                    messageId: replyMsgId ?? "",
-                    userId: data.userId,
-                    username,
-                    source: "discord",
-                    timestamp: new Date(),
-                });
-            }
-            else if (data.command === "save") {
-                await this.handleSlashSave(data, adapterId);
-            }
-            else if (data.command === "load") {
-                // load is kiro-cli/classic only — no claude-code equivalent.
-                if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond(t("admin.required"));
-                    return;
-                }
-                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent_start"));
-                    return;
-                }
-                const filename = data.options?.filename;
-                if (!SAVE_FILENAME_RE.test(filename ?? "")) {
-                    await data.respond(t("filename.invalid"));
-                    return;
-                }
-                this.pasteRawToClassicInstance(name, `/chat load ${filename}`);
-                await data.respond(t("save.sent", `/chat load ${filename}`, name));
-            }
-            else if (data.command === "compact") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const result = await this.topicCommands.sendCompact(name);
-                await data.respond(result);
-            }
-            else if (data.command === "steer") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const steerText = String(data.options?.message ?? "").trim();
-                if (!steerText) {
-                    await data.respond(t("steer.usage"));
-                    return;
-                }
-                // chat_id/message_id stay empty: a slash interaction has no channel
-                // message to react to, and an empty chat_id keeps updateLastChat from
-                // rerouting the instance's replies to the slash context.
-                const result = this.topicCommands.sendSteer(name, steerText, {
-                    chatId: "", messageId: "", username: data.username ?? "user",
-                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
-                });
-                await data.respond(result);
-            }
-            else if (data.command === "btw") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const btwText = String(data.options?.message ?? "").trim();
-                if (!btwText) {
-                    await data.respond(t("btw.usage"));
-                    return;
-                }
-                const result = this.topicCommands.sendBtw(name, btwText, {
-                    chatId: "", messageId: "", username: data.username ?? "user",
-                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
-                });
-                await data.respond(result);
-            }
-            else if (data.command === "login") {
-                await this.handleLoginSlash(data, adapterId, this.adapter);
-            }
-            else if (data.command === "clear") {
-                await this.handleClearSlash(data, adapterId);
-            }
-            else if (data.command === "model") {
-                await this.handleModelSlash(data, adapterId);
-            }
-            else if (data.command === "effort") {
-                await this.handleEffortSlash(data, adapterId);
-            }
-            else if (data.command === "cancel") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const ok = this.cancelInstance(name);
-                await data.respond(ok ? t("cancel.sent", name) : t("cancel.not_running", name));
-            }
-            else if (data.command === "ctx") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                // Single source of truth (statusline.json + robust tmux pane fallback).
-                await data.respond(await this.topicCommands.getCtxText(name));
-            }
-            else if (data.command === "collab") {
-                // Classic no longer lives in the routing engine, so a routing hit here is
-                // always a fleet-topic instance.
-                const collabTarget = this.routing.resolve(data.channelId);
-                if (collabTarget) {
-                    const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                    if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                        await data.respond(t("not_authorized"));
-                        return;
-                    }
-                    const isCollab = this.toggleFleetCollab(collabTarget.name);
-                    await data.respond(isCollab ? t("collab.on") : t("collab.off"));
-                    return;
-                }
-                if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond(t("admin.required"));
-                    return;
-                }
-                if (!this.classicChannels.isClassicChannel(data.channelId, adapterId)) {
-                    await data.respond(t("classic.no_agent_start"));
-                    return;
-                }
-                const newState = this.classicChannels.toggleCollab(data.channelId, adapterId);
-                await data.respond(newState
-                    ? t("collab.on.classic")
-                    : t("collab.off.classic"));
-            }
-            else if (data.command === "update") {
-                await this.handleUpdateSlash(data, adapterId);
-            }
-            else if (data.command === "doctor") {
-                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond(t("not_authorized"));
-                    return;
-                }
-                await data.respond(await this.runBackendDoctor());
-            }
-            else if (data.command === "usage") {
-                // Same permission level as /ctx (none). The reply is still ephemeral —
-                // the adapter defers non-chat commands that way — so it never spams the
-                // channel either way.
-                try {
-                    const { getUsageSnapshot } = await import("./usage/usage-api.js");
-                    const { renderUsageMarkdown } = await import("./usage/format-rich.js");
-                    // slash_command is Discord-only; editReply renders Markdown natively.
-                    await data.respond(renderUsageMarkdown(await getUsageSnapshot(false, this.getActiveUsageProviderIds())));
-                }
-                catch (err) {
-                    await data.respond(t("usage.failed", err.message));
-                }
-            }
-            else if (data.command === "tips") {
-                await this.handleTipsSlash(data, adapterId);
-            }
-            else if (data.command === "status") {
-                // Admin-gated (like the topic path): the merged table shows every
-                // instance's cost and IPC health.
-                if (!this.isFleetAdmin(data.userId, adapterId)) {
-                    await data.respond(t("cmd.admin_required", "/status"));
-                    return;
-                }
-                const text = await this.topicCommands.getStatusText();
-                await data.respond(text);
-            }
-            else if (data.command === "sysinfo") {
-                // Slash commands are Discord-only; use plain lines (no markdown table)
-                await this.topicCommands.sendSysInfo(text => data.respond(text), { platform: "discord" });
-            }
-            else if (data.command === "dashboard") {
-                // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
-                // the web-token-bearing URLs are only visible to the caller.
-                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                if (allowed.length === 0) {
-                    await data.respond(t("dashboard.disabled"));
-                    return;
-                }
-                if (!allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond(t("not_authorized"));
-                    return;
-                }
-                await data.respond(this.topicCommands.getDashboardText());
-            }
-            else if (data.command === "restart") {
-                await this.handleRestartSlash(data, adapterId);
-            }
-            else if (data.command === "compact") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const result = await this.topicCommands.sendCompact(name);
-                await data.respond(result);
-            }
-            else if (data.command === "steer") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const steerText = String(data.options?.message ?? "").trim();
-                if (!steerText) {
-                    await data.respond(t("steer.usage"));
-                    return;
-                }
-                // chat_id/message_id stay empty: a slash interaction has no channel
-                // message to react to, and an empty chat_id keeps updateLastChat from
-                // rerouting the instance's replies to the slash context.
-                const result = this.topicCommands.sendSteer(name, steerText, {
-                    chatId: "", messageId: "", username: data.username ?? "user",
-                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
-                });
-                await data.respond(result);
-            }
-            else if (data.command === "btw") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const btwText = String(data.options?.message ?? "").trim();
-                if (!btwText) {
-                    await data.respond(t("btw.usage"));
-                    return;
-                }
-                const result = this.topicCommands.sendBtw(name, btwText, {
-                    chatId: "", messageId: "", username: data.username ?? "user",
-                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
-                });
-                await data.respond(result);
-            }
-            else if (data.command === "login") {
-                await this.handleLoginSlash(data, adapterId, this.adapter);
-            }
+            await this.dispatchSlash(data, adapterId, adapter);
         }, this.logger, "adapter.slash_command"));
         await this.topicCommands.registerBotCommands().catch(e => this.logger.warn({ err: e }, "registerBotCommands failed (non-fatal)"));
         // Background-probe each backend's CLI env (version/models) → cli-env cache.
@@ -4444,224 +4612,7 @@ export class FleetManager {
         adapter.on("slash_command", safeHandler(async (data) => {
             if (!isCurrentAdapter())
                 return;
-            if (data.command === "start") {
-                await this.handleClassicStartSlash(data, adapterId);
-            }
-            else if (data.command === "stop") {
-                const reply = await this.handleClassicStop(data.channelId, adapterId);
-                await data.respond(reply);
-            }
-            else if (data.command === "pause" || data.command === "wake") {
-                await this.handlePauseWakeSlash(data, adapterId);
-            }
-            else if (data.command === "chat") {
-                const text = data.text ?? "";
-                if (!text) {
-                    await data.respond(t("chat.usage"));
-                    return;
-                }
-                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent_start"));
-                    return;
-                }
-                const replyMsgId = await data.respond("👀");
-                const username = data.username ?? data.userId;
-                ClassicChannelManager.logMessage(name, username, `/chat ${text}`, new Date());
-                await this.forwardToClassicInstance(name, text, {
-                    chatId: data.channelId,
-                    threadId: data.channelId,
-                    messageId: replyMsgId ?? "",
-                    userId: data.userId,
-                    username,
-                    source: channelConfig.type,
-                    timestamp: new Date(),
-                });
-            }
-            else if (data.command === "save") {
-                await this.handleSlashSave(data, adapterId);
-            }
-            else if (data.command === "load") {
-                // load is kiro-cli/classic only — no claude-code equivalent.
-                if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond(t("admin.required"));
-                    return;
-                }
-                const name = this.classicChannels?.getInstanceByChannel(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent_start"));
-                    return;
-                }
-                const filename = data.options?.filename;
-                if (!SAVE_FILENAME_RE.test(filename ?? "")) {
-                    await data.respond(t("filename.invalid"));
-                    return;
-                }
-                this.pasteRawToClassicInstance(name, `/chat load ${filename}`);
-                await data.respond(t("save.sent", `/chat load ${filename}`, name));
-            }
-            else if (data.command === "model") {
-                await this.handleModelSlash(data, adapterId);
-            }
-            else if (data.command === "clear") {
-                await this.handleClearSlash(data, adapterId);
-            }
-            else if (data.command === "effort") {
-                await this.handleEffortSlash(data, adapterId);
-            }
-            else if (data.command === "cancel") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const ok = this.cancelInstance(name);
-                await data.respond(ok ? t("cancel.sent", name) : t("cancel.not_running", name));
-            }
-            else if (data.command === "ctx") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                // Single source of truth (statusline.json + robust tmux pane fallback).
-                await data.respond(await this.topicCommands.getCtxText(name));
-            }
-            else if (data.command === "collab") {
-                // Classic no longer lives in the routing engine, so a routing hit here is
-                // always a fleet-topic instance.
-                const collabTarget2 = this.routing.resolve(data.channelId);
-                if (collabTarget2) {
-                    const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                    if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                        await data.respond(t("not_authorized"));
-                        return;
-                    }
-                    const isCollab = this.toggleFleetCollab(collabTarget2.name);
-                    await data.respond(isCollab ? t("collab.on") : t("collab.off"));
-                    return;
-                }
-                if (!this.classicChannels?.isAdmin(data.userId)) {
-                    await data.respond(t("admin.required"));
-                    return;
-                }
-                if (!this.classicChannels.isClassicChannel(data.channelId, adapterId)) {
-                    await data.respond(t("classic.no_agent_start"));
-                    return;
-                }
-                const newState = this.classicChannels.toggleCollab(data.channelId, adapterId);
-                await data.respond(newState
-                    ? t("collab.on.classic")
-                    : t("collab.off.classic"));
-            }
-            else if (data.command === "update") {
-                await this.handleUpdateSlash(data, adapterId);
-            }
-            else if (data.command === "doctor") {
-                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                if (allowed.length > 0 && !allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond(t("not_authorized"));
-                    return;
-                }
-                await data.respond(await this.runBackendDoctor());
-            }
-            else if (data.command === "usage") {
-                // Same permission level as /ctx (none). The reply is still ephemeral —
-                // the adapter defers non-chat commands that way — so it never spams the
-                // channel either way.
-                try {
-                    const { getUsageSnapshot } = await import("./usage/usage-api.js");
-                    const { renderUsageMarkdown } = await import("./usage/format-rich.js");
-                    // slash_command is Discord-only; editReply renders Markdown natively.
-                    await data.respond(renderUsageMarkdown(await getUsageSnapshot(false, this.getActiveUsageProviderIds())));
-                }
-                catch (err) {
-                    await data.respond(t("usage.failed", err.message));
-                }
-            }
-            else if (data.command === "tips") {
-                await this.handleTipsSlash(data, adapterId);
-            }
-            else if (data.command === "status") {
-                // Admin-gated (like the topic path): the merged table shows every
-                // instance's cost and IPC health.
-                if (!this.isFleetAdmin(data.userId, adapterId)) {
-                    await data.respond(t("cmd.admin_required", "/status"));
-                    return;
-                }
-                const text = await this.topicCommands.getStatusText();
-                await data.respond(text);
-            }
-            else if (data.command === "sysinfo") {
-                // Slash commands are Discord-only; use plain lines (no markdown table)
-                await this.topicCommands.sendSysInfo(text => data.respond(text), { platform: "discord" });
-            }
-            else if (data.command === "dashboard") {
-                // Reply is ephemeral (adapter defers non-chat commands ephemerally), so
-                // the web-token-bearing URLs are only visible to the caller.
-                const allowed = this.fleetConfig?.channel?.access?.allowed_users ?? [];
-                if (allowed.length === 0) {
-                    await data.respond(t("dashboard.disabled"));
-                    return;
-                }
-                if (!allowed.some(u => String(u) === String(data.userId))) {
-                    await data.respond(t("not_authorized"));
-                    return;
-                }
-                await data.respond(this.topicCommands.getDashboardText());
-            }
-            else if (data.command === "restart") {
-                await this.handleRestartSlash(data, adapterId);
-            }
-            else if (data.command === "compact") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const result = await this.topicCommands.sendCompact(name);
-                await data.respond(result);
-            }
-            else if (data.command === "steer") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const steerText = String(data.options?.message ?? "").trim();
-                if (!steerText) {
-                    await data.respond(t("steer.usage"));
-                    return;
-                }
-                // chat_id/message_id stay empty: a slash interaction has no channel
-                // message to react to, and an empty chat_id keeps updateLastChat from
-                // rerouting the instance's replies to the slash context.
-                const result = this.topicCommands.sendSteer(name, steerText, {
-                    chatId: "", messageId: "", username: data.username ?? "user",
-                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
-                });
-                await data.respond(result);
-            }
-            else if (data.command === "btw") {
-                const name = this.resolveSlashTarget(data.channelId, adapterId);
-                if (!name) {
-                    await data.respond(t("classic.no_agent"));
-                    return;
-                }
-                const btwText = String(data.options?.message ?? "").trim();
-                if (!btwText) {
-                    await data.respond(t("btw.usage"));
-                    return;
-                }
-                const result = this.topicCommands.sendBtw(name, btwText, {
-                    chatId: "", messageId: "", username: data.username ?? "user",
-                    userId: data.userId ?? "", threadId: undefined, adapterId, source: "discord",
-                });
-                await data.respond(result);
-            }
-            else if (data.command === "login") {
-                await this.handleLoginSlash(data, adapterId, adapter);
-            }
+            await this.dispatchSlash(data, adapterId, adapter);
         }, this.logger, `adapter[${adapterId}].slash_command`));
         adapter.on("started", safeHandler((username, userId) => {
             if (!isCurrentAdapter())
@@ -5273,7 +5224,14 @@ export class FleetManager {
         // Key the dedup per-adapter there so a sibling bot's copy isn't dropped.
         if (msg.messageId) {
             const classicCid = threadId || msg.chatId;
-            const isClassicMsg = this.classicChannels?.hasChannel(classicCid) ?? false;
+            // First /start has no registration yet. A sibling can receive the same
+            // targeted command first, then reject its @suffix below; it must not
+            // consume the intended bot's key. Use the same Classic candidate scope
+            // as routing (including foreign forum topics normalized above, #1085).
+            const isTelegramClassicCandidate = msg.source === "telegram" && !threadId
+                && msg.chatId !== String(this.getChannelConfig(msg.adapterId)?.group_id ?? "");
+            const isClassicMsg = !!this.classicChannels
+                && (this.classicChannels.hasChannel(classicCid) || isTelegramClassicCandidate);
             const dedupKey = isClassicMsg
                 ? `${msg.source}:${msg.chatId}:${msg.messageId}:${msg.adapterId ?? ""}`
                 : `${msg.source}:${msg.chatId}:${msg.messageId}`;
@@ -5432,7 +5390,8 @@ export class FleetManager {
                     return;
                 }
                 // Handle /compact command (admin only)
-                if (text === "/compact" || text.startsWith("/compact@")) {
+                const classicCompact = parseCompactCommand(text);
+                if (classicCompact) {
                     if (!this.classicChannels.isAdmin(msg.userId)) {
                         await msgAdapter?.sendText(chatId, t("cmd.admin_required", "/compact"));
                         return;
@@ -5442,7 +5401,7 @@ export class FleetManager {
                         await msgAdapter?.sendText(chatId, t("classic.no_agent_start"));
                         return;
                     }
-                    const result = await this.topicCommands.sendCompact(compactName);
+                    const result = await this.topicCommands.sendCompact(compactName, classicCompact.instructions);
                     await msgAdapter?.sendText(chatId, result);
                     return;
                 }
@@ -7230,6 +7189,9 @@ export class FleetManager {
     pendingCliEnvProbes = new Map();
     /** Forced vendor catalog refreshes are separate flights, but sysinfo joins either flight. */
     pendingVendorCliEnvProbes = new Map();
+    pendingInstanceModelProbes = new Map();
+    cliEnvProbePool = new ProbeWorkerPool();
+    cliEnvProbeEpoch = 0;
     /**
      * The status emojis for an instance (#1005): its own `status_emojis`, then
      * its channel's `options.status_emojis`, then the platform built-in. An
@@ -7558,10 +7520,18 @@ export class FleetManager {
         return statusAvoidList(this.resolveStatusEmojisFor(instanceName));
     }
     /** The progress bubble's leading emoji, in the form the channel renders. */
-    progressPrefixFor(instanceName) {
+    progressPrefixFor(instanceName, elapsedMs = 0, minElapsedMs = this.progressMinElapsedMs()) {
         const r = this.resolveStatusEmojisFor(instanceName);
         const builtin = builtinStatusEmojis(r.platform).progress_prefix;
-        return r.progress_prefix === builtin ? undefined : textForm(r.platform, r.progress_prefix);
+        // Keep the built-in short/elapsed phases, but resolve their status values
+        // too. A custom progress prefix takes precedence in both phases.
+        // Telegram's built-in queued reaction is 👀; its elapsed *text* has always
+        // used ⏳ (text is not limited to Telegram's reaction vocabulary).
+        const queued = r.platform === "telegram" && r.queued === builtinStatusEmojis(r.platform).queued
+            ? builtinStatusEmojis(undefined).queued : r.queued;
+        const value = r.progress_prefix !== builtin ? r.progress_prefix
+            : elapsedMs < minElapsedMs ? r.processing : queued;
+        return textForm(r.platform, value);
     }
     /**
      * Is this inbound reaction one of the fleet's own delivery-status stamps?
@@ -8260,7 +8230,7 @@ export class FleetManager {
     }
     /**
      * A button from a prompt kind that no longer exists (#1131: `/install-cli`'s
-     * picker and its "sign in now?" prompt). Still on screen after an upgrade;
+     * picker and its "sign in now?" prompt; #1139: the relay login's provider picker). Still on screen after an upgrade;
      * a click gets the expired-prompt treatment — a private notice, the buttons
      * collapsed — instead of nothing.
      */
@@ -8281,8 +8251,6 @@ export class FleetManager {
             return true;
         if (await this.handleClassicApproval(data, adapterId, adapter))
             return true;
-        if (await this.handleLoginMenuSelect(data, adapterId, adapter))
-            return true;
         if (this.handleRetiredPromptButton(data, adapterId, adapter))
             return true;
         if (await this.handleLoginConfirm(data, adapterId, adapter))
@@ -8858,10 +8826,17 @@ export class FleetManager {
      * unsupported backends get a clear error. Routes via classic paste or fleet IPC.
      */
     async handleSlashSave(data, adapterId) {
-        if (!this.classicChannels?.isAdmin(data.userId)) {
+        // The admin of the channel's own kind (a fleet admin in a fleet channel). It used to ask for a ClassicBot
+        // admin everywhere, so a fleet admin was refused in their own channel and a ClassicBot admin could paste
+        // into a fleet instance.
+        if (!this.isModelAdmin(data.userId, data.channelId, adapterId)) {
             await data.respond(t("admin.required"));
             return;
         }
+        if (!this.classicChannels) {
+            await data.respond(t("classic.no_agent_start"));
+            return;
+        }
         // Classic resolves per-bot (same-channel multi-bot); otherwise a fleet topic.
         const classicName = this.classicChannels.getInstanceByChannel(data.channelId, adapterId);
         const target = classicName
@@ -8999,7 +8974,7 @@ export class FleetManager {
             return;
         }
         const publication = this.beginCancelButtonPublication(instanceName, correlationId);
-        const initialProgressText = FleetManager.progressText(0, null, 1, this.progressPrefixFor(instanceName));
+        const initialProgressText = FleetManager.progressText(0, null, 1, this.progressPrefixFor(instanceName, 0, 1));
         try {
             const sent = await adapter.notifyAlert(chatId, {
                 type: "cancel",
@@ -9215,7 +9190,8 @@ export class FleetManager {
      * wiped by the next elapsed tick (#528 trap 2).
      */
     composeBubbleText(entry) {
-        return FleetManager.bubbleText(Date.now() - (entry.startedAt ?? Date.now()), this.instanceActivity.get(entry.instanceName), this.progressMinElapsedMs(), entry.toolProgress, this.progressPrefixFor(entry.instanceName));
+        const elapsedMs = Date.now() - (entry.startedAt ?? Date.now());
+        return FleetManager.bubbleText(elapsedMs, this.instanceActivity.get(entry.instanceName), this.progressMinElapsedMs(), entry.toolProgress, this.progressPrefixFor(entry.instanceName, elapsedMs));
     }
     /** Pure composition of header + tool list, exposed for tests. */
     static bubbleText(elapsedMs, activity, minElapsedMs, progress, prefix) {
@@ -9521,16 +9497,11 @@ export class FleetManager {
     // shared ~/.codex; the other CLIs use one real home), so a single sign-in
     // repairs every instance of that backend, and instance delivery, pane-state
     // detection, tool progress, and mcp_proxy_reply never observe login output.
-    activeLogin = null;
-    /**
-     * Web-terminal login (v2.1.5 default, `login.mode: web`). The relay code
-     * below (activeLogin/LoginSession) is `login.mode: relay`, kept for one
-     * release as the rollback lever and removed in 2.1.6.
-     */
+    /** Web-terminal login: the only sign-in path (the chat-relay mode was removed, #1139). */
     loginController = null;
     /**
      * One login/install window fleet-wide. Claimed synchronously before the
-     * first await by web login, relay login and install alike (sol B1).
+     * first await by web login and install alike (sol B1).
      */
     loginWindow = new LoginWindowLock();
     get webLogin() {
@@ -9766,162 +9737,11 @@ export class FleetManager {
             this.logger.debug({ err, backend, flow }, "Could not record the /login flow");
         }
     }
-    /** The sign-in itself (web, or the legacy relay) for a CLI that is installed. */
+    /** The sign-in itself, in the web terminal, for a CLI that is installed. */
     async launchSignIn(backendArg, chat, opts = {}) {
-        if (this.webLogin.mode() === "web")
-            return this.webLogin.start(backendArg, chat, opts);
-        // ── legacy relay mode (login.mode: relay) — removed in 2.1.6 ──
-        const backend = LOGIN_BACKEND_ALIASES[backendArg.toLowerCase()] ?? backendArg.toLowerCase();
-        const flow = LOGIN_FLOWS[backend];
-        if (!flow)
-            return t("login.unsupported", backendArg);
-        // Declined in every mode — never a silent relay fallback (e.g. Antigravity).
-        if (flow.remoteLogin === "unsupported")
-            return t("login.remote_unsupported_agent_cli", backend, flow.command);
-        // Reserve the window before the pre-check await. The claim is owned by this
-        // region until it is transferred to launchLoginSession; any other exit
-        // (buttons only, throw, shutdown) releases it.
-        const claim = this.loginWindow.tryClaim("relay", backend);
-        if (!claim)
-            return this.loginWindow.busyMessage();
-        let transferred = false;
-        try {
-            return await this.startRelayClaimed(flow, backend, chat, opts, claim, () => { transferred = true; });
-        }
-        finally {
-            if (!transferred)
-                this.loginWindow.release(claim);
-        }
-    }
-    async startRelayClaimed(flow, backend, chat, opts, claim, markTransferred) {
-        // Token-free pre-check (5s cap): re-login while auth still works is
-        // usually a mistake, so it needs a confirmed click. An invalid OR
-        // uncertain result (timeout, missing binary) proceeds straight to login —
-        // an unreliable probe must never block the re-login the admin asked for.
-        if (!opts.skipAuthCheck && flow.authCheck) {
-            const status = await checkAuthStatus(flow.authCheck);
-            if (!this.loginWindow.isCurrent(claim))
-                return t("login.web_shutting_down"); // fleet shut down while we probed
-            if (status === "valid") {
-                const failure = await this.postChooser({
-                    prefix: LOGIN_CONFIRM_CALLBACK_PREFIX,
-                    alertType: "login",
-                    instanceName: backend,
-                    adapter: chat.adapter,
-                    adapterId: chat.adapterId,
-                    chatId: chat.chatId,
-                    threadId: chat.threadId,
-                    message: t("login.still_valid", backend),
-                    choices: [
-                        { action: "go", label: t("login.relogin_go") },
-                        { action: "cancel", label: t("login.relogin_cancel") },
-                    ],
-                    expiredText: t("buttons.stale"),
-                });
-                return failure ?? null;
-            }
-        }
-        markTransferred(); // launchLoginSession owns the claim from here
-        return this.launchLoginSession(flow, backend, chat, claim);
-    }
-    /** Create the login window and session (pre-check already settled). */
-    async launchLoginSession(flow, backend, chat, claim) {
-        // Owns `claim`: released on any failure before the session is published,
-        // and by onDone afterwards. A shutdown during ensureSession stops us.
-        let tmux;
-        try {
-            const sessionName = getTmuxSession();
-            await TmuxManager.ensureSession(sessionName);
-            if (!this.loginWindow.isCurrent(claim)) {
-                this.loginWindow.release(claim);
-                return t("login.web_shutting_down");
-            }
-            tmux = new TmuxManager(sessionName, "");
-        }
-        catch (err) {
-            this.loginWindow.release(claim);
-            return t("login.failed", backend, err.message);
-        }
-        const session = new LoginSession(flow, tmux, {
-            onMenu: async (options) => {
-                const failure = await this.postChooser({
-                    prefix: LOGIN_MENU_CALLBACK_PREFIX,
-                    alertType: "login",
-                    instanceName: backend,
-                    adapter: chat.adapter,
-                    adapterId: chat.adapterId,
-                    chatId: chat.chatId,
-                    threadId: chat.threadId,
-                    message: t("login.choose_provider"),
-                    choices: options.map((label, index) => ({ action: String(index), label })),
-                    expiredText: t("buttons.stale"),
-                });
-                if (failure) {
-                    await chat.adapter.sendText(chat.chatId, failure, { threadId: chat.threadId })
-                        .catch(err => this.logger.warn({ err, backend }, "Could not report a login menu that failed to post"));
-                }
-            },
-            onAuthHint: async (url, code) => {
-                await this.sendLoginSecret(chat, backend, url, code);
-            },
-            onNeedInput: async (promptExcerpt) => {
-                await chat.adapter.sendText(chat.chatId, t("login.need_input", backend, promptExcerpt), { threadId: chat.threadId }).catch(() => { });
-            },
-            onDone: async ({ ok, detail, cleanupFailed }) => {
-                this.activeLogin = null;
-                this.loginWindow.release(claim);
-                if (cleanupFailed) {
-                    await chat.adapter.sendText(chat.chatId, t("login.web_cleanup_failed", backend), { threadId: chat.threadId }).catch(() => { });
-                }
-                const send = (text) => chat.adapter.sendText(chat.chatId, text, { threadId: chat.threadId }).catch(() => { });
-                let text;
-                if (ok) {
-                    // Same order as the web-login path: the login result goes out first,
-                    // then the recovery reports its own outcome. Waiting for recovery to
-                    // build this message is what made a successful login look hung.
-                    await send(t("login.completed", backend));
-                    await announcePostLoginRecovery(backend, () => this.recoverBackendInstances(backend), send);
-                    return;
-                }
-                else if (detail === "cancelled") {
-                    // The cancel command's own reply already announced this — a second
-                    // message here was a duplicate.
-                    return;
-                }
-                else {
-                    text = t("login.failed", backend, detail);
-                }
-                await chat.adapter.sendText(chat.chatId, text, { threadId: chat.threadId }).catch(() => { });
-            },
-        }, this.logger);
-        // Claim the slot before the first await so two admins racing /login cannot
-        // both create windows; release on startup failure.
-        this.activeLogin = { session, backend, chat };
-        try {
-            await session.start();
-        }
-        catch (err) {
-            this.activeLogin = null;
-            this.loginWindow.release(claim);
-            const text = t("login.failed", backend, err.message);
-            return err.cleanupFailed ? `${text}\n${t("login.web_cleanup_failed", backend)}` : text;
-        }
-        if (session.state === "done") {
-            // Cancelled (user or shutdown) while starting: start() joined the
-            // teardown, so nothing is left. onDone already released the claim.
-            this.activeLogin = null;
-            this.loginWindow.release(claim);
-            return this.loginWindow.isClosed ? t("login.web_shutting_down") : t("login.cancelled", backend);
-        }
-        if (!this.loginWindow.isCurrent(claim)) {
-            await session.cancel("cancelled").catch(() => { });
-            this.activeLogin = null;
-            this.loginWindow.release(claim);
-            return t("login.web_shutting_down");
-        }
-        return t("login.started", backend);
+        return this.webLogin.start(backendArg, chat, opts);
     }
-    /** Fleet shutdown: end any web/relay login or install window and wait for its confirmed teardown. */
+    /** Fleet shutdown: end any web login or install window and wait for its confirmed teardown. */
     async shutdownLoginWindows() {
         // Close the lock FIRST: in-flight starts parked in a pre-check or
         // ensureSession observe !isCurrent when they resume and stop; no new
@@ -9956,19 +9776,9 @@ export class FleetManager {
         // a stopping fleet must not announce "login failed — fleet shutdown".
         await Promise.all([
             bounded(this.loginController?.shutdown(), "web-login"),
-            bounded(this.activeLogin?.session.cancel("cancelled"), "relay-login"),
             bounded(this.activeInstall?.session.cancel("cancelled"), "install"),
         ]);
     }
-    /** `/login code <text>` — paste admin-supplied text into the login window. */
-    async loginSubmitInput(text) {
-        if (this.loginController?.isActive())
-            return t("login.web_code_not_needed");
-        if (!this.activeLogin)
-            return t("login.no_session");
-        const ok = await this.activeLogin.session.submitInput(text);
-        return ok ? t("login.input_sent") : t("login.input_failed");
-    }
     /** `/login cancel` — abort the active session and remove its window. */
     async cancelLoginSession() {
         // `/login cancel` also stops an install that `/login` started — and the
@@ -9983,31 +9793,7 @@ export class FleetManager {
         }
         if (this.loginController?.isActive())
             return this.loginController.cancel();
-        if (!this.activeLogin)
-            return t("login.no_session");
-        const backend = this.activeLogin.backend;
-        await this.activeLogin.session.cancel();
-        return t("login.cancelled", backend);
-    }
-    /**
-     * The URL (+ code) is a live credential: whoever completes it binds THEIR
-     * account to this fleet's CLI. Telegram gets an HTML spoiler (same treatment
-     * as the dashboard token); other adapters get plain text with the warning.
-     */
-    async sendLoginSecret(chat, backend, url, code) {
-        const codeLine = code ? `\n${t("login.auth_code", code)}` : "";
-        try {
-            if (chat.adapter.type === "telegram") {
-                const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-                await chat.adapter.sendText(chat.chatId, `${esc(t("login.auth_hint", backend))}\n<tg-spoiler>${esc(url)}${esc(codeLine)}</tg-spoiler>`, { threadId: chat.threadId, format: "html" });
-            }
-            else {
-                await chat.adapter.sendText(chat.chatId, `${t("login.auth_hint", backend)}\n${url}${codeLine}`, { threadId: chat.threadId });
-            }
-        }
-        catch (err) {
-            this.logger.warn({ err: err.message, backend }, "Failed to deliver login URL");
-        }
+        return t("login.no_session");
     }
     /**
      * After a successful login: wake the paused instances of that backend AND
@@ -10125,20 +9911,6 @@ export class FleetManager {
         await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, text);
         return true;
     }
-    /** Kiro provider button → drive the CLI's arrow-key selector. */
-    async handleLoginMenuSelect(data, callbackAdapterId, receivingAdapter) {
-        const claimed = this.consumeNonceCallback(LOGIN_MENU_CALLBACK_PREFIX, /^login-menu:([0-9a-f]+):(\d)$/, data, callbackAdapterId, receivingAdapter);
-        if (claimed === null)
-            return false;
-        if (claimed === "consumed")
-            return true;
-        const { entry, action } = claimed;
-        const index = Number(action);
-        const label = this.activeLogin?.session.flow.menu?.options[index] ?? action;
-        const ok = await this.activeLogin?.session.selectMenuOption(index) ?? false;
-        await this.retireNonceButtons(entry, entry.messageId ?? data.messageId, ok ? t("login.provider_selected", label) : t("login.no_session"));
-        return true;
-    }
     // ── Remote CLI install (run by `/login` for a CLI that is missing) ──────────────────────────────────
     //
     // Same dedicated-window model as /login (and the same LoginSession state
@@ -10156,7 +9928,7 @@ export class FleetManager {
             return t("install.unsupported", backendArg);
         if (checkBinaryInstalled(info.binary))
             return t("install.already", backend, info.binary);
-        // Reserve the fleet-wide window before the first await (shared with web/relay
+        // Reserve the fleet-wide window before the first await (shared with web
         // login). Owned by this method until the session is published.
         const claim = this.loginWindow.tryClaim("install", backend);
         if (!claim)
@@ -10175,10 +9947,9 @@ export class FleetManager {
             this.loginWindow.release(claim);
             return t("install.failed", backend, err.message);
         }
-        // A synthetic login flow: success is decided by the installer's exit code
-        // (LoginSession treats a clean exit as success), never by pane text — and
-        // installer output that happens to contain a URL must not be forwarded as
-        // an auth hint, hence the no-op events below.
+        // A synthetic flow: success is decided by the installer's exit code
+        // (LoginSession treats a clean exit as success), never by pane text. The
+        // session only judges that verdict; it does not read the output for URLs or prompts.
         const flow = {
             backend,
             command: info.install,
@@ -10186,9 +9957,6 @@ export class FleetManager {
             timeoutMs: 10 * 60 * 1000,
         };
         const session = new LoginSession(flow, tmux, {
-            onMenu: () => { },
-            onAuthHint: () => { },
-            onNeedInput: () => { },
             onDone: async ({ ok, detail, cleanupFailed }) => {
                 this.activeInstall = null;
                 this.loginWindow.release(claim);
@@ -11145,7 +10913,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         for (const backend of SYSINFO_BACKEND_IDS) {
             if (!this.cliEnvNeedsRefresh(this.readCliEnv(backend)))
                 continue;
-            void this.probeBackendBounded(backend, { nonBlocking: true }).catch(err => {
+            void this.probeBackendBounded(backend).catch(err => {
                 this.logger.debug({ err, backend }, "Background CLI version refresh failed");
             });
         }
@@ -11168,19 +10936,26 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             return vendorFlight;
         if (!opts.refreshVendorCatalog && (vendorFlight || regularFlight))
             return vendorFlight ?? regularFlight;
-        const worker = opts.nonBlocking ? this.startCliEnvProbeWorker(backend, opts) : undefined;
-        const work = worker?.promise ?? this.probeBackend(backend, opts);
-        work.catch(() => { });
-        let timer;
-        const deadline = new Promise(resolve => {
-            timer = setTimeout(() => {
-                worker?.terminate();
-                this.logger.warn({ backend, deadlineMs: CLI_ENV_PROBE_DEADLINE_MS }, "CLI env live probe exceeded its deadline — serving the cached model list");
-                resolve(null);
-            }, CLI_ENV_PROBE_DEADLINE_MS);
-        });
-        const bounded = Promise.race([work, deadline]).finally(() => {
-            clearTimeout(timer);
+        if (this.shuttingDown)
+            return null;
+        const instanceDir = join(getAgendHome(), "cli-env");
+        const epoch = this.cliEnvProbeEpoch;
+        const input = {
+            mode: "env", backend, instanceDir,
+            config: { workingDirectory: "", instanceDir, instanceName: `probe-${backend}`, mcpServers: {} },
+            refreshVendorCatalog: opts.refreshVendorCatalog === true,
+        };
+        const bounded = this.runBackendProbeWorker(`global:${backend}`, input).then(probed => {
+            if (!probed || Array.isArray(probed) || this.shuttingDown || epoch !== this.cliEnvProbeEpoch)
+                return null;
+            try {
+                return this.persistCliEnvProbeResult(backend, probed);
+            }
+            catch (err) {
+                this.logger.warn({ backend, err }, "CLI env cache write failed");
+                return null;
+            }
+        }).finally(() => {
             const flights = opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes;
             if (flights.get(backend) === bounded)
                 flights.delete(backend);
@@ -11188,18 +10963,26 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         (opts.refreshVendorCatalog ? this.pendingVendorCliEnvProbes : this.pendingCliEnvProbes).set(backend, bounded);
         return bounded;
     }
-    startCliEnvProbeWorker(backend, opts) {
-        const workerData = {
-            backend,
-            instanceDir: join(getAgendHome(), "cli-env"),
-            config: {
-                workingDirectory: "",
-                instanceDir: join(getAgendHome(), "cli-env"),
-                instanceName: `probe-${backend}`,
-                mcpServers: {},
-            },
-            refreshVendorCatalog: opts.refreshVendorCatalog === true,
-        };
+    stopCliEnvProbes() {
+        this.cliEnvProbeEpoch++;
+        this.cliEnvProbePool.close();
+        this.pendingCliEnvProbes.clear();
+        this.pendingVendorCliEnvProbes.clear();
+        this.pendingInstanceModelProbes.clear();
+    }
+    runBackendProbeWorker(key, input) {
+        if (this.shuttingDown)
+            return Promise.resolve(null);
+        this.cliEnvProbePool.reopen();
+        return this.cliEnvProbePool.run(key, () => this.startCliEnvProbeWorker(input), {
+            deadlineMs: CLI_ENV_PROBE_DEADLINE_MS,
+            onTimeout: () => this.logger.warn({ backend: input.backend, deadlineMs: CLI_ENV_PROBE_DEADLINE_MS }, "CLI env live probe exceeded its deadline — serving the cached model list"),
+            onError: err => this.logger.warn({ backend: input.backend, err }, "CLI env worker failed to start or stop"),
+        });
+    }
+    startCliEnvProbeWorker(input) {
+        const { backend } = input;
+        const workerData = input;
         // `tsx src/cli.ts` needs its TS module resolver inside the separate isolate.
         // Published builds load the compiled worker and require no tsx dependency.
         const worker = import.meta.url.endsWith(".ts")
@@ -11207,35 +10990,31 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             : new Worker(new URL("./backend/cli-env-probe-worker.js", import.meta.url), { execArgv: [], workerData });
         let settled = false;
         let resolveProbe;
+        let markStopped;
+        const stopped = new Promise(resolve => { markStopped = resolve; });
         const promise = new Promise(resolve => { resolveProbe = resolve; });
         const finish = (value) => {
             if (settled)
                 return;
             settled = true;
             resolveProbe(value);
-            void worker.terminate().catch(err => {
+            // Admission stays occupied until terminate resolves or an exit is seen.
+            // A rejected termination does not prove the isolate has stopped.
+            try {
+                void worker.terminate().then(markStopped).catch(err => {
+                    this.logger.debug({ backend, err }, "CLI env worker termination failed");
+                });
+            }
+            catch (err) {
                 this.logger.debug({ backend, err }, "CLI env worker termination failed");
-            });
+            }
         };
         worker.once("message", (message) => {
             if (settled)
                 return;
-            if (!message.ok) {
+            if (!message.ok)
                 this.logger.warn({ backend, error: message.error }, "CLI env worker failed");
-                finish(null);
-            }
-            else if (!message.result) {
-                finish(null);
-            }
-            else {
-                try {
-                    finish(this.persistCliEnvProbeResult(backend, message.result));
-                }
-                catch (err) {
-                    this.logger.warn({ backend, err }, "CLI env cache write failed");
-                    finish(null);
-                }
-            }
+            finish(message.ok ? message.result ?? null : null);
         });
         worker.once("error", err => {
             if (settled)
@@ -11244,12 +11023,13 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             finish(null);
         });
         worker.once("exit", code => {
+            markStopped();
             if (settled)
                 return;
             this.logger.warn({ backend, code }, "CLI env worker exited without a result");
             finish(null);
         });
-        return { promise, terminate: () => { finish(null); } };
+        return { promise, stopped, terminate: () => { finish(null); } };
     }
     /**
      * Resolve the effective model for a fleet or ClassicBot instance, plus where it
@@ -11299,32 +11079,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const label = option.description ? `${option.label} — ${option.description}` : option.label;
         return option.id === currentModel ? `✓ ${label}` : label;
     }
-    /**
-     * Probe one backend's CLI env and cache it. Best-effort; never throws.
-     *
-     * `refreshVendorCatalog` is the "🔄 Refresh models" path only (#886): first
-     * ask the CLI to refetch its own catalog, for backends whose probe merely
-     * reads a file the CLI maintains. Every other caller leaves it off, so the
-     * startup and /model probes behave exactly as before. A failed vendor
-     * refresh fails the probe (null), which the menu reports instead of passing
-     * the old list off as fresh.
-     */
-    async probeBackend(backend, opts = {}) {
-        try {
-            const be = createBackend(backend, join(getAgendHome(), "cli-env"));
-            if (!be.probeCLIEnv)
-                return null;
-            if (opts.refreshVendorCatalog && be.refreshModelCatalog)
-                await be.refreshModelCatalog();
-            const probed = await be.probeCLIEnv({ workingDirectory: "", instanceDir: join(getAgendHome(), "cli-env"), instanceName: `probe-${backend}`, mcpServers: {} });
-            return this.persistCliEnvProbeResult(backend, probed);
-        }
-        catch (err) {
-            this.logger.warn({ err, backend }, "CLI env probe failed");
-            return null;
-        }
-    }
-    /** Preserve the existing cache merge rules for both in-process and worker probes. */
+    /** Preserve the existing cache merge rules for worker probes. */
     persistCliEnvProbeResult(backend, probed) {
         const env = { backend, probedAt: Date.now(), ...probed };
         // An empty result must never overwrite a catalog we already have. Some
@@ -11471,17 +11226,30 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         try {
             const inst = this.fleetConfig?.instances?.[instanceName];
             const instanceDir = this.getInstanceDir(instanceName);
-            const be = createBackend(backend, instanceDir);
-            if (!be.listModels)
-                return [];
-            return await be.listModels({
+            const config = structuredClone({
                 workingDirectory: inst?.working_directory ?? "",
                 instanceDir,
                 instanceName,
                 mcpServers: {},
                 model: inst?.model,
                 backendOptions: inst?.backend_options?.[backend] ?? this.fleetConfig?.defaults?.backend_options?.[backend],
-            }) ?? [];
+            });
+            // Include the config snapshot, so a changed provider/profile cannot join
+            // a still-running probe for the previous instance configuration.
+            const key = JSON.stringify({ backend, instanceDir, config });
+            const pending = this.pendingInstanceModelProbes.get(key);
+            if (pending)
+                return pending;
+            const epoch = this.cliEnvProbeEpoch;
+            const bounded = this.runBackendProbeWorker(`instance:${backend}:${instanceDir}`, {
+                mode: "models", backend, instanceDir, config,
+            }).then(result => Array.isArray(result) && !this.shuttingDown && epoch === this.cliEnvProbeEpoch ? result : [])
+                .finally(() => {
+                if (this.pendingInstanceModelProbes.get(key) === bounded)
+                    this.pendingInstanceModelProbes.delete(key);
+            });
+            this.pendingInstanceModelProbes.set(key, bounded);
+            return bounded;
         }
         catch {
             // listModels is documented never to throw, but a backend constructor can
@@ -11990,12 +11758,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** How this instance's backend applies an effort change. */
     effortStrategyFor(instanceName) {
         try {
-            const backend = createBackend(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
-            const strategy = backend.getEffortStrategy?.() ?? "unsupported";
-            // A backend claiming support but listing no levels is unusable either way.
-            return strategy !== "unsupported" && (backend.getEffortLevels?.() ?? []).length > 0
-                ? strategy
-                : "unsupported";
+            const { strategy, levels } = readEffortMetadata(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            return strategy !== "unsupported" && levels.length > 0 ? strategy : "unsupported";
         }
         catch {
             return "unsupported";
@@ -12004,10 +11768,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     /** Effort levels this instance's backend actually accepts (empty = unsupported). */
     effortLevelsFor(instanceName) {
         try {
-            const backend = createBackend(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
-            if ((backend.getEffortStrategy?.() ?? "unsupported") === "unsupported")
-                return [];
-            return backend.getEffortLevels?.() ?? [];
+            const { strategy, levels } = readEffortMetadata(this.backendNameForInstance(instanceName), this.getInstanceDir(instanceName));
+            return strategy === "unsupported" ? [] : levels;
         }
         catch {
             return [];
@@ -12147,21 +11909,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         try {
             if (!existsSync(logFile))
                 return undefined;
-            const lines = readFileSync(logFile, "utf-8").trim().split("\n");
-            // The triggering message is written before forwardToClassicInstance runs
-            // and is included separately under [User message]. Exclude that newest
-            // log entry so the agent does not receive the same message twice. A chat
-            // message may span physical lines, so remove from its timestamped entry
-            // header rather than blindly dropping only the final continuation line.
-            const entryHeader = /^\[\d{4}-\d{2}-\d{2}T[^\]]+\] <.*> /;
-            let currentEntryStart = lines.length - 1;
-            while (currentEntryStart > 0 && !entryHeader.test(lines[currentEntryStart])) {
-                currentEntryStart--;
-            }
-            lines.splice(currentEntryStart);
-            if (lines.length === 0 || maxLines <= 0)
-                return undefined;
-            return lines.slice(-maxLines).join("\n") || undefined;
+            // Only the end of today's log is needed (#1161): a day's log used to be read and split whole for every message.
+            return recentChatContext(logFile, maxLines, CHAT_LOG_TAIL_BYTES, CHAT_LOG_TAIL_MAX_BYTES);
         }
         catch {
             return undefined;
@@ -12417,6 +12166,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // make `agend stop` wait forever for its own queue.
         this.stormWindow.shutdown();
         this.spawnGate.shutdown();
+        this.memoryPressure?.stop();
+        this.stopCliEnvProbes();
         for (const pending of this.startupRetries.values())
             clearTimeout(pending.timer);
         this.startupRetries.clear();