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

package/dist/fleet-manager.d.ts

@@ -1,3 +1,4 @@
+import { type HumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsExecution } from "./settings-transaction.js";
 import type { LoginCodeOwner } from "./web-login.js";
 import { type ProfileTicket } from "./runtime-cpu-profile.js";
@@ -51,14 +52,20 @@ export declare function applyTaskListCap<T extends {
     omitted: number;
     hint: string;
 } | T[];
+import { type PublicPreviewForUi } from "./web-api.js";
+import { type LogAnswer, type LogQuery } from "./log-service.js";
 import { WebChatHistory } from "./web-chat-history.js";
+import { SeenUsers, type MentionNames, type MentionQuery } from "./web-mentions.js";
+import { WebPrefsStore } from "./web-prefs.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
 import { WebFileLedger } from "./web-upload.js";
+import { type CachedImage } from "./web-images.js";
 import { type RawConfigPatch } from "./settings-api.js";
 import { type AgentEndpointContext } from "./agent-endpoint.js";
 import { ClassicChannelManager } from "./classic-channel-manager.js";
 import { type ExplicitInstanceRemoval } from "./instance-removal.js";
 import type { InstanceState, InteractionSnapshot } from "./backend/types.js";
+import { type Daemon } from "./daemon.js";
 import { WakeCoordinator } from "./wake-coordinator.js";
 import { TargetQueueWorker } from "./target-queue-worker.js";
 import { resolveDeliveryWorkerMode } from "./types.js";
@@ -71,6 +78,7 @@ import { type PreviewAvailability } from "./web-preview.js";
 import { type ConnectionMetadata, type ConnectionBinding, type BindingProbe, type SecretApplyJob, type ProviderSecretApplyJob } from "./connection-secrets.js";
 import { type ProviderSecretStatus } from "./provider-secret-registry.js";
 import { ApplyJobStore, type ApplyJob, type ApplyTargetKind, type SelfRestartResult } from "./apply-job.js";
+import { type CarryResult } from "./backend/claude-carry.js";
 import { StormWindow } from "./storm-window.js";
 import { SpawnGate } from "./spawn-gate.js";
 import { BackendOutageTracker } from "./backend-outage.js";
@@ -98,6 +106,17 @@ export declare function selectLruEvictions(warm: string[], cap: number, opts: {
  * must match here, or a deleted instance's CLI is left running (#1305 P2-3).
  */
 export declare function isOrphanInstanceWindowName(name: string): boolean;
+/** restartSingleInstance's options. `carry` (#1753): a credential-profile switch; its outcome is written into `result`. */
+export interface RestartOpts {
+    freshStart?: boolean;
+    explicit?: boolean;
+    carry?: {
+        backend: string;
+        from: string | null;
+        to: string | null;
+        result?: CarryResult | null;
+    };
+}
 /**
  * Answer shape for `list_models`. `scope` reports where the LIST came from —
  * "instance" only when it was read through that instance's own backend config,
@@ -158,6 +177,8 @@ export declare const LOGIN_CALLBACK_PREFIX = "login:";
  * and hides exactly the newly released model the user opened `/model` to find.
  * The wait is announced before it starts, so it reads as progress, not a stall.
  */
+/** #1690: how long `/model` waits for the daemon's word on our own runtime switch (its dialog wait plus settling). */
+export declare const RUNTIME_SWITCH_RESULT_MS = 12000;
 export declare const CLI_ENV_PROBE_DEADLINE_MS = 16000;
 /**
  * How many CLIs may cold-start at once, from BOTH memory and cores.
@@ -200,7 +221,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private replyObligationTimer;
     private readonly activeDurableTargets;
     /** Live view of lifecycle.daemons — used throughout; not deprecated. */
-    get daemons(): Map<string, import("./daemon.js").Daemon>;
+    get daemons(): Map<string, Daemon>;
     fleetConfig: FleetConfig | null;
     private rawFleetConfig;
     private rawFleetDocument;
@@ -299,6 +320,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private webChannelEchoGuards;
     /** instanceName → restart currently executing; concurrent callers join it. */
     private restartsInFlight;
+    /**
+     * #1753: each in-flight restart's stop → start gap — the conversation carry it will run there (its own, or one a later
+     * caller joined with before the gap), and whether the gap has been reached.
+     */
+    private readonly restartGaps;
     /**
      * Delayed automatic retries for instances whose startup failed. Before this a
      * failed start was logged once and the instance stayed `stopped` until an
@@ -333,6 +359,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** In-flight /effort selections, same coordinator shape as pendingModelSelects. */
     private pendingEffortSelects;
     private pendingModelSelects;
+    /** #1806: in-flight /backend steps, keyed by nonce (see handleBackendSelection). */
+    private pendingBackendSelects;
     /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
     private pendingNonceButtons;
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
@@ -397,6 +425,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private connectionBindingInFlight;
     private collabInstances;
     private healthServer;
+    private healthServerDrain;
     /** #1306: the preview listener (health_port + 1 by default), and whether it is listening. */
     private previewListener;
     private previewListening;
@@ -409,6 +438,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private updateProgressEditRunning;
     private lastUpdateProgressText;
     private updateCompletionTipText;
+    /**
+     * #1660: an adopted update whose retire outcome is still owed. The
+     * completion summary was (or will be) posted; this watch appends the
+     * cleanup outcome to the same receipt instead of letting stage edits
+     * clobber it — and refuses a receipt that no longer matches (checklist 3/5).
+     */
+    private updateCleanupWatch;
     /** Injectable only to keep the chat→CLI reload hand-off deterministic in tests. */
     private fullRestartLauncher;
     private eventLogPruneTimer;
@@ -428,8 +464,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private memoryLogAt;
     private memoryDebugAt;
     private memoryLogLevel;
-    private memoryNoticeAt;
-    private memoryNoticeLevel;
+    /** #1685: the host_memory value the last status frame carried, so a change re-sends the frame. */
+    private memoryIndicatorShown;
     private mirrorBuffer;
     private mirrorTimer;
     private sseClients;
@@ -439,6 +475,15 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private webChatStore;
     /** Uploaded files and the files the dashboard may fetch back (uploads, reply attachments). */
     readonly webFiles: WebFileLedger;
+    /** #1770: per instance, its last web reply still copying its files — the next one is shown after it, in order. */
+    private readonly webReplyOrder;
+    /** #1770: an instance's web-files byte cap (a field, so a test can make it small). */
+    private webReplyMaxBytes;
+    /** #1682: the people seen on inbound messages (id → name), for the web chat's mention pills; bounded, in memory. */
+    readonly seenUsers: SeenUsers;
+    private webPrefsStore?;
+    /** #1665: the web preferences kept on the host (<home>/web-prefs.json), read on first use. */
+    get webPrefs(): WebPrefsStore;
     /**
      * Read from disk on every access rather than cached at startup: `agend
      * web-token rotate` runs in a separate process, and a cached copy would keep
@@ -519,12 +564,17 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         kind: string;
         correlationId: string;
         payload: Record<string, unknown>;
+        forwards?: readonly string[];
+        requestedKind?: string;
     }): {
         deliveryId: string;
         state: string;
         duplicate: boolean;
+        kind: string;
     };
     queryDurableDeliveryStatus(callerInstance: string, selector: DeliveryStatusSelector): DeliveryStatusPage;
+    /** #1641: why a target is not taking queued work right now, or null when nothing known holds it. */
+    private deliveryWaitingReason;
     getDaemonBootId(instanceName: string): string | undefined;
     markDurableResponseDelivered(sourceInstance: string, operationId: string): void;
     /** Called after a replacement Daemon object is installed in lifecycle.daemons. */
@@ -535,6 +585,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * notice when the owner is not working and nothing came back in time.
      */
     sweepReplyObligations(now?: Date): void;
+    private expireReplyObligations;
     private scheduleDeliveryOutboxPump;
     private runDeliveryOutboxPump;
     /**
@@ -551,6 +602,9 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private dispatchDurableDelivery;
     private waitForDurableLaneRelease;
     private spawnConcurrency;
+    /** #1685: "elevated" or "critical" while host memory pressure slows or holds new agents; otherwise null (an
+     *  unknown macOS reading — the advisory case — is unknown, so null too). */
+    private hostMemoryIndicator;
     /** Separate cooldown: changing measurements must not create new text-throttle keys. */
     private reportMemoryPressure;
     /** Wire the one fleet-wide storm into notification and recovery surfaces. */
@@ -586,6 +640,18 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     isPlannedRestart(): boolean;
     private finishStartup;
+    /**
+     * We are the post-update fleet: the update is over by definition. Clearing it here (rather than in the update
+     * command, which exits before the new fleet is up) is what keeps the quiet window from outliving the restart.
+     * #1660 exception: an update still owing its retire outcome keeps its receipt until the cleanup watch resolves it —
+     * deleting it here is what lost the warning. Terminal stages are still cleared unconditionally.
+     * #1735: and while the watch is armed it owns the marker — even if the outcome landed after the completion posted
+     * (a launchd kickstart or a detached restart returns at once, so it can land at any point of the boot): the watch
+     * appends it, then clears.
+     * #1737 review: and only the marker this boot adopted. One written since — a `/restart full` or a new `/update`
+     * landing while this boot's completion was still being edited — belongs to its writer and is left alone.
+     */
+    private clearSettledUpdateMarker;
     lastActivityMs(name: string): number;
     /** Capture the current daemon and delivery owner for a background context read. */
     getPaneContextSource(name: string): import("./pane-context-cache.js").PaneContextSource | null;
@@ -751,6 +817,18 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     getActiveBackendIds(): ReadonlySet<string>;
     isClassicInstance(name: string): boolean;
     /** #1523 N2: a ClassicBot room's own summary for its Details page (classicBot.yaml), or null. */
+    /** #1218: the Log tab's on-demand service — made on first use; with `web.log_tab` off it answers off and does nothing. */
+    private logService;
+    private get log();
+    /** #1218: GET /ui/steps — an instance's steps, read on demand (null: no such instance). */
+    logSteps(name: string, q: LogQuery): Promise<LogAnswer | null>;
+    /**
+     * #1218: where an instance's steps are read from, resolved only when its Log asks: the transcript its daemon follows
+     * now; for claude-code, also the path its statusline last named (so a stopped instance's Log still shows its last
+     * work). kiro: fleet events with the reason its history is not read (kiro-log-gate.ts); other backends have no
+     * transcript AgEnD can read.
+     */
+    private logSource;
     classicRoomFor(name: string): {
         name: string;
         channel_id: string;
@@ -826,11 +904,39 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * already in flight may still land late — the contract permits that.
      */
     sendClassicWebEcho(instance: string, text: string): Promise<number>;
-    reserveWebChannelEcho(instanceName: string, sendEcho: () => Promise<unknown>): (accepted: boolean) => void;
+    /**
+     * #1666: a delivered web chat message starts the same cancel/progress lifecycle in the instance's topic as a platform
+     * inbound (afterUserInboundDelivered): the same bubble, ticker and retire rules. Not its ✅ tracking — the web message
+     * id is no platform message, and the echo is the fleet's own post. The web send calls this on the echo's lane.
+     */
+    startWebChatProgress(instanceName: string): Promise<void>;
+    /**
+     * `copy: false` (#1666/#1668): an entry that is not a copy of a message — the web send's Cancel/progress bubble. It
+     * keeps its place in the order, but the lane's copy rules do not apply to it: its 5 s budget starts when its turn
+     * starts (waiting behind a slow echo is not its delay), its own timeout only releases the lane (the copies queued
+     * behind it are not "behind an ambiguous copy"), and another entry's timeout never drops it. A copy reserved while
+     * any non-copy is still open starts its own budget when the last of them finishes: a slow bubble is no copy's delay,
+     * however far back the copy is. And a timeout only ever drops copies reserved AFTER the entry that timed out — with
+     * deferred budgets, deadlines no longer grow with the order, so that rule is stated, not implied (#1668 r3).
+     */
+    reserveWebChannelEcho(instanceName: string, sendEcho: () => Promise<unknown>, opts?: {
+        copy?: boolean;
+    }): (accepted: boolean) => void;
     /** Whether this target already has an ordinary non-user delivery in its FIFO. */
     hasPendingIdleGatedDelivery(instanceName: string): boolean;
     /** The running launch's own steer capability (#1405); undefined for a backend without one, or no running Daemon. */
     instanceLaunchSupportsSteer(instanceName: string): boolean | undefined;
+    private humanReceiptDaemons;
+    /** Cached FM + lifecycle + Daemon + tmux owner; unknown ownership grants nothing. */
+    private humanReceiptOwner;
+    private listenForHumanReceipt;
+    /** Evidence-only admission. Bots/system/agent payloads have no trusted origin. */
+    private humanReceiptPayload;
+    /** Bind at the actual IPC send, after all wake/reconnect waits. No human retry lane. */
+    private bindHumanReceiptPayload;
+    deliverHumanToInstance(instanceName: string, payload: Record<string, unknown>, origin: HumanOrigin | undefined, originalBody: string, options?: DeliveryOptions): Promise<boolean | void>;
+    /** Synchronous steer/btw handoff, using the same evidence and owner binding. */
+    sendHumanControl(instanceName: string, payload: Record<string, unknown>, origin: HumanOrigin | undefined, originalBody: string): boolean;
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     deliverToInstance(instanceName: string, payload: Record<string, unknown>, options?: DeliveryOptions): Promise<boolean | void>;
     /**
@@ -877,6 +983,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * the check and the act, so the channel's instance cannot be rebound to another bot in between.
      */
     private dispatchSlash;
+    private dispatchSlashCore;
     /**
      * The door every Discord slash command goes through (src/slash-authz.ts has the rule and the reasoning): the scope
      * it lets the command into, or the reply that refuses it. Synchronous, so the dispatch acts on what it judged.
@@ -1006,6 +1113,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * from restarting the same process twice; backendNameOf defines ownership.
      */
     private configuredBackendInstanceNames;
+    /** #1624: migration cannot infer ownership from the running daemon roster.
+     * Stopped/paused ClassicBot entries count too; their workspace is exactly
+     * the one startClassicInstance builds, not this FleetManager's dataDir.
+     */
+    kiroPeerWorkingDirectories(name: string): string[];
     /**
      * Probe the same executable set exposed by the web backend catalog.
      *
@@ -1058,12 +1170,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Last-resort completion after RestartProgress could not deliver to its
      * adopted target. It stays bounded and never wakes a not-ready gateway. */
     private sendFleetStartCompletionFallback;
-    stopInstance(name: string, transition?: TransitionHandle): Promise<void>;
+    stopInstance(name: string, transition?: TransitionHandle): Promise<{
+        backgroundWorkEnded: boolean;
+    }>;
     /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
-    restartSingleInstance(name: string, opts?: {
-        freshStart?: boolean;
-        explicit?: boolean;
-    }): Promise<void>;
+    restartSingleInstance(name: string, opts?: RestartOpts): Promise<void>;
     isInstanceRestarting(name: string): boolean;
     /** InstanceLifecycleContext: an explicit wake joins the restart in flight. */
     restartInFlight(name: string): Promise<void> | undefined;
@@ -1084,6 +1195,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * One-shot: the daemon deletes it on startup.
      */
     private writeFreshStartMarker;
+    /**
+     * #1753: a credential-profile switch, between the old CLI's stop and the new one's start. Where the backend can take
+     * the conversation along (claude-code), copy it into the new profile and make it the one `--continue` picks; when that
+     * cannot be done, or the backend cannot, start fresh as before. Null when nothing was tried.
+     */
+    private switchConversation;
     /** Load .env file from data dir into process.env */
     private loadEnvFile;
     /** Initialize auth before any adapter can answer /dashboard. */
@@ -1099,11 +1216,31 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         ttlMinutes: number;
     } | null;
     private tunnelPurposeLane;
+    private previewTunnel;
     private publicWebLink;
+    /** #1723: the public link's preview tunnel — a manager and lease of its own, never the fleet's one tunnel lane. */
+    private getPreviewTunnel;
     private getTunnelLane;
     private publicOwnerCurrent;
     /** Exact owning General. No primary-adapter or name fallback participates in authorization. */
     private dashboardOwner;
+    /**
+     * #1742: the General a fleet admin's DM speaks for (`/start web`): the same owner `/web` in that General would make
+     * — this bot's configured group and its one General topic. No address to match in a DM, so it must be unambiguous:
+     * no General, or more than one on this bot and group, and there is no owner (nothing is guessed).
+     */
+    private dmDashboardOwner;
+    /**
+     * #1742: a fleet admin whose Telegram `/web` could not reach them privately may next open the bot's DM and press
+     * Telegram's START, which sends a bare `/start` — read as `/start web` (the DM menu) for 10 minutes, once, for that
+     * admin on that bot. Monotonic: a wall-clock jump neither opens nor shuts it.
+     */
+    private readonly tgWebStartWindows;
+    private openTgWebStartWindow;
+    /** Uses the window up: true when it was open. */
+    private takeTgWebStartWindow;
+    /** #1742: `/start web` from a fleet admin: the /web menu right here in the DM, for the General this bot serves. */
+    private startWebInDm;
     private getPublicWebLink;
     getPublicWebStatus(): {
         state: string;
@@ -1117,6 +1254,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     }, current: () => boolean): Promise<void>;
     /** Telegram's typed command enters through the same strict owner and nonce path as Discord. */
     dashboardMenu(msg: InboundMessage): Promise<void>;
+    /**
+     * #1686: build the Telegram deep-link that opens a DM with this bot pre-seeded with `/start web`.
+     * Returns null when no botUsername is known or the username fails Telegram's format validation.
+     */
+    private tgStartWebUrl;
     private sendLocalDashboard;
     /**
      * #1586: the sign-in code once more, as a message of its own, so a phone can copy it by itself: Telegram's monospace
@@ -1136,6 +1278,10 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Why the DM did not go, for the log only (Discord 50007 = the user does not accept DMs from this server's members). */
     private logDashboardDmFailure;
     /** False when the menu was not shown (the caller still owes the user an answer). */
+    /**
+     * `dmChatId` (#1742): show it in the owner's own private chat with the bot instead of the General — the owner, its
+     * gates and the code's route are the same; only where the menu sits (and its clicks are good) changes.
+     */
     private showDashboardMenu;
     private handleDashboardCallback;
     /** `/dashboard revoke`: sign out every browser and withdraw any unused code. */
@@ -1188,6 +1334,36 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private reportFullRestartFailure;
     failUpdateProgress(message: string): void;
     /** The old fleet edits CLI install stages; the new fleet adopts the same message below. */
+    /**
+     * #1660: arm the post-completion cleanup watch and make sure its monitor
+     * actually runs. The new fleet adopts the receipt at boot but nothing else
+     * starts this timer on that path (Prism a) — without this, the owed
+     * outcome would sit in the marker unwatched. READY never waits for it.
+     */
+    /**
+     * #1735: what the completion of an adopted update does about its retire outcome, read from the marker as it is now.
+     * Already landed with a warning (a detached restart returns before this fleet boots, so the updater retires first)
+     * → render it in the completion. Still owed (`cleanup: "pending"` — a service restart waits for READY, which comes
+     * after the completion) → watch for it. Anything else (no retire on this update, done silently, another receipt)
+     * → nothing.
+     */
+    /**
+     * #1716: background work this restart/update ended, scoped to the operation
+     * so an older stop never reports (`sinceAt` null = plain boot, report
+     * nothing). A method — not a module function — because the #1737
+     * extracted-completion harness runs this region verbatim with only
+     * `this`-methods plus a fixed context.
+     */
+    private collectBackgroundWorkEndedNames;
+    private updateCleanupAtCompletion;
+    private armCleanupWatch;
+    /**
+     * #1660: append a recorded cleanup outcome to the adopted update message,
+     * then release the receipt — but only if this receipt still owns the
+     * marker. The await yields, so a newer receipt (e.g. a full-restart that
+     * landed mid-edit) must not be cleared or disturbed (Prism b).
+     */
+    private appendCleanupWarning;
     private startUpdateProgressMonitor;
     /** Start all instances from fleet config */
     startAll(configPath: string): Promise<void>;
@@ -1392,6 +1568,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private resolveInboundTarget;
     private handleInboundMessage;
+    /**
+     * #1752: the bot that speaks back about an inbound message — in a fleet topic the owning instance's adapter, never
+     * the sibling that happened to win the dedup race; elsewhere (ClassicBot rooms, no routed instance) the receiver.
+     */
+    private inboundNoticeAdapter;
+    private handleInboundMessageCore;
     /** Handle outbound tool calls from a daemon instance */
     /** Warn (but don't block) when rate limits are high. 30-min debounce per instance. */
     private rateLimitWarnedAt;
@@ -1433,7 +1615,14 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private isWebOnlyFleet;
     /** On a fleet with no chat platform, the dashboard is where an instance-health prompt is posted (#1307 item 6). */
     private webOnlyPromptPlace;
+    /** Resolves when the reply is in the web chat (#1770: after its files are copied); the caller need not wait. */
     private afterReplyRouted;
+    /**
+     * #1770: a reply's files as the web chat shows them. Each is copied into the instance's web-files/ and served from
+     * the copy. One the copy refuses (a symlink, not a regular file, over 50 MB, a state file, missing) is not shown;
+     * one that could not be copied (I/O) is served from the agent's own path, as before — until the fleet restarts.
+     */
+    private webReplyAttachments;
     private handleScheduleTrigger;
     /**
      * The adapter that can actually post into a chat, found by its group.
@@ -1675,6 +1864,46 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Keyed `<connection>\0<server id>`. */
     private guildEmojiCache;
     private guildEmojiFetches;
+    private webImageCaches;
+    private webImageCache;
+    /**
+     * instance → the connection that is its own bot: configured now (a connection removed from fleet.yaml is nobody's,
+     * whatever an instance still names — #1635 review), not the primary, and answering for it alone.
+     */
+    private ownBots;
+    /**
+     * The bot a connection is now: its running adapter and that bot's own user id. Everything cached for an own bot is
+     * keyed by both, so a bot put in its place (a token replaced under the same connection id) never shows the old one's
+     * face or colour, and the old one's late answers land under the old key (#1635 review). null while it has no id.
+     */
+    private botOwner;
+    /** Still the same bot behind `connection` (after an await): the same adapter object and the same bot id. */
+    private botStillOwns;
+    /** keyed `<connection>\0<bot id>\0<channel>`: the bot's colour there, refreshed at most daily (monotonic), one read at a time. */
+    private webAccents;
+    private webAccentReads;
+    private webAccent;
+    /** The cache key of an own bot's avatar, and its loader (which refuses an answer from a bot no longer there). */
+    private botAvatarSource;
+    /** One instance's avatar and ring for the status frame. Synchronous: what is cached now; fetches run behind. */
+    private webIdentityImage;
+    /** GET /ui/img/bot|avatar/<key>: what is cached, never a fetch. Only an own-bot connection, or a known instance's upload. */
+    webImage(kind: "bot" | "avatar", key: string): CachedImage | null;
+    /**
+     * #1682 GET /ui/mentions: names for the mention ids a page found in what it rendered — never a Discord request; in order:
+     * the fleet's bots (an instance's own bot is that instance's label: fleet.yaml, and the View profiles read from
+     * profiles.db, as the status frame does), the people seen on inbound messages, and the Discord adapters' caches
+     * (members, users, roles, channels).
+     */
+    webMentionNames(query: MentionQuery): MentionNames;
+    /** GET /ui/emojis: the custom emoji of every server the fleet's Discord bots are in (the Settings picker's cache). */
+    webEmojiList(): Promise<Array<{
+        id: string;
+        name: string;
+        animated: boolean;
+    }>>;
+    /** GET /ui/img/emoji/<id>: only an emoji of those servers; fetched once from Discord's CDN, then from the host cache. */
+    webEmoji(id: string): Promise<CachedImage | null>;
     /**
      * What `instanceName` may pick as its persona emoji (the `list_emojis`
      * tool): its current status set with where each value comes from, the
@@ -1977,6 +2206,19 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     orgChart(): OrgChart;
     private cacheService;
+    /**
+     * #1699: the credential profile an instance's CLI signs in with on `backend` — fleet.yaml's (with its defaults), or a
+     * ClassicBot room's launched or would-be login when the room runs that backend. Null: the backend's default login
+     * (also for a backend that has no profiles, where the option is ignored).
+     */
+    credentialProfileOf(name: string, backend: string): string | null;
+    /**
+     * #1699: the claude config dir an instance's CLI uses — its credential profile's, else exactly as before
+     * (CLAUDE_CONFIG_DIR or ~/.claude).
+     */
+    claudeConfigDirOf(name: string): string;
+    /** The instances the cache analysis reads: fleet.yaml's, then the ClassicBot rooms (their workspace under the AgEnD home, their own backend). */
+    private cacheInstances;
     /**
      * #1468: the prompt-cache expiry analysis for the web, per instance, over `window`. Read from each instance's
      * ledger as it is now; the first request starts the bounded, persisted catch-up over the transcripts
@@ -2049,6 +2291,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * synchronous; they never probe the pane.
      */
     private clearTargetFence;
+    /** #1806: the web's /backend confirmations — one per question, used once, for the arguments and backend asked about. */
+    private readonly webBackendTokens;
     /** #1269: the web's /clear confirmations — one token per question, used once, for the instance as it was asked about. */
     private readonly webClearTokens;
     /** #1269: an instance's chat command from the web chat (web-commands.ts); `publicLink`: a gateway request. */
@@ -2112,7 +2356,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * Backends with no remote login flow (opencode logs in from a terminal) get
      * no button — the alert's own wording already tells them what to run.
      */
-    offerBackendLogin(targetInstance: string, backend: string): Promise<void>;
+    offerBackendLogin(targetInstance: string, backend: string, profile?: string): Promise<void>;
     /** Consume a General assist button exactly once. */
     private handleInteractivePromptAssist;
     /** Send a "🛑 Cancel" button to the instance's topic/channel after delivery. */
@@ -2345,6 +2589,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         skipAuthCheck?: boolean;
         tokenPresent?: boolean;
         tunnel?: boolean;
+        profile?: string;
     }): Promise<string | null>;
     /** Which way a `/login` went (#1131) — so the event log shows what users actually need. */
     private recordLoginFlow;
@@ -2388,6 +2633,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         chatId: string;
         threadId?: string;
         userId?: string;
+    }, signIn?: {
+        profile?: string;
     }): Promise<string>;
     /** Whether this backend's CLI is on the fleet's PATH (what `/login` installs when it is not). */
     isCliInstalled(backend: string): boolean;
@@ -2504,6 +2751,20 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Forward a message to a classic channel instance with chat log context */
     private forwardToClassicInstance;
     /** Paste raw text directly to a classic instance's CLI (no [user:] wrapping) */
+    /** #1690: our own runtime switches awaiting the daemon's outcome, by id. */
+    private readonly runtimeSwitchWaiters;
+    /**
+     * #1690: type `/model <model>` and wait for what it came to: the daemon answers claude's "Switch model?" for us (Yes
+     * when it names this model, No otherwise) or sees claude's own result. Null when it could not be sent; a timeout is
+     * "not confirmed".
+     */
+    private runRuntimeModelSwitch;
+    /**
+     * #1690: the names claude-code is known to accept, for checking `/model <name>` BEFORE it is typed — claude itself
+     * accepts any string ("Set model to opsu"), and its "Switch model?" then names the typo. Static aliases (with [1m]),
+     * the cached account catalog, the configured model; without a cached catalog, any `claude-…` id too (cannot check).
+     */
+    private claudeModelKnown;
     private pasteRawToClassicInstance;
     /** Resolve the backend name configured for an instance (fleet or classic). */
     private backendNameForInstance;
@@ -2669,6 +2930,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     applyEffort(instanceName: string, requested: string): Promise<string>;
     applyModel(instanceName: string, model: string): Promise<string>;
+    /** Save an instance's model (fleet.yaml, or its ClassicBot channel). False when neither holds it. */
+    private persistInstanceModel;
     /**
      * The trailing "Current effort: …" line for a /model reply.
      *
@@ -2677,6 +2940,72 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * a switch saves the round trip of asking. Empty when the backend has none.
      */
     private effortSuffix;
+    /** The steps' view of this fleet (backend-command.ts). `live`: a missing or stale model list may be probed (not on the web). */
+    private backendCommandDeps;
+    /**
+     * `/effort`'s levels for a backend this instance may move to, for the model that will run there (codex's levels are
+     * per model; null: its configured default). Empty: it has no effort setting. A file read, never a CLI.
+     */
+    backendEffortLevels(instanceName: string, backend: string, model?: string | null): string[];
+    /**
+     * #1808: whether a backend takes this model name — the one rule for /backend and update_instance_config's switch.
+     * The name must be one its launch line can carry (modelNameCarried); then its offered list (the cached CLI env), and
+     * claude-code's known names (without this instance's configured model, which belongs to the backend being left).
+     * With no list known, the backend's usual name pattern decides.
+     */
+    backendModelVerdict(instanceName: string, backend: string, model: string, 
+    /** The provider the backend will run on (default: this instance's own, else the fleet's). */
+    opts?: {
+        provider: string | null;
+    }): {
+        ok: true;
+    } | {
+        ok: false;
+        choices: string[];
+    };
+    /**
+     * #1807 review r2: the model codex's next launch of this instance runs. Every launch's writeConfig copies the SHARED
+     * config.toml into the instance's codex home first, so that source decides — not the home's copy from an earlier
+     * launch. Read-only; a model chosen here (`-c model=…`) outranks it; a project file that could change it, unproven.
+     */
+    private prospectiveCodexModel;
+    /** #1811: whether a launch of `backend` here would pass a level: the same gate its builder applies. */
+    private launchEffortGate;
+    /** Installed the way the launch finds a CLI (resolveBinary): on PATH or in a known install directory. */
+    private backendInstalledHere;
+    /** The models `/model` would offer on a backend: the cached CLI env, else (live) a bounded probe. Never throws. */
+    private backendModelOptions;
+    /**
+     * #1806 review: the instance a `/backend` was asked about is still this config entry — not one deleted and created
+     * again under the same name, or replaced by a Settings edit (both put a new object there), stopped or not.
+     */
+    private backendTargetIs;
+    /** `/backend` is for fleet.yaml instances: update_instance_config does not manage a ClassicBot agent. */
+    private backendCommandRefusal;
+    /**
+     * Apply a confirmed `/backend`: judged again first (a menu lives a minute — the backend may have moved, a CLI been
+     * removed), then update_instance_config's write: backend, model and effort at once, refused and rolled back whole
+     * (its credential-profile login gate included), then one fresh relaunch of a running instance.
+     */
+    applyBackendSwitch(instanceName: string, args: readonly string[], from: string, stillCurrent: () => boolean): Promise<string>;
+    /** A step's buttons: index callbacks (a model id can be longer than Telegram's 64-byte callback data allows). */
+    private backendStepButtons;
+    /**
+     * Show a `/backend` step (a choice, or the confirmation) where the command was given: Discord edits its interaction
+     * reply; Telegram retires the previous step's keyboard and posts the next. One pending entry per step, under a fresh
+     * nonce: a click on an older step finds nothing.
+     */
+    private presentBackendStep;
+    /** Close a `/backend` menu with a last word: its buttons go (Telegram edits them away), the text stays. Returns where it was said. */
+    private endBackendMenu;
+    /** Start `/backend` for a fleet instance from Discord or Telegram; the caller has checked the channel admin. */
+    private beginBackendCommand;
+    /** `/backend` slash handler: channel admin, as `/model`. Options or typed text give the direct form. */
+    private handleBackendSlash;
+    /** Telegram `/backend` in a fleet topic (topic-commands) or a ClassicBot chat; the caller has checked the admin. */
+    runBackendCommand(instanceName: string, text: string, userId: string, channelId: string, adapter: ChannelAdapter, chatId: string, threadId?: string, adapterId?: string): Promise<void>;
+    /** Consume a `/backend` click: the next step, or on the confirmation the switch itself. True for every backend-select id. */
+    private handleBackendSelection;
     /** Read recent chat log for agent context */
     private getRecentChatLog;
     /**
@@ -2692,6 +3021,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private getMissingBackendWarning;
     /** Handle Discord's required static slash choice, warning before a likely startup failure. */
     private handleClassicStartSlash;
+    private handleClassicStartSlashCore;
     /** Present platform-native backend choices, then start on selection or timeout. */
     private beginClassicBackendSelection;
     /** Consume a selection callback. Returns true for all ClassicBot callback IDs, including stale ones. */
@@ -3003,6 +3333,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     previewForUi(hostHeader: string | undefined, secure: boolean): PreviewAvailability & {
         boot: string | null;
     };
+    /**
+     * #1723: for one page of the public link (exposure `exposureId`, at `dashboardOrigin`): its own preview tunnel's
+     * origin once up, "starting" until then, why it failed if it did — or a configured web.preview_origin, used instead.
+     */
+    publicPreviewForUi(exposureId: string, dashboardOrigin: string): PublicPreviewForUi;
     getUiStatus(): unknown;
     private getUiStatusSync;
 }