@songsid/agend 2.3.5-alpha.3 → 2.3.5-alpha.5

package/dist/fleet-manager.d.ts

@@ -1,3 +1,4 @@
+import { AgentRuntimeChanges } from "./agent-runtime-change.js";
 import { type HumanOrigin } from "./human-delivery-receipts.js";
 import { type SettingsPendingView } from "./settings-confirmation.js";
 import { type GeneralSwitchInput } from "./general-binding.js";
@@ -5,6 +6,7 @@ import { SettingsExecution } from "./settings-transaction.js";
 import { AppIconStore } from "./web-app-icon.js";
 import { type NamedTestResult } from "./tunnel/named-link-test.js";
 import { OfficeShareService } from "./office-share-service.js";
+import { OfficeTalk } from "./office-talk.js";
 import { type OfficeShare } from "./office-share.js";
 import type { PageShare } from "./page-share.js";
 import type { LoginCodeOwner } from "./web-login.js";
@@ -18,6 +20,7 @@ import type { FleetConfig, RawFleetConfig, InstanceConfig, WebVerifiedAuthorityC
 import { type DeliveryStatus, type GuildEmoji, type GuildEmojiGroup, type ResolvedStatusEmojis } from "./status-emojis.js";
 import { type RouteTarget } from "./fleet-context.js";
 import { EventLog } from "./event-log.js";
+import { type TopicDeleteOutcome } from "./instance-topic-delete.js";
 import { BackendAvailabilityStore, type AvailabilityProbes, type BackendAvailability } from "./backend-availability.js";
 import { AdapterWorld } from "./adapter-world.js";
 import { CostGuard } from "./cost-guard.js";
@@ -26,6 +29,7 @@ import type { AdapterHealthSnapshot, ChannelAdapter, InboundMessage, InboundReac
 import { type BackendCliVersionSnapshot } from "./backend/types.js";
 import { type Logger } from "./logger.js";
 import { Scheduler } from "./scheduler/index.js";
+import type { Task } from "./scheduler/types.js";
 import type { FleetContext } from "./fleet-context.js";
 import { TmuxControlClient } from "./tmux-control.js";
 import { RoutingEngine } from "./routing-engine.js";
@@ -54,6 +58,11 @@ export declare const LIVE_TASK_STATUSES: string[];
  * " \t " and [" ", "\t"] both normalize to undefined (not treated as explicit
  * filters). The same result drives the live-only default and the cap decision.
  */
+/**
+ * #3195: the saved value of each plain-update field the call named (assignee, priority, result), read back from the
+ * task — so the answer shows what was persisted, not what was asked. Status is always in the ack already.
+ */
+export declare function savedFields(t: Task, named: Record<string, unknown>): Partial<Pick<Task, "assignee" | "priority" | "result">>;
 export declare function normalizeStatusFilter(v: unknown): string | string[] | undefined;
 export declare function applyTaskListCap<T extends {
     updated_at: string;
@@ -63,10 +72,12 @@ export declare function applyTaskListCap<T extends {
     hint: string;
 } | T[];
 import { type PublicPreviewForUi } from "./web-api.js";
+import { RuntimeInstallService } from "./runtime-install.js";
 import { RuntimeCoordinator } from "./runtime-coordinator.js";
 import { FleetWindowsRuntime, type NativeRuntimePatch } from "./fleet-windows-runtime.js";
 import { NativeMcpSessions } from "./native-mcp.js";
 import { type LogAnswer, type LogQuery } from "./log-service.js";
+import { type ViewHistoryAnswer, type ViewHistoryQuery } from "./view-history.js";
 import { WebChatHistory, type WebChatPost } from "./web-chat-history.js";
 import { type WebEchoCopy } from "./web-reactions.js";
 import { SeenUsers, type MentionNames, type MentionQuery } from "./web-mentions.js";
@@ -93,6 +104,7 @@ import { WebBackendLogins, type SignInTarget } from "./web-backend-login.js";
 import { BrowserBackendSignIns } from "./browser-backend-signins.js";
 import { type RawConfigPatch } from "./settings-api.js";
 import { type AgentEndpointContext } from "./agent-endpoint.js";
+import { AgentCredentials } from "./agent-credentials.js";
 import { ClassicChannelManager } from "./classic-channel-manager.js";
 import { type ExplicitInstanceRemoval } from "./instance-removal.js";
 import { type SessionOomRetry } from "./session-oom-stop.js";
@@ -106,7 +118,7 @@ import { type OrgChart } from "./web-org.js";
 import { type MemoryHog } from "./memory-hogs.js";
 import { type CacheReport } from "./cache-service.js";
 import { type WebCommandResult } from "./web-commands.js";
-import { type SessionRecord } from "./web-session.js";
+import { type SessionRecord, type WebDeviceRow } from "./web-session.js";
 import { WebNotices } from "./web-notices.js";
 import { WebRemoteAccess } from "./web-remote-access.js";
 import { VERIFIED_SESSION_HOURS, type HumanAuthority, type WebAuthorityRefusal, type WebAuthorityResult, type WebPeer } from "./authority/web-authority.js";
@@ -119,6 +131,7 @@ import { type ConnectionMetadata, type ConnectionBinding, type BindingProbe, typ
 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 { type AccountsView } from "./accounts-view.js";
 import { StormWindow } from "./storm-window.js";
 import { SpawnGate } from "./spawn-gate.js";
 import { BackendOutageTracker } from "./backend-outage.js";
@@ -213,6 +226,11 @@ export interface DeliveryOptions {
     authorityCurrent?: () => boolean;
     /** Explicitly identify agent-to-agent delivery when metadata is unavailable. */
     isCrossInstance?: boolean;
+    /**
+     * The Hub representative's last step (docs/design/hub-representative-agent.md): run after any wake, the idle wait and
+     * the storm recheck, immediately before the IPC hand-off. False drops the delivery unsent. Not for Windows agents.
+     */
+    beforeInput?: () => Promise<boolean>;
     /** Force or bypass the idle gate. Schedules set this explicitly. */
     waitForIdle?: boolean;
     /** Test/operational override; normal deliveries use the 60 second backstop. */
@@ -340,6 +358,9 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private localPaneRelay;
     private openingLocalPane;
     private runtimeHub;
+    private runtimeInstall;
+    /** One service for the public installer routes and the administrator API: the hash the dashboard shows is the hash of what is sent. */
+    runtimeInstaller(): RuntimeInstallService;
     private runtimeExecutor;
     private runtimeStatusScheduled;
     private readonly reconciledRemoteResults;
@@ -348,8 +369,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private runtimeWindowsExecutor;
     /** Per-turn capabilities for native MCP, separate from browser and Linux-agent credentials. */
     nativeMcpSessions(): NativeMcpSessions;
+    /** Retire only existing native capabilities; ordinary lifecycle changes do not instantiate the Windows path. */
+    invalidateNativeMcp(name: string): void;
     /** The same instance registry and delivery entry point, with a native Windows execution adapter. */
     nativeInstanceRuntime(): FleetWindowsRuntime;
+    private agentRuntimeChangeService?;
+    agentRuntimeChanges(): AgentRuntimeChanges;
     /** Explicit dashboard opt-in, with the same General confirmation and ordinary topic/Daemon routing. */
     createNativePaneInstance(profile: Record<string, unknown>, channelId: string | undefined, authorized: () => boolean, execution: SettingsExecution): Promise<{
         name: string;
@@ -358,11 +383,22 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     }>;
     /** Admin-only settings path: validate first, then close the exact old launch before changing cold fields. */
     updateNativePaneConfig(name: string, patch: Partial<NativeRuntimePatch>, authorized: () => boolean, transaction?: Pick<SettingsExecution, "mutate" | "complete">): Promise<ReturnType<FleetWindowsRuntime["update"]>>;
+    /** The local machine's inventory as last used to open its pane relay (status only; never a launch decision). */
+    private localPaneInventory;
+    private nativeCliStatus;
     private localNativePaneEndpoint;
     /** Persistent ownership is independent of the exec worker's per-turn capabilities. */
     private nativePanes;
     /** Prepare only bundled role files; this neither switches General nor starts a provider process. */
     prepareWindowsGeneralWorkspace(name: string, machineId: string, cli: "codex" | "claude-code", bindingId: string, authorized: () => boolean): Promise<import("./runtime-general-protocol.js").GeneralWorkspaceReceipt>;
+    /** S3c (S-55): the member's exposure API, attached by S5's member composition (null: no Hub member here). */
+    private hubMemberExposureApi;
+    hubMemberExposures(): import("./hub/member/exposure-api.js").HubMemberExposureApi | null;
+    attachHubMemberExposures(api: import("./hub/member/exposure-api.js").HubMemberExposureApi | null): void;
+    /** S3c PR B: the member's pairing API, attached by S5's member composition (null: no Hub member here). */
+    private hubMemberPairingApi;
+    hubMemberPairing(): ReturnType<typeof import("./hub/member/pairing-api.js").createHubMemberPairingApi> | null;
+    attachHubMemberPairing(api: ReturnType<typeof import("./hub/member/pairing-api.js").createHubMemberPairingApi> | null): void;
     private readonly generalLocationFlights;
     private readonly generalAttentionEpisodes;
     private generalBindings;
@@ -406,6 +442,85 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * them at once; what the fleet itself holds (paired computers' connections, this PC's Windows process, agents' tool
      * sessions) follows just after, outside the save that changed them (applyRuntimeSwitches): no restart is needed.
      */
+    /** S-51: the Hub switches follow the configuration in force (load, save, reload rollback), like the runtime ones. */
+    private observeHubSwitches;
+    /** Reads the raw configuration at run time (the newest wins); off and never started: returns before any import. */
+    private applyHubSwitches;
+    /** Single flight: one import, one runtime, assigned once; every caller (and Stop) gets that same runtime. */
+    private hubRuntimeCreated;
+    /**
+     * S-51 PR 2b: while the member switch is on, the local owner's "Connect to a Hub" backend (S3c's pairing API) is
+     * attached, paired or not; switched off, it is detached. A binding change re-composes the member side.
+     */
+    private observeHubMemberPairing;
+    /**
+     * Disconnect: every published exposure is withdrawn and saved before the disconnect reports success. Through the
+     * running member's API, or — held or not composed — directly in the member's own store; a failure here makes the
+     * disconnect report "unsaved" (S3c), so consent never outlives the disconnect.
+     */
+    private hubMemberWithdrawAll;
+    /**
+     * The Hub exposure picker's agents (docs/design/hub-representative-agent.md): every configured instance normal
+     * delivery addresses, General included, shown by its display name. The dedicated Hub daemon is not a fleet instance.
+     */
+    private hubMemberAgents;
+    /** Same cached usage source as the owner's rail, scoped to the representative's CLI and credential profile. */
+    private hubAgentQuota;
+    /**
+     * A published representative's lifecycle token (#3145, #3147 review): a DURABLE incarnation id per agent name, rotated
+     * whenever its backend, folder or runtime changes and dropped when the instance is removed. A replacement (remove and
+     * re-add, even with the same name and config, across restarts) or any retarget — including A→B→A — gets a new id, so
+     * earlier consent never matches again without an explicit republish. Stopping or pausing changes nothing.
+     */
+    private hubAgentToken;
+    private hubIncarnationsPath;
+    /**
+     * M-2451 (#3147 residual): written beside hub-member/, in the data directory itself, when an invalidation could not be
+     * made durable in hub-member/. A later process that finds it invalidates every incarnation before handing out any
+     * token, so a restart never revives consent the earlier process had to withdraw (A→B→A, or a removal, while hub-member/
+     * was unwritable).
+     */
+    private hubIncarnationsMarkerPath;
+    /** Whether this process has settled the incarnations on disk (the marker handled, the file proven writable). */
+    private hubIncarnationsSettled;
+    /**
+     * Once per process, before the first token: an invalidation an earlier process could not persist (the marker) clears
+     * every incarnation; and an existing file must be rewritable here, else this process is broken (no token at all) —
+     * an incarnation this process could not rotate must never be handed out. Fails closed: any doubt marks it broken.
+     */
+    private settleHubIncarnations; /**
+     * #3147 r2: set when an invalidation could not be made durable in any way (neither the atomic write nor removing the
+     * file worked). From then on this process hands out no representative token at all, and the transitions the fleet
+     * controls (a config save, a removal) are refused instead of applied.
+     */
+    private hubIncarnationsBroken;
+    private readHubIncarnations;
+    /**
+     * Persist the incarnation map: "written", or — when the atomic write fails — "cleared": the whole file is removed, which
+     * durably invalidates EVERY earlier incarnation (all consent then needs a republish; never a revival). Throws (and
+     * marks the process broken) only when neither is possible.
+     */
+    private writeHubIncarnations;
+    /** The agent's durable incarnation id (create: make one if none; else null). A changed fingerprint rotates it. */
+    private hubAgentIncarnation;
+    /**
+     * Every configuration in force: rotate a recorded agent's incarnation when its backend/folder/runtime changed; drop
+     * removed ones. strict (a config save the fleet is about to write): a failure to make that durable throws, so the save
+     * is refused instead of applied. Otherwise (a load or reload of a hand-edited file) a failure is logged — the
+     * invalidation then is the cleared file, or, if nothing could be written, this process hands out no token at all.
+     */
+    private observeHubAgentIncarnations;
+    /** A removed instance's incarnation goes with it (a later instance of the same name is a new one). strict: throw if not durable. */
+    private forgetHubAgentIncarnation;
+    /**
+     * A Hub question to its representative agent: ordinary cross-instance delivery (idle gate, wake, retries), from the
+     * reserved Hub sender with the Hub-issued correlation id. beforeInput runs immediately before the IPC hand-off.
+     */
+    private deliverHubQuestion;
+    /** S-51: why the Hub (or this fleet's Hub membership) is not running, if it is held. Empty while off or running. */
+    getHubHolds(): readonly import("./hub/runtime.js").HubHold[];
+    hubBrowserCertificate(): import("./hub/browser-certificate.js").HubBrowserCertificateControl | null;
+    hubRetention(): import("./hub/retention.js").HubRetentionControl | null;
     private observeRuntimeSwitches;
     /**
      * Turned off: what it allowed ends now — the paired computers' connections (their agents show as offline) or this PC's
@@ -418,6 +533,32 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Native CLIs are headless: the manager owns the durable delivery generation instead of a tmux daemon. */
     private deliveryBootId;
     private rawFleetConfig;
+    /**
+     * S-51 (#3095, experimental, off by default): the Hub runtime. src/hub/runtime.js is imported only once a Hub switch
+     * (hub.enabled / hub_member.enabled) is on; while both are off nothing Hub-related loads, opens or listens.
+     */
+    private hubRuntime;
+    /** S3c's currentBinding reader, loaded with the pairing API (only while the member switch is on). */
+    private hubMemberBinding;
+    /** The member link as the "Connect to a Hub" view shows it (S5's client lifecycle). */
+    private hubMemberLink;
+    /** OutboundContext: the Hub representative's answer hook (null: no member service running, or not a Hub answer). */
+    hubReport(input: {
+        correlationId: string;
+        caller: string;
+        text: string;
+        callerCurrent(): boolean;
+        extras?: import("./hub-report-target.js").HubReportExtras;
+    }): Promise<import("./hub-report-target.js").HubReportOutcome> | null;
+    /** The member side's pane-failure hook for a Hub-issued correlation id (else null). */
+    private hubDeliveryFailed;
+    /** The member side's report_result hook for HUB_REPORT_TARGET while a representative service runs (else null). */
+    private hubReports;
+    /** The one in-flight creation (single flight): overlapping first observations share it, Stop waits for it. */
+    private hubRuntimeInit;
+    private hubEffectsReady;
+    private hubEffectsScheduled;
+    private hubHolds;
     private rawFleetDocument;
     /** #2208: the paths a saveFleetConfig() wrote, for its check that nothing else changed. */
     private fleetDocumentWrites;
@@ -543,6 +684,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private startupRetryNotices;
     /** Unsupported-CLI refusals waiting to go out, grouped by reason (#1109). */
     private unsupportedCliNotices;
+    private kiroCompatibilityHolds;
     private kiroIncompatNotices;
     /** Backoff between automatic startup retries; the last step repeats while the backend is down. */
     static readonly STARTUP_RETRY_BACKOFF_MS: number[];
@@ -570,6 +712,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private kiroMigrationRuns;
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     private needsYou;
+    private hubExecutionAttention;
+    private missedOfflineStore;
     private configHistory;
     private configHistoryTimer;
     private loadedFleetSource;
@@ -678,6 +822,9 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private discordPresenceEagerPending;
     private discordPresenceInFlight;
     private static readonly DISCORD_PRESENCE_REFRESH_MS;
+    /** #3066 §1d: how often a fleet with no Discord bot reads the quota for its history (the user's choice: 30 min). */
+    static readonly QUOTA_BACKGROUND_READ_MS: number;
+    private quotaReadTimer;
     /** Days of event/activity history to keep. */
     private static readonly EVENT_LOG_RETENTION_DAYS;
     private watchdogTimer;
@@ -794,6 +941,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** #2855: a trusted guest's searches, per account. */
     readonly guestSearches: OfficeWriteLimiter;
     private officeSharesInstance?;
+    /** #2861: when each instance was last talked to and answered (no words), for share links' dialogue box. */
+    readonly officeTalk: OfficeTalk;
     /**
      * #2636: Office share links — the live Office view for people outside the fleet, read-only, on a quick tunnel of
      * their own (a manager and lease of its own: never the fleet's one tunnel lane nor the public link's preview tunnel).
@@ -914,6 +1063,75 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private agentProposalsRev;
     private agentProposalOwner;
+    /**
+     * Refs #3061 (P2a): the new-device approval's one authority — the same one that decides an agent's request: this web-only
+     * fleet's owner, asked of the LIVE session each time (a sign-out, an expiry, a revocation, the authority switch or
+     * "Only this computer can authorize" turning a session into a non-owner is seen at once). A LAN session that signed in
+     * with a one-time code, a session a device approval made, a guest, a chat fleet's admin and the CLI's header token are
+     * none of them this: they are told so, and learn nothing about any request.
+     */
+    private deviceApprovalOwner;
+    /**
+     * Refs #3061 (auth-api): device-code sign-in is offered — a web-only fleet with web authorization on. With
+     * `web.verified_authority.enabled: false` no one is an owner (liveOwner → null), so no one could approve: the three
+     * `/auth/device-login*` routes answer 404 and the sign-in page shows no button. "Only this computer can authorize"
+     * does not close it: this computer's own session can still approve.
+     */
+    deviceLoginAvailable(): boolean;
+    /** Refs #3061 (P2b): `web.login_qr` (default off), read per page served — the sign-in page then draws the approve link's QR code. */
+    loginQrEnabled(): boolean;
+    /**
+     * GET /ui/devices: is this a web-only fleet, may THIS session approve a new device and end another (is it the verified
+     * owner), and — to an admin session, never to a guest or the CLI's header token — the signed-in devices (Refs #3061, P2b).
+     * `authority`: web authorization is on. With it off nobody is an owner (liveOwner → null), so nobody may add a device or
+     * sign another out; the page says why and points to `agend web-token rotate` on this computer instead of "use the AgEnD
+     * computer", which would not help.
+     */
+    webDevicesStatus(req: IncomingMessage): {
+        webOnly: boolean;
+        owner: boolean;
+        authority: boolean;
+        devices: WebDeviceRow[];
+    };
+    /**
+     * Refs #3061 (P2b): the device list — this fleet's admin sessions, newest activity first (a guest's sessions are the
+     * Guests page's, and a read-only tier has none): how each was approved, whether it carries owner authority, and which
+     * one is the reader's own. The same people may read this as may read `GET /auth/sessions` (any admin session).
+     *
+     * `ownerVerified` is the §3 verdict for the session as it would be used from where it signs in (a host session from
+     * this computer, a session from outside over the link): one that signed in with a one-time code or a device approval is
+     * not an owner until the authenticator vouches for it. Display only — the checks that act on it run again at each use.
+     */
+    private webDeviceRows;
+    /**
+     * Refs #3061 (P2b): may this request's session end ANOTHER session — one signed in elsewhere, or all of them (auth-api
+     * `DELETE /auth/sessions…`, which an admin session could always do). On a web-only fleet that is the verified owner's:
+     * a session a code or a device approval made is signed in but not an owner, and could otherwise sign out the owner's
+     * own. A fleet with a chat connection is as it was (its admins are the chat's). Ending one's OWN session is never this.
+     */
+    mayEndOtherSessions(req: IncomingMessage): boolean;
+    /**
+     * Refs #3061 (P2b): POST /ui/devices/signout {handle} — the owner ends another signed-in device (the settings list's
+     * button). Only the verified owner, asked of the LIVE session each time (a non-owner learns nothing about any handle:
+     * 403 before anything is looked up); only an admin session of this fleet (a guest's is the Guests page's; an unknown
+     * handle and a guest's are the same 404); never the owner's own session here (Sign out is /auth/logout). The device's
+     * authorization goes with it, so a copy of its cookie is nobody's.
+     */
+    webDeviceSignOut(req: IncomingMessage, handle: string): {
+        status: number;
+        body: Record<string, unknown>;
+    };
+    /**
+     * Refs #3061 (P2a): look a new device's code up (for the confirm screen), approve it, or deny it — the verified owner's,
+     * on a web-only fleet. The answer is the request as it now stands. Approving only marks the request approved: the new
+     * browser makes its own session when it next asks (auth-api POST /auth/device-login/poll), so no credential passes from
+     * here to there — not in the answer, not through the fleet. A wrong code counts against one fleet-wide breaker; while
+     * it is open every code (a right one too) waits.
+     */
+    webDeviceLoginAct(req: IncomingMessage, op: "lookup" | "approve" | "deny", code: string): {
+        status: number;
+        body: Record<string, unknown>;
+    };
     /** alpha.2: the agents' requests waiting for this web-only fleet's owner, or null when the reader is not that owner. */
     webAgentProposals(req: IncomingMessage): SettingsPendingView[] | null;
     /**
@@ -984,6 +1202,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     sseHeartbeatMs: number;
     /** The dashboard's login codes. Memory only: a code that outlives the process is a code nobody can prove was not copied. */
     private webLoginCodes;
+    /** Refs #3061 (P2a): device-code sign-in requests (in memory; web-device-login.ts). Read by auth-api as `webDeviceLogins`. */
+    private webDeviceLogins;
     /**
      * #1920 step 4: guests' codes, apart from the admins' — one per account, so no guest's `/web` withdraws another's or
      * an admin's code (#2093 review), at most 32 at once. Local sign-in only for now (audience "local").
@@ -1022,6 +1242,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * startup-only key at startup. See checkStartupSignatureConsistency(). */
     private fleetSignatureMismatch;
     private healthServerListening;
+    private agentCredentialsCache?;
+    get agentCredentials(): AgentCredentials;
     constructor(dataDir: string);
     /** #1266: a reply's buttons — the store (reply-buttons.db) and what a click does. Created on first use. */
     private replyButtonsCtl;
@@ -1246,6 +1468,7 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private tightenInstanceDirectories;
     /** AgEnD package version (for the Settings "current version" / What's New). */
     get currentVersion(): string;
+    get currentBuild(): import("./build-provenance.js").InstalledBuild;
     /**
      * Resolve a slash-command target in a channel. Classic channels are looked up
      * per-bot (same-channel multi-bot); a fleet-topic instance is found via the
@@ -1357,6 +1580,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Board 003648ac: a web /compact followed to its end, from the transcript the Log reads (none: nothing to follow). */
     private compactWatchService;
     private get compactWatch();
+    /**
+     * Claude history in the View: an instance's earlier conversation for its View, from the transcript the Log reads —
+     * the View's route applied its own access rules first (view-api.ts); the Log's switch plays no part.
+     */
+    viewHistory(name: string, q: ViewHistoryQuery): Promise<ViewHistoryAnswer | null>;
     /** #1218: GET /ui/steps — an instance's steps, read on demand (null: no such instance). */
     logSteps(name: string, q: LogQuery): Promise<LogAnswer | null>;
     /**
@@ -1418,6 +1646,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * retry brings it up, however long the backoff, and fails only once the retries give up.
      */
     private sendWhenConnected;
+    /**
+     * The Hub representative's hand-off (#3145): only once a connected client exists, after every reconnect/order wait,
+     * the begin lease + input intent (beforeInput), then the fence and the LIVE client are checked again and the payload
+     * goes in one attempt. After the intent is spent nothing here retries: false is the caller's uncertain outcome.
+     */
+    private handOffAfterBeforeInput;
     /** Poll for the instance's IPC to come back, then send. Throws if it does not. */
     private sendAfterIpcReturns;
     /**
@@ -1730,6 +1964,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * first unattended start and every scheduled retry.
      */
     private stopOnUnsupportedCli;
+    /** No pane is needed for a compatibility refusal to remain in Needs you. */
+    setKiroCompatibilityHold(name: string, message: string | null): void;
     /**
      * LifecycleContext: a kiro instance the installed kiro-cli cannot run as
      * configured (#1109) — at start, or at a respawn after kiro-cli replaced
@@ -2189,6 +2425,35 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Start all instances from fleet config */
     startAll(configPath: string): Promise<void>;
     private startAllWithinDeadline;
+    /**
+     * #3066 §1d (the user: yes, every 30 min): the quota history (usage/quota-history.ts) records only the readings AgEnD
+     * makes. A Discord bot's presence refresh reads every 15 min; without one, nothing reads while nobody looks. So, with no
+     * Discord bot and while some account has a running agent, read every 30 min — the same cached read (its 5-minute TTL
+     * still bounds the vendor calls), recorded like any other.
+     */
+    private startQuotaBackgroundReads;
+    /** #3066 §1: the latest estimates, by `provider\0metric` (what usage-api's lookup reads, synchronously). */
+    private capacityEstimates;
+    private capacityTimer;
+    static readonly CAPACITY_REFRESH_MS: number;
+    /**
+     * #3066 §1: estimate each account's weekly 100% from the quota history (§1d) and the usage ledger's hours — both read
+     * asynchronously, the arithmetic small (usage/capacity.ts). An account is its usage provider id ("claude",
+     * "claude:hsinlin", "codex:yanxianchen"): its hours are the ledger sources of that backend under that credential profile
+     * (Codex's "unrecorded" hours are no account's). A per-model weekly ("Sonnet (weekly)") counts only that model's tokens.
+     *
+     * Prism #3073: no estimate rather than a wrong one —
+     * - a window is measured only where the ledger has its hours: kept (31 days) and scanned (`days.coverage`) for every
+     *   instance of the account's backend, and every instance whose hours count for it; the quota history goes back 12 weeks;
+     * - a profile literally named "default", "unknown" or "unrecorded" (configured, on disk, or in the quota history) makes
+     *   those hours ambiguous: neither the host
+     *   account nor the named one is estimated (each would be credited the other's use, or lose its own);
+     * - only a metric the vendor marks per-model (`scope: "model"`) is filtered by model; another named weekly pool
+     *   ("Luna Reserve (weekly)", Antigravity pools) is no model name and is not estimated.
+     */
+    refreshCapacity(): Promise<number>;
+    /** One background quota read, when nothing else reads (no Discord bot) and an account has a running agent. */
+    backgroundQuotaRead(): Promise<boolean>;
     /** Keep Discord profile activity aligned with the same cached usage source as /usage. */
     private startDiscordUsagePresence;
     /**
@@ -2243,8 +2508,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      *                 that should be running is running
      *  - `degraded` — reachable, but something the operator should look at (an
      *                 adapter retrying, an instance crashed or stopped)
-     *  - `down`     — the fleet cannot do its job: no adapter is connected, so no
-     *                 message can arrive or be answered
+     *  - `down`     — no configured adapter is connected, or a dedicated Hub's
+     *                 server mount is unavailable
      *
      * Deliberately does NOT gate the systemd watchdog — see the comment at the
      * WATCHDOG timer for why.
@@ -2275,6 +2540,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
             topProcessesAt?: string;
         };
         problems: string[];
+        warnings: string[];
+        /** Local server mount availability; absent when the Hub server switch is off. */
+        hub?: {
+            server: import("./hub/runtime.js").HubServerHealth;
+        };
     };
     /** Start the primary adapter (backward-compatible, sets this.adapter) */
     private startSingleAdapter;
@@ -2414,6 +2684,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * copies retain their permissive handling when that identity is unknown.
      */
     private isOwnerCommandCopy;
+    /** File a Telegram update that was too old to inject; Needs you lists it until Acknowledge. */
+    private recordMissedOffline;
     /**
      * #1085: coincident topic numbers must not route across Telegram groups.
      */
@@ -2571,6 +2843,12 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * of the schedule response on IPC.
      */
     private performScheduleOp;
+    /**
+     * `post_decision` with `supersedes` changes a decision someone else may have recorded (it stops being active): the
+     * same permission as `update_decision`, asked through the same live check (tool set + dashboard switches), on both
+     * create paths. An empty or absent value supersedes nothing and needs nothing; anything else must be an id.
+     */
+    private decisionSupersedes;
     handleDecisionCrudHttp(instance: string, op: string, args: Record<string, unknown>): Promise<unknown>;
     handleTaskCrudHttp(instance: string, args: Record<string, unknown>): Promise<unknown>;
     handleSetDisplayNameHttp(instance: string, name: string): Promise<unknown>;
@@ -2586,7 +2864,48 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private handleTaskCrud;
     /** Create a forum topic via the adapter. Returns the message_thread_id. */
     createForumTopic(topicName: string, adapterId?: string): Promise<number | string>;
-    deleteForumTopic(topicId: number | string, adapterId?: string): Promise<void>;
+    /**
+     * Delete an agent and, unless asked not to, its own chat topic (user decision: by default). The topic is planned
+     * before the removal (its id and bot go with the fleet.yaml entry) and deleted through the agent's OWN bot after it;
+     * the outcome is the platform's answer (instance-topic-delete.ts). A topic that cannot go never fails the removal.
+     */
+    removeInstanceAndTopic(name: string, authorization: ExplicitInstanceRemoval, opts: {
+        deleteTopic: boolean;
+        execution?: SettingsExecution;
+    }): Promise<TopicDeleteOutcome>;
+    /** #3055: destinations whose platform deletion is running now; a binding to one waits until it is over. */
+    private readonly topicDeletionsInFlight;
+    /** True while a topic with this id is being deleted on any connection (a new binding of it is refused meanwhile). */
+    isTopicDeletionInFlight(topicId: number | string): boolean;
+    /**
+     * #3055 review r2 (Prism P1-3): would this instance config bind a topic whose deletion is running now? Compared by
+     * physical destination, so the same thread number in another Telegram group is not held. Settings asks it at commit.
+     */
+    topicBindingInFlight(inst: {
+        channel_id?: unknown;
+        topic_id?: unknown;
+    }): boolean;
+    /** Any topic deletion running now (a connection's group or General may not be re-pointed meanwhile). */
+    topicDeletionPending(): boolean;
+    /** The physical destination of `topicId` on the bot `adapterId`. */
+    private destinationFor;
+    /** The adapter of the bot `adapterId` names — never a substitute for a bot that is not there. */
+    private instanceTopicAdapter;
+    /**
+     * Topic ownership by physical destination (#3055 review, Prism P1): an instance's topic is where its bot's platform
+     * puts it (a Telegram group + thread, a Discord channel), so two bots in one group, or two instances on one
+     * channel, are seen to share it; and every connection's own General is protected, with or without a General agent.
+     */
+    private topicOwnership;
+    /**
+     * The bot an agent's configured topic is on (#3105 review, Prism P1): a fleet.yaml agent's `channel_id` (else the
+     * primary connection) whatever its runtime — a per-turn Windows agent has no execution adapter
+     * (getInstanceAdapterId), yet its topic is still on that bot, and must be counted as an owner and deleted through it.
+     * Topic planning and ownership only; execution routing is getInstanceAdapterId's and unchanged.
+     */
+    private topicAdapterIdOf;
+    /** What deleting `name`'s topic would act on: its own bot only — a bot that is not there is never substituted. */
+    private planInstanceTopicDelete;
     getForumTopicDeleter(adapterId?: string): ((topicId: number | string) => Promise<void>) | null;
     private topicCleanupTimer;
     private sessionPruneTimer;
@@ -3120,6 +3439,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     onAttentionChanged(name: string): void;
     /** The list for the web: every world's items, and those of instances with no world (#1386 §5.0). */
     needsYouItems(): WebNeedsItem[];
+    /** Enabled member composition supplies only a local attention reader, never an approval/execution callback. */
+    attachHubExecutionAttention(read: (() => import("./needs-you.js").HubExecutionAttentionInput[]) | null): void;
     /**
      * #1389: the org chart's structure for the web — the instances the dashboard lists (getUiStatus's names), General,
      * fleet.yaml's teams, each instance's description and thread link. Read on demand; the live state rides the stream.
@@ -3452,6 +3773,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
         }>;
         /** #2453 (§0.2): the admin's named-tunnel hostname, while one is configured (the named-link row shows only then). */
         namedHost: string | null;
+        /** A fleet with no chat connection: the page words the card for the authenticator, not for Discord / Telegram. */
+        webOnly: boolean;
     };
     private authorizationRequests;
     /**
@@ -3657,9 +3980,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * Make a tool summary safe to paste into a channel message.
      *
      * The text is agent-controlled (it is built from tool inputs — file paths,
-     * shell commands), so it gets flattened to one line, capped, and stripped of
-     * the two Discord mass-mention triggers. Neither channel renders it with a
-     * parse mode, so no markup escaping is needed beyond that.
+     * shell commands), so it gets flattened to one line, secrets masked, capped,
+     * and stripped of the two Discord mass-mention triggers. Masking comes BEFORE
+     * the cap: a cap can cut a mask's context but must never be what hides (or
+     * fails to hide) a secret. Neither channel renders it with a parse mode, so no
+     * markup escaping is needed beyond that.
      */
     private static sanitizeActivity;
     /**
@@ -3699,6 +4024,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     /** Configured threshold before elapsed time appears, in ms. */
     progressMinElapsedMs(): number;
+    /** M-2391: when the instance's live (not retiring) bubble started — the current turn's start — or undefined. */
+    private liveButtonStart;
     private startProgressTicker;
     /**
      * After a reply: give the instance REPLY_RETIRE_GRACE_MS to resume working; if
@@ -3788,6 +4115,34 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * #2233: Settings → Agents' sign-in list — every backend's default login as the availability snapshot has it, then
      * each credential profile an agent uses (its own login state, read offline).
      */
+    /** Which account each sign-in is, as the host's own `claude auth status` said (masked; see checkAuthIdentity). Keys are `backend\0profile` in a Map: a name is data, never a property. */
+    private readonly signInIdentities;
+    /** Reads in flight, by the same key: a second request for a sign-in that is already being read joins it instead of starting another process. */
+    private readonly signInIdentityReads;
+    /** Raised each time the accounts are forgotten: a read that began before is never allowed to write what it found. */
+    private signInIdentityGeneration;
+    private signInIdentitySlots;
+    private readonly signInIdentityWaiters;
+    private signInIdentity;
+    /** A sign-in finished (or changed): forget what was read and let no read that was already running put its answer back. */
+    private forgetSignInIdentities;
+    /** At most three `claude auth status` at once across the whole host, however many requests ask. */
+    private withSignInIdentitySlot;
+    /** One `claude auth status` for a sign-in (the default one, or a credential profile's folder). */
+    private readSignInIdentity;
+    /**
+     * Start reading, in the background, the account of each Claude Code sign-in that is signed in (the default and every profile an agent uses) and
+     * not read in the last five minutes. It never waits and never blocks a request: the list shows what is already known, and the pages are told to
+     * read it again when something new was learned. A sign-in already being read is not read twice, and a read that began before the accounts were
+     * forgotten (a sign-in finished meanwhile) is dropped. No login, no network request of ours, nothing logged.
+     */
+    refreshSignInIdentities(): void;
+    /**
+     * #3212 PR 1: the Accounts view (accounts-view.ts) — every CLI's default sign-in and named profiles (used or only on
+     * disk), who uses each and its weekly usage. Host rows only; a paired computer's rows come with #3190 Part 3c. Its
+     * usage is the usage panel's cached read (never forced), given at most `usageWaitMs` before the view is sent without it.
+     */
+    accountsView(usageWaitMs?: number): Promise<AccountsView>;
     backendSignInTargets(): SignInTarget[];
     /** #2233: the session with this handle is live, admin, local and of the current dashboard token. */
     private isLocalAdminSession;