@songsid/agend 2.2.0-beta.2 → 2.2.0-beta.20

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,7 +52,13 @@ 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 { type WebAccount } from "./web-profile.js";
+import type { WebPerson as WebPersonView } from "./web-api.js";
 import { ReplyButtonsController } from "./reply-buttons-controller.js";
 import { WebFileLedger } from "./web-upload.js";
 import { type CachedImage } from "./web-images.js";
@@ -60,6 +67,7 @@ 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";
@@ -72,6 +80,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";
@@ -99,6 +108,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,
@@ -159,6 +179,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.
@@ -201,7 +223,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;
@@ -300,6 +322,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
@@ -334,6 +361,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). */
@@ -398,6 +427,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,7 +439,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private updateProgressTimer;
     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;
@@ -429,8 +465,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;
@@ -440,6 +476,43 @@ 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. */
+    /**
+     * #1827: a web person as agents and chats see them. Signed in as an account (a sign-in code DMed to it): that
+     * account's user id — still `via web`, and only for recognition — and the name they chose, else their account's name
+     * at sign-in (made safe). Otherwise (an `agend web` session): "web-user", as before, under a name the operator may set.
+     * Names are checked again now: one an instance or bot has taken since reads as the next choice down.
+     */
+    webPerson(owner?: WebAccount): WebPersonView;
+    /** #1827: set (null: clear — back to their account's name) a web person's own name; validated in full. */
+    setWebPersonName(owner: WebAccount | undefined, raw: unknown): {
+        ok: true;
+        person: WebPersonView;
+    } | {
+        ok: false;
+        status: number;
+        error: string;
+    };
+    /** #1827 (auth-api): a sign-in as this account — its display name then is the web name it starts with. */
+    noteWebSignIn(account: {
+        adapterId: string;
+        userId: string;
+        username?: string;
+    }): void;
+    /**
+     * #1827: a name that belongs to something here — an instance (or ClassicBot room), its display name, a bot. On the web
+     * send path: it never throws (a lookup that fails reserves nothing; the name was checked in full when it was set).
+     */
+    private webNameReserved;
+    private webNameTaken;
+    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
@@ -501,6 +574,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     replyButtons(): ReplyButtonsController | null;
     private replyButtonsStore;
+    /**
+     * #1823: a closed poll's results go to its instance through the delivery outbox, as a system notice keyed by the
+     * poll: durable (held until the instance can take it) and admitted once, however often this is asked. Addressed to
+     * the poll's chat, so the instance's answer (the right option, the scores) goes there.
+     */
+    private admitPollResults;
     /**
      * #1266: who may answer a reply's buttons on a platform — whoever may message that instance there: in a ClassicBot
      * room anyone there (as a typed message), elsewhere someone the sending connection lets speak (#754/#1148), never a
@@ -520,10 +599,13 @@ 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. */
@@ -538,6 +620,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;
     /**
@@ -554,6 +637,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. */
@@ -589,6 +675,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;
@@ -754,6 +852,21 @@ 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();
+    /** Board 003648ac: a web /compact followed to its end, from the transcript the Log reads (none: nothing to follow). */
+    private compactWatchService;
+    private get compactWatch();
+    /** #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;
@@ -828,12 +941,41 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * or a rebound adapter is never posted through a stale route. A copy
      * 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;
+    /** `sender` (#1827): the web person's name, as the room log records them ("web-user" when none). */
+    sendClassicWebEcho(instance: string, text: string, sender?: string): Promise<number>;
+    /**
+     * #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>;
     /**
@@ -853,6 +995,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     isFleetAdmin(userId: string, adapterId?: string): boolean;
     /** Whether this adapter has any fleet admin at all (an empty allowlist means the admin commands are off). */
     hasFleetAdmins(adapterId?: string): boolean;
+    /**
+     * Where this adapter's fleet-admin list is in fleet.yaml, as the operator wrote it, for the "disabled" replies:
+     * `channel.access.allowed_users` (the single-channel form), else the `channels:` entry — by its `id:`, or its
+     * `type:` when it has none. Read from the raw file: loading turns `channel:` into `channels` and fills in ids.
+     */
+    adminListKey(adapterId?: string): string;
     /**
      * 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
@@ -880,6 +1028,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.
@@ -1066,12 +1215,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;
@@ -1092,6 +1240,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. */
@@ -1107,11 +1261,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;
@@ -1125,6 +1299,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
@@ -1144,6 +1323,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. */
@@ -1196,6 +1379,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>;
@@ -1400,6 +1613,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;
@@ -1441,7 +1660,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.
@@ -1603,6 +1829,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     saveFleetConfig(explicitPatches?: RawConfigPatch[]): void;
     /** Why the config written to `candidate` must not replace fleet.yaml, or null: it does not load, or it adds errors. */
     private savedFleetConfigProblem;
+    /**
+     * #1874 follow-up: the validator's warnings, once per start, in daemon.log — a setting fleet.yaml has that AgEnD
+     * ignores (e.g. `web.access`) is otherwise silent unless someone runs `agend validate`.
+     */
+    private logConfigWarningsAtStartup;
     /** One-time upgrade migration; invalid YAML is never rewritten. */
     private slimFleetConfigAtStartup;
     private writeFleetConfigBackup;
@@ -1686,9 +1917,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     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.
+     * The bots instances and ClassicBot rooms speak through, by connections configured now (a connection removed from
+     * fleet.yaml is nobody's, whatever an instance still names — #1635 review). `own`: instance → its own bot (answering
+     * for it alone; the primary too, when it serves one instance only). `speaking` (#1867): instance → the bot it speaks through — its own, a shared one,
+     * or, with none configured for it, the primary.
      */
+    private webBots;
+    /** instance → the connection that is its own bot (see webBots). */
     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
@@ -1704,10 +1939,23 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     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. */
+    /**
+     * One instance's avatar and ring for the status frame. Synchronous: what is cached now; fetches run behind. The bot
+     * is its own, else the one it speaks through (#1867) — one cache entry per bot, so a shared bot is fetched once.
+     */
     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. */
+    /**
+     * GET /ui/img/bot|avatar/<key>: what is cached, never a fetch. Only a connection some instance or room speaks
+     * through (#1867), 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;
@@ -2018,6 +2266,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
@@ -2057,10 +2318,26 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * The caller has passed the /ui gate (session, same origin, CSRF). Here: the prompt must be one offered
      * on the dashboard, about the instance the page named, and the action one of its own buttons.
      */
-    /** #1266: a click on a reply's button in the web chat (the /ui gate is passed: a session, or the public link). */
-    clickWebReplyButton(instance: string, id: string, index: number): Promise<{
+    /** #1823: close_poll — `instance` closes one of its own polls before the deadline. */
+    closePollEarly(instance: string, id: string): Promise<{
+        ok: true;
+        voted: number;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /**
+     * #1266: a click on a reply's button in the web chat (the /ui gate is passed: a session, or the public link). On a
+     * poll (#1823) it is `voter`'s vote: the page's session.
+     */
+    clickWebReplyButton(instance: string, id: string, index: number, voter?: {
+        key: string;
+        userId: string;
+        name: string;
+    }): Promise<{
         status: 200 | 400 | 403 | 409;
         error?: string;
+        options?: number[];
     }>;
     clickWebPrompt(instance: string, nonce: string, action: string): Promise<{
         status: 200 | 400 | 403 | 409;
@@ -2090,6 +2367,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. */
@@ -2100,6 +2379,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         confirm?: string;
     }, opts: {
         publicLink: boolean;
+        person?: Pick<WebPersonView, "userId" | "name">;
     }): Promise<WebCommandResult>;
     /** Consume `/clear` Confirm/Cancel exactly once; only Confirm reaches IPC. */
     private handleClearConfirmation;
@@ -2153,7 +2433,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. */
@@ -2386,6 +2666,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;
@@ -2429,6 +2710,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;
@@ -2439,9 +2722,9 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * The absolute path a fresh login shell resolves `binary` to, or null. Only
      * a real executable file counts: `command -v` also answers with an alias
      * definition or a function name, neither of which a spawn could run.
+     * Async (runOnLoginShell): a login file that backgrounds a process holding the shell's output once froze the fleet loop here.
      */
     private locateBinaryOnLoginShell;
-    private locateBinaryOnLoginShellSync;
     /**
      * #1092: the binary in one of the directories its own installer installs to,
      * when no login shell can see it (the installer recorded its PATH in an
@@ -2545,6 +2828,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;
@@ -2687,6 +2984,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     effortStrategyFor(instanceName: string): "runtime" | "restart" | "unsupported";
     /** Effort levels this instance's backend actually accepts (empty = unsupported). */
     effortLevelsFor(instanceName: string): string[];
+    /** The instance's backend's effort metadata; agy's levels are its model's (#1825), the one the instance runs. */
+    private instanceEffortMetadata;
     /** Configured effort for an instance: per-instance, else fleet default, else none. */
     resolveInstanceEffort(instanceName: string): {
         effort: string | null;
@@ -2710,6 +3009,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.
      *
@@ -2718,6 +3019,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;
     /**
@@ -2733,6 +3100,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. */
@@ -3044,6 +3412,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;
 }