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

package/dist/fleet-manager.js

@@ -1,19 +1,23 @@
+import { readInstalledBuild } from "./build-provenance.js";
 import { buildNativeFleetInstructions } from "./instructions.js";
 import { GENERAL_ROLE_INSTRUCTIONS } from "./general-role.js";
 import { NativePaneRecoveryError } from "./native-pane-recovery.js";
 import { nativePaneToolAvailable, nativePaneToolRefusal } from "./native-pane-tools.js";
 import { windowsAgentsFor } from "./windows-agents.js";
+import { AgentRuntimeChanges } from "./agent-runtime-change.js";
 import { supportsVerifiedKiroMigration, getCachedKiroCliCompatibility, kiroV1DbPath, kiroV2SessionsDir } from "./backend/kiro.js";
 import { listKiroV1Sessions, readKiroClassicLinks } from "./backend/kiro-identity.js";
 import { readKiroV1SavedModel } from "./backend/kiro-retired-model.js";
 import { sharedKiroV2StoreLane } from "./backend/kiro-v2-store.js";
 import { SEPARATE_FEATURE_KEYS, hasLegacyOffice, normalizeOfficeStorage } from "./dashboard-permissions.js";
+import { maskSecrets } from "./log-steps.js";
 import { loginNoticeMode, normalizeNoticeDelivery, setNoticeMode } from "./notice-delivery.js";
 import { DEFAULT_REPLY_TRIGGERS } from "./reply-triggers.js";
 import { WorkingRecoveryCoordinator, WORKING_RECOVERY_KIND, buildWorkingRecoveryPrompt } from "./working-recovery.js";
 import { PUBLIC_TUNNEL_TOKEN_ENV, PUBLIC_TUNNEL_TOKEN_HINT, normalizePublicTunnelToken } from "./public-tunnel-config.js";
 import { humanOwnerObjectId, webHumanOrigin } from "./human-delivery-receipts.js";
 import { SettingsBaselines } from "./settings-baseline.js";
+import { hubMembershipSettings } from "./hub-membership-settings.js";
 import { prepareSettingsEffect } from "./settings-effect.js";
 import { settingsDisplay } from "./settings-change.js";
 import { SettingsConfirmationError, SettingsConfirmationStore, settingsSourceLabel } from "./settings-confirmation.js";
@@ -38,11 +42,13 @@ import { clearPublicLinkOwner, readPublicLinkOwner, writePublicLinkOwner } from
 import { PUBLIC_PREVIEW_FRAME_SRC, PUBLIC_PREVIEW_TUNNEL_DIR, PublicPreview, publicPreviewWanted } from "./public-preview.js";
 import { CloudflaredProvider } from "./tunnel/cloudflared.js";
 import { ensureCloudflared } from "./tunnel/cloudflared-install.js";
-import { unattendedInstallCommand, loginShell } from "./unattended-install.js";
+import { installExitMarker, unattendedInstallCommand, loginShell } from "./unattended-install.js";
 import { InstallStream } from "./install-stream.js";
 import { namedTestLane, runNamedLinkTest } from "./tunnel/named-link-test.js";
 import { daemonTopicMode, isWebOnlyFleetConfig } from "./web-only-fleet.js";
 import { OFFICE_SHARE_TUNNEL_DIR, OfficeShareService } from "./office-share-service.js";
+import { OfficeTalk } from "./office-talk.js";
+import { pairingSummary } from "./hub-pairing-summary.js";
 import { ALL_OFFICES, WHOLE_FLEET } from "./office-share.js";
 import { TunnelPurposeLane } from "./tunnel/purpose-lane.js";
 import { ManagedTunnel } from "./tunnel/manager.js";
@@ -79,6 +85,11 @@ import { tmuxExecHelper } from "./tmux-exec-helper.js";
 import { kiroLogGate } from "./kiro-log-gate.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+// Describe this running program, not files an updater may replace later. No reads on dashboard polls.
+const RUNNING_BUILD = readInstalledBuild();
+if (RUNNING_BUILD.source)
+    Object.freeze(RUNNING_BUILD.source);
+Object.freeze(RUNNING_BUILD);
 /** Fallback access policy for a channel with no `access:` block — open (no gate). */
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
 import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiImageUrl, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
@@ -86,6 +97,7 @@ import { isProbeableRouteTarget } from "./fleet-context.js";
 import { getEffectiveInstanceDefaults, loadFleetConfig, loadRawFleetConfig, loadFleetConfigSource, loadRawFleetConfigSource, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG, autoGeneralInstanceConfig } from "./config.js";
 import { EventLog } from "./event-log.js";
 import { binaryProbe } from "./binary-probe.js";
+import { deletePlannedTopic, planInstanceTopicDelete, topicDestination, topicMustStay } from "./instance-topic-delete.js";
 import { AVAILABILITY_STALE_MS, BackendAvailabilityStore, hostAvailabilityProbes, findExecutableIn, resolveBackendBinary } from "./backend-availability.js";
 import { classifySqliteOpenError } from "./sqlite-open-errors.js";
 import { OutboxOpenError } from "./outbox-open-error.js";
@@ -102,6 +114,7 @@ import { formatFleetTime } from "./tz-utils.js";
 import { createAdapter } from "./channel/factory.js";
 import { isWebChannelEcho, WEB_ECHO_PREFIX } from "./web-channel-echo.js";
 import { TelegramAdapter } from "./channel/adapters/telegram.js";
+import { MissedOfflineStore } from "./missed-offline.js";
 import { createBackend } from "./backend/factory.js";
 import { readEffortMetadata } from "./backend/effort-metadata.js";
 import { codexEffort, flagEffort } from "./backend/launch-effort.js";
@@ -127,6 +140,7 @@ import { InstanceLifecycle, SupersededStartError, BACKEND_INSTALLATION_INFO, che
 import { TopicArchiver } from "./topic-archiver.js";
 import { StatuslineWatcher } from "./statusline-watcher.js";
 import { applyInstanceConfigPatch, outboundHandlers } from "./outbound-handlers.js";
+import { HUB_REPORT_TARGET } from "./hub-report-target.js";
 import { backendArgs, backendStep, joinBackendArgs, modelNameCarried, planDisplay } from "./backend-command.js";
 import { DeliveryOutbox, DEFAULT_REPLY_OBLIGATION_TTL_MS, isSilentScheduleDelivery } from "./delivery-outbox.js";
 // The target Daemon can legitimately wait 30 minutes for a busy pane before
@@ -153,6 +167,20 @@ export const LIVE_TASK_STATUSES = ["open", "claimed", "blocked", "review"];
  * " \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 function savedFields(t, named) {
+    const out = {};
+    if (named.assignee !== undefined)
+        out.assignee = t.assignee;
+    if (named.priority !== undefined)
+        out.priority = t.priority;
+    if (named.result !== undefined)
+        out.result = t.result;
+    return out;
+}
 export function normalizeStatusFilter(v) {
     if (typeof v === "string") {
         const s = v.trim();
@@ -182,19 +210,23 @@ export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
 }
 import { handleWebRequest, webPeerOf, broadcastSseEvent, broadcastToGuests, SSE_HEARTBEAT_MS } from "./web-api.js";
 import { windowsCliEnabled, closeWindowsBridge, inventoryProbed, LOCAL_WINDOWS_CLI_OFF } from "./windows-cli.js";
+import { nativeCliVersionState } from "./runtime-pane-native.js";
 import { localWindowsCliEnabled, remoteRuntimeEnabled, setConfiguredRuntimeSwitches, maxAgentsPerMachine } from "./runtime-switches.js";
+import { RuntimeInstallService } from "./runtime-install.js";
+import { RUNTIME_CREDENTIAL_CAPABILITY } from "./runtime-credential-profiles.js";
 import { RuntimeCoordinator } from "./runtime-coordinator.js";
 import { RuntimeWindowsBridge } from "./runtime-windows-bridge.js";
 import { FleetWindowsRuntime } from "./fleet-windows-runtime.js";
 import { NativeMcpSessions } from "./native-mcp.js";
 import { nativeProviderMcpSupported } from "./windows-cli-providers.js";
-import { isWindowsInstance, isNativePaneInstance, isNativeExecInstance, WINDOWS_CONFIG_REFUSED } from "./native-instance-registry.js";
+import { isWindowsInstance, isNativePaneInstance, isNativeExecInstance, WINDOWS_CONFIG_REFUSED, nativeCredentialProfile } from "./native-instance-registry.js";
 import { createNativeWindowsInstance, updateNativeWindowsInstance } from "./native-instance-api.js";
 import { NativeInstanceConfigEdit, parseNativeInstanceCreate } from "./native-instance-input.js";
 import { LogService } from "./log-service.js";
+import { viewHistory } from "./view-history.js";
 import { WebChatHistory, WEB_CHAT_TEXT_MAX, isWebMessageId, newWebMessageId, webChatFrom } from "./web-chat-history.js";
 import { WEB_ECHO_COPIES_MAX, WEB_MIRROR_TIMEOUT_MS, webReactionEmoji, webReactionProblem } from "./web-reactions.js";
-import { WebChatDiskStore } from "./web-chat-store.js";
+import { WebChatDiskStore, isSafeInstanceDirName } from "./web-chat-store.js";
 import { SeenUsers, resolveMentions } from "./web-mentions.js";
 import { OPERATOR, WebPrefsStore } from "./web-prefs.js";
 import { agendVersion } from "./agent-whats-new.js";
@@ -224,8 +256,8 @@ import { envFileKeys } from "./token-env-name.js";
 import { discordGeneralChannelId } from "./discord-general.js";
 import { parseEnvText } from "./env-file.js";
 import { isDisallowedIntentsError, isRejectedTokenError } from "./discord-permissions.js";
-import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
-import { LOGIN_FLOWS, checkAuthStatus, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
+import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, setCapacityLookup, usageProviderIdForBackend } from "./usage/usage-api.js";
+import { LOGIN_FLOWS, checkAuthStatus, checkAuthIdentity, authIdentitySupported, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
 import { LoginSession } from "./login-manager.js";
 import { runOnLoginShell } from "./login-shell.js";
 import { tightenInstanceDirs } from "./private-dir.js";
@@ -255,6 +287,8 @@ import { remoteCardAction, remoteCardChoiceLabel, remoteCardOutcomeText, remoteC
 import { recentChatContext } from "./log-tail.js";
 import { describeSignalSource, recordInternalRequest, withOrigin } from "./fleet-control-audit.js";
 import { handleAgentRequest, ToolNotPermittedError } from "./agent-endpoint.js";
+import { AgentCredentials, agentCredentialPolicy } from "./agent-credentials.js";
+import { writeSecretFile } from "./secret-file.js";
 import { ConfigHistory, ConfigSyntaxError, configIssueText } from "./config-history.js";
 import { ClassicChannelManager, classicWebEchoOn, getClassicBackendChoices, inferClassicChannelType, isSelectableClassicBackend, readClassicLastActivityAt, readClassicRoomNames } from "./classic-channel-manager.js";
 import { assertExplicitInstanceRemoval } from "./instance-removal.js";
@@ -285,13 +319,14 @@ import { CompactWatch, launchIdentity } from "./compact-watch.js";
 import { agyLegacyAgentsFile, danglingSymlink, migrateAgyAgentsFile } from "./backend/antigravity.js";
 import { claudeConfigDirFor, claudeProjectKey } from "./backend/claude-code.js";
 import { sharedRolloutIndex } from "./rollout-index.js";
-import { TASK_BOARD_ON_NOTICE, dashboardRefusalIn, taskBoardSwitchedOn } from "./dashboard-permissions.js";
+import { TASK_BOARD_ON_NOTICE, dashboardRefusalIn, taskBoardOffIn, taskBoardSwitchedOn } from "./dashboard-permissions.js";
 import { mayUseTool, resolveToolSet, scheduleOpRefusal, toolForIpcType, toolRefusedMessage, } from "./tool-permissions.js";
 import { authorizeSession, decideWebGate, loadOrCreateWebToken, readSessionCookies, readWebToken, sessionCookieUpgrade } from "./web-auth.js";
 import { bypassesWebGate, handleAuthRequest, serveGuestRefusedPage, serveSigninPage } from "./auth-api.js";
 import { isWebPageNavigation } from "./web-shell-routes.js";
-import { guestSessionPolicy, localSessionPolicy, tokenEpoch, WebSessionStore } from "./web-session.js";
+import { guestSessionPolicy, localSessionPolicy, sessionVia, tokenEpoch, WebSessionStore } from "./web-session.js";
 import { WebNotices, WEB_NOTICES_FILE } from "./web-notices.js";
+import { DeviceLoginRequests } from "./web-device-login.js";
 import { isOutsideLinkOwner, OUTSIDE_LINK_OWNER, OUTSIDE_LINK_RETRY_MS, OUTSIDE_OWN_CLOSES, outsideDuration, outsideTimer, TOTP_STEP_SECONDS, WEB_REMOTE_ACCESS_FILE, WebRemoteAccess } from "./web-remote-access.js";
 import { authorityNow, evaluateWebAuthority, HOST_OPERATOR, VERIFIED_SESSION_HOURS, webAuthorityPolicy } from "./authority/web-authority.js";
 import { AuthorityStateStore } from "./authority/authority-state.js";
@@ -314,9 +349,10 @@ import { PROVIDER_SECRET_SPECS, PUBLIC_TUNNEL_SECRET_SPEC, providerSecretSpec, p
 const SELF_RESTART_DEADLINE_MS = 300_000;
 import { APPLY_FLEET_TARGET, ApplyJobStore, viewOf, } from "./apply-job.js";
 import { kiroHome } from "./backend/kiro-kas-store.js";
-import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileLogin, credentialProfileLoginCommand, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
+import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileEnv, credentialProfileLogin, credentialProfileLoginCommand, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile, listConfiguredProfiles } from "./backend/credential-profile.js";
 import { carryClaudeConversation } from "./backend/claude-carry.js";
-import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
+import { classicProfile, mergeBackendOptions, profileKey, profileName, profileOf, readClassicBindings } from "./classic-bindings.js";
+import { ACCOUNT_CLIS, PROFILE_CLIS, buildAccountsView, profilesOnDisk, weeklyUsage } from "./accounts-view.js";
 import { classifyInstanceChange, CLASSIC_HOT_CONFIG_KEYS, HOT_INSTANCE_CONFIG_KEYS, hotConfigUpdate, } from "./instance-config-impact.js";
 import { cleanupWatchVerdict, formatRestartProgressCompletion, RestartProgress, } from "./restart-progress.js";
 import { FleetStartup } from "./fleet-startup.js";
@@ -330,6 +366,12 @@ import { BackendOutageTracker } from "./backend-outage.js";
 import { canUnlockAdvancedTips, DailyTipScheduler, selectTip, visibleTipLevels, } from "./tips.js";
 import { getTmuxSession } from "./config.js";
 import { OwnStatusMessages, discordMessageKey } from "./chat-log-ids.js";
+import { PROFILE_TIMELINE_FILE, PROFILE_UNRECORDED, recordProfileLaunch } from "./usage/profile-timeline.js";
+import { readQuotaHistory } from "./usage/quota-history.js";
+import { estimateCapacity } from "./usage/capacity.js";
+import { covered, hourSources } from "./usage-rollup.js";
+import { KEEP_DAYS } from "./cache-ledger.js";
+import { ratesFor } from "./cache-prices.js";
 // Closed migration cohort: these 11 names existed immediately before the first
 // managed-skill publisher (a1ac499f; parent e267e684). Never grow this set when
 // adding a bundled skill: its new name is not proof of old AgEnD ownership.
@@ -481,6 +523,8 @@ const INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
  * while anything real shows signs of life well before the old two minutes.
  */
 const PROGRESS_MIN_ELAPSED_MS = 30_000;
+/** M-2391: the threshold tick fires this long after it, never a millisecond before (timers can fire early). */
+const PROGRESS_THRESHOLD_MARGIN_MS = 50;
 /** How much of a tool summary the progress line will show before eliding. */
 const PROGRESS_ACTIVITY_MAX_CHARS = 48;
 /**
@@ -767,6 +811,9 @@ export class FleetManager {
     localPaneRelay = null;
     openingLocalPane = null;
     runtimeHub = null;
+    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() { return this.runtimeInstall ??= new RuntimeInstallService(); }
     runtimeExecutor = null;
     runtimeStatusScheduled = false;
     reconciledRemoteResults = new Set();
@@ -777,6 +824,7 @@ export class FleetManager {
         return this.runtimeHub ??= new RuntimeCoordinator(this.dataDir, {
             handleMcp: (machineId, runId, body) => this.runtimeWindowsExecutor().mcp(machineId, runId, body),
             handlePaneMcp: async (machineId, body, current) => (await this.nativePanes()).handle(machineId, body, current),
+            warn: (fields, message) => this.logger.warn(fields, message),
             changed: event => {
                 if (event?.type === "machine" && this.runtimeHub?.machine(event.machineId)?.status !== "online") {
                     for (const [name, config] of Object.entries(this.fleetConfig?.instances ?? {}))
@@ -817,6 +865,8 @@ export class FleetManager {
     nativeMcpSessions() {
         return this.nativeMcpStore ??= new NativeMcpSessions(this);
     }
+    /** Retire only existing native capabilities; ordinary lifecycle changes do not instantiate the Windows path. */
+    invalidateNativeMcp(name) { this.nativeMcpStore?.closeInstance(name); }
     /** The same instance registry and delivery entry point, with a native Windows execution adapter. */
     nativeInstanceRuntime() {
         return this.fleetWindowsRuntime ??= new FleetWindowsRuntime({
@@ -827,13 +877,25 @@ export class FleetManager {
             removed: name => this.nativeInstanceRemoved(name),
             paneCurrent: name => this.daemons.get(name)?.nativePaneCurrent?.() === true,
             machineAvailable: id => remoteRuntimeEnabled() && this.runtimeCoordinator().machine(id)?.status === "online",
-            validateMachine: (id, cli, sandbox) => {
+            machineGeneration: id => this.runtimeCoordinator().machine(id)?.bootId ?? null,
+            paneAvailable: id => this.runtimeCoordinator().machine(id)?.paneProtocol === 1,
+            validateMachine: (id, cli, sandbox, credentialProfile) => {
                 const machine = this.runtimeCoordinator().machine(id);
                 const provider = machine?.inventory?.clis.find(row => row.id === cli && row.runnable && row.supports.resume);
                 if (!machine || machine.status !== "online" || machine.platform !== "win32" || !provider)
                     throw new Error("Choose an online runtime and an available CLI");
                 if (sandbox === "read-only" && !provider.readOnlySupport)
                     throw new Error("This runtime CLI cannot enforce read-only execution");
+                if (credentialProfile !== undefined) {
+                    // Fail closed at selection time, not at the first message: an old Runtime would ignore the name and run another account.
+                    if (!machine.runtimeInfo?.capabilities.includes(RUNTIME_CREDENTIAL_CAPABILITY))
+                        throw new Error("This computer's Runtime is too old to choose a Claude account. Update the Runtime on that computer, then try again.");
+                    const row = machine.inventory?.credentialProfiles?.profiles.find(profile => profile.name === credentialProfile);
+                    if (!row)
+                        throw new Error(`This computer has not reported a credential profile named "${credentialProfile}". On that computer run: agend-runtime login claude-code ${credentialProfile}, then choose Detect again in that computer's CLI diagnostics (Settings → Runtime).`);
+                    if (row.loggedIn === false)
+                        throw new Error(`Credential profile "${credentialProfile}" is not signed in on that computer. Sign in there: agend-runtime login claude-code ${credentialProfile}`);
+                }
             },
             emit: (event, data) => {
                 this.emitSseEvent(event, event === "status" ? this.getUiStatus() : data);
@@ -842,6 +904,152 @@ export class FleetManager {
             },
         }, { bridge: this.runtimeWindowsExecutor() });
     }
+    agentRuntimeChangeService;
+    agentRuntimeChanges() {
+        if (this.agentRuntimeChangeService)
+            return this.agentRuntimeChangeService;
+        const windowPins = new Map();
+        return this.agentRuntimeChangeService ??= new AgentRuntimeChanges({
+            config: name => Object.hasOwn(this.fleetConfig?.instances ?? {}, name) ? this.fleetConfig.instances[name] : undefined,
+            defaults: () => this.fleetConfig?.defaults,
+            generation: () => [this.managerBootId, this.settingsGeneration],
+            epoch: name => this.lifecycle.epochOf(name),
+            backendState: (name, backend) => !isWindowsInstance(this.fleetConfig?.instances[name]) ? this.backendAvailabilityFor(name).find(row => row.backend === backend)?.state : undefined,
+            transition: (name, run) => this.lifecycle.runTransition(name, async (transition) => {
+                const config = this.fleetConfig?.instances[name];
+                if (!isWindowsInstance(config)) {
+                    const path = join(this.getInstanceDir(name), "window-id");
+                    let pin;
+                    if (existsSync(path)) {
+                        if (statSync(path).size > 128)
+                            throw Error("Invalid saved CLI window identity");
+                        pin = readFileSync(path, "utf8").trim();
+                        if (!/^@\d+$/.test(pin))
+                            throw Error("Invalid saved CLI window identity");
+                    }
+                    else if (this.daemons.has(name))
+                        throw Error("The current CLI window identity is unavailable");
+                    windowPins.set(name, pin);
+                }
+                try {
+                    return await run(async () => {
+                        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
+                            this.lifecycle.invalidate(name);
+                            this.nativeInstanceRuntime().setPaused(name, true);
+                        }
+                        else
+                            await this.stopInstance(name, transition);
+                    });
+                }
+                finally {
+                    windowPins.delete(name);
+                }
+            }),
+            idle: name => {
+                if (this.shuttingDown || this.lifecycle.hasWorkLease(name) || this.deliveryOutbox?.countForTarget(name, ["queued", "retry_wait", "delivering", "submission_started", "reconciliation_pending", "uncertain"]))
+                    return false;
+                const config = this.fleetConfig?.instances[name];
+                if (!config)
+                    return false;
+                if (isWindowsInstance(config)) {
+                    try {
+                        const agent = this.nativeInstanceRuntime().get(name);
+                        if (!agent || agent.blocked || agent.activeId && !isNativePaneInstance(config))
+                            return false;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                if (!this.daemons.has(name) && !isWindowsInstance(config) && existsSync(join(this.getInstanceDir(name), "window-id")))
+                    return false;
+                return !this.daemons.has(name) || this.getInstanceExecutionState(name) === "idle";
+            },
+            prepare: async (name, before, target, current) => {
+                if (!current())
+                    throw Error("Runtime change authority expired");
+                if (isWindowsInstance(before))
+                    this.nativeInstanceRuntime().importHistory(name);
+                if (target.runtime === "windows")
+                    return this.nativeInstanceRuntime().prepareRuntimeChange(name, before, target, current);
+                const sameAccount = !isWindowsInstance(before) && target.backend === (before.backend || this.fleetConfig?.defaults?.backend || "claude-code");
+                const availability = (sameAccount ? this.backendAvailabilityFor(name) : this.backendAvailabilityRows()).find(row => row.backend === target.backend);
+                if (availability && ["not_installed", "not_signed_in", "too_old"].includes(availability.state))
+                    throw Error("Choose an available CLI on the Fleet host");
+                const supplied = target.directory.trim(), cwd = supplied || join(this.dataDir, "workspaces", name);
+                if (!isAbsolute(cwd) || /^[A-Za-z]:[\\/]/.test(cwd) || /[\x00-\x1f]/.test(cwd))
+                    throw Error("Enter an absolute Linux working directory or leave it empty");
+                if (!current())
+                    throw Error("Runtime change authority expired");
+                if (supplied) {
+                    if (!statSync(cwd).isDirectory())
+                        throw Error("The Linux working directory is not a directory");
+                }
+                else
+                    mkdirSync(cwd, { recursive: true, mode: 0o700 });
+                const config = { ...before, runtime: "wsl", working_directory: cwd, backend: target.backend, model: target.model };
+                if (before.backend !== target.backend)
+                    config.model_failover = [];
+                for (const key of ["machine_id", "native_agent_id", "native_adapter", "native_sandbox"])
+                    delete config[key];
+                if (!sameAccount)
+                    delete config.backend_options;
+                return { config, discard: () => { } };
+            },
+            closed: async (name, before) => {
+                if (this.daemons.has(name))
+                    return false;
+                if (isWindowsInstance(before))
+                    return !this.nativeInstanceRuntime().get(name)?.activeId;
+                // An unreadable tmux state is not evidence that the old process exited.
+                const session = getTmuxSession();
+                if (!await TmuxManager.sessionExistsStrict(session))
+                    return true;
+                const pin = windowPins.get(name);
+                return !(await TmuxManager.listWindowsStrict(session)).some(window => window.name === name || pin && window.id === pin);
+            },
+            fresh: (name, requestId) => {
+                const dir = this.getInstanceDir(name), moved = [];
+                const restore = () => { for (const [source, saved] of moved.reverse())
+                    if (!existsSync(source) && existsSync(saved))
+                        renameSync(saved, source); };
+                try {
+                    for (const file of ["session-id", "session-id.backend"]) {
+                        const source = join(dir, file), saved = join(dir, `${file}.runtime-${requestId}`);
+                        if (existsSync(source)) {
+                            if (existsSync(saved))
+                                throw Error("Session backup already exists");
+                            renameSync(source, saved);
+                            moved.push([source, saved]);
+                        }
+                    }
+                    return restore;
+                }
+                catch (error) {
+                    restore();
+                    throw error;
+                }
+            },
+            save: (name, before, next) => {
+                if (this.fleetConfig?.instances[name] !== before)
+                    throw Error("Agent settings changed before saving Runtime");
+                // Mark the replacement stopped before committing its config. A marker failure must not leave a saved
+                // Windows config referring to a profile the preparation rollback would then remove.
+                writePausedMarker(this.getInstanceDir(name), Date.now(), "operator");
+                const fleet = this.fleetConfig;
+                fleet.instances[name] = next;
+                try {
+                    this.saveFleetConfig();
+                }
+                catch (error) {
+                    fleet.instances[name] = before;
+                    throw error;
+                }
+                // A move deliberately leaves the replacement stopped; its next explicit Start opens the fresh CLI.
+            },
+            changed: name => { this.instanceStateCache.delete(name); this.instanceProcessStatus.delete(name); this.emitSseEvent("status", this.getUiStatus()); },
+        });
+    }
     /** Explicit dashboard opt-in, with the same General confirmation and ordinary topic/Daemon routing. */
     async createNativePaneInstance(profile, channelId, authorized, execution) {
         const { createNativePane } = await import("./native-pane-create.js");
@@ -915,6 +1123,26 @@ export class FleetManager {
             return result;
         });
     }
+    /** The local machine's inventory as last used to open its pane relay (status only; never a launch decision). */
+    localPaneInventory = null;
+    nativeCliStatus(cli, machineId, daemon) {
+        if (cli !== "codex" && cli !== "claude-code")
+            return {};
+        // The version the running pane actually launched; only without one, the machine's last inventory.
+        let running;
+        try {
+            running = daemon?.usesNativePane?.() ? daemon.nativePaneCliVersion() : undefined;
+        }
+        catch {
+            running = undefined;
+        }
+        const inventory = machineId ? this.runtimeHub?.machine(machineId)?.inventory : this.localPaneInventory;
+        const version = running ?? inventory?.clis?.find(item => item.id === cli && item.runnable)?.version;
+        if (version === undefined || version === null)
+            return {};
+        const result = nativeCliVersionState(cli, version);
+        return { ...(result.version ? { native_cli_version: result.version } : {}), native_cli_verification: result.state };
+    }
     async localNativePaneEndpoint() {
         const admit = () => { if (this.shuttingDown || this.localPaneDrain || !localWindowsCliEnabled())
             throw Error("Local Windows runtime is switched off or draining"); };
@@ -931,6 +1159,7 @@ export class FleetManager {
             ]);
             admit();
             this.localPaneRelay?.stop();
+            this.localPaneInventory = inventory;
             const relay = await LocalPaneEndpoint.open({ scope: localPaneScope(this.dataDir), admit, maxAgents: maxAgentsPerMachine,
                 diagnostic: text => this.logger.warn({ stderr: text }, "Local Windows pane relay wrote to stderr"),
                 version: provider => inventory.clis.find(row => row.id === provider && row.runnable)?.version ?? null,
@@ -979,8 +1208,12 @@ export class FleetManager {
                 if (this.shuttingDown || !isNativePaneInstance(now) || now?.native_agent_id !== config.native_agent_id
                     || now?.machine_id !== config.machine_id || now?.working_directory !== config.working_directory || now?.backend !== config.backend
                     || now?.model !== config.model || now?.native_sandbox !== config.native_sandbox || now?.systemPrompt !== config.systemPrompt || now?.workflow !== config.workflow
-                    || now?.general_topic !== config.general_topic || now?.native_general_binding !== config.native_general_binding)
+                    || now?.general_topic !== config.general_topic || now?.native_general_binding !== config.native_general_binding
+                    || nativeCredentialProfile(now) !== nativeCredentialProfile(config))
                     throw Error("Native pane configuration or lifetime changed");
+                // Fail closed: a Runtime that does not report the capability would start the terminal on the computer's own account.
+                if (nativeCredentialProfile(config) && !this.runtimeCoordinator().machine(config.machine_id)?.runtimeInfo?.capabilities.includes(RUNTIME_CREDENTIAL_CAPABILITY))
+                    throw Error("This computer's Runtime is too old to choose a Claude account. Update the Runtime on that computer, then try again.");
                 if (config.machine_id ? this.remotePaneDrain || !remoteRuntimeEnabled() : this.localPaneDrain || !localWindowsCliEnabled())
                     throw Error("Native runtime is switched off");
             },
@@ -1039,12 +1272,12 @@ export class FleetManager {
             throw Error("General or its paired runtime is unavailable");
         const current = () => authorized() && !this.shuttingDown && remoteRuntimeEnabled() && this.runtimeHub === hub
             && this.fleetConfig?.instances[name] === config && hub.paneTransportEpoch(machineId) === epoch;
-        const [{ loadGeneralKnowledge }, { validateGeneralWorkspaceRequest, validateGeneralWorkspaceReceipt, generalWorkspaceUpgrade }, { assertAuditedNativePaneVersion }] = await Promise.all([
+        const [{ loadGeneralKnowledge }, { validateGeneralWorkspaceRequest, validateGeneralWorkspaceReceipt, generalWorkspaceUpgrade }, { assertRunnableNativePaneVersion }] = await Promise.all([
             import("./runtime-general-workspace.js"), import("./runtime-general-protocol.js"), import("./runtime-pane-native.js"),
         ]);
         if (!current())
             throw Error("General workspace authority expired");
-        assertAuditedNativePaneVersion(cli, hub.machine(machineId)?.inventory?.clis.find(row => row.id === cli && row.runnable)?.version ?? null);
+        assertRunnableNativePaneVersion(cli, hub.machine(machineId)?.inventory?.clis.find(row => row.id === cli && row.runnable)?.version ?? null);
         const request = validateGeneralWorkspaceRequest({ action: "general-workspace", bindingId, instance: name, cli, packHash: loadGeneralKnowledge(cli).hash });
         const inventory = await hub.callPane(machineId, { action: "list" }, maxAgentsPerMachine());
         if (!current())
@@ -1058,6 +1291,14 @@ export class FleetManager {
             throw new NativePaneRecoveryError({ kind: "host-upgrade" });
         return validateGeneralWorkspaceReceipt(result, request);
     }
+    /** S3c (S-55): the member's exposure API, attached by S5's member composition (null: no Hub member here). */
+    hubMemberExposureApi = null;
+    hubMemberExposures() { return this.hubMemberExposureApi; }
+    attachHubMemberExposures(api) { this.hubMemberExposureApi = api; }
+    /** S3c PR B: the member's pairing API, attached by S5's member composition (null: no Hub member here). */
+    hubMemberPairingApi = null;
+    hubMemberPairing() { return this.hubMemberPairingApi; }
+    attachHubMemberPairing(api) { this.hubMemberPairingApi = api; }
     generalLocationFlights = new Map();
     generalAttentionEpisodes = new Map();
     generalBindings() { return new GeneralBindings(this.dataDir); }
@@ -1513,6 +1754,364 @@ export class FleetManager {
      * 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. */
+    observeHubSwitches() {
+        this.observeHubAgentIncarnations();
+        if (!this.hubEffectsReady || this.hubEffectsScheduled || this.shuttingDown)
+            return;
+        this.hubEffectsScheduled = true;
+        queueMicrotask(() => { this.hubEffectsScheduled = false; void this.applyHubSwitches(); });
+    }
+    /** Reads the raw configuration at run time (the newest wins); off and never started: returns before any import. */
+    async applyHubSwitches() {
+        if (this.shuttingDown || !this.hubEffectsReady)
+            return;
+        const raw = this.rawFleetConfig;
+        const on = raw?.hub?.enabled === true || raw?.hub_member?.enabled === true;
+        if (!on && !this.hubRuntime && !this.hubRuntimeInit)
+            return;
+        try {
+            const runtime = this.hubRuntime ?? (await this.hubRuntimeCreated());
+            if (this.shuttingDown || !this.hubEffectsReady)
+                return; // Stop owns it now (fenced in stopAll, closed in doStopAll)
+            await this.observeHubMemberPairing(raw?.hub_member?.enabled === true);
+            const current = this.rawFleetConfig;
+            await runtime.apply({ hub: current?.hub, hub_member: current?.hub_member });
+        }
+        catch (err) {
+            this.logger.warn({ err: err?.message ?? String(err) }, "Hub switches could not be applied");
+        }
+    }
+    /** Single flight: one import, one runtime, assigned once; every caller (and Stop) gets that same runtime. */
+    hubRuntimeCreated() {
+        this.hubRuntimeInit ??= (async () => {
+            const { HubRuntime } = await import("./hub/runtime.js");
+            const runtime = new HubRuntime({
+                home: this.dataDir,
+                log: (level, message, meta) => this.logger[level](meta ?? {}, message),
+                onHoldsChanged: holds => { this.hubHolds = holds; this.needsYou?.poke(); },
+                // S-51 PR 2b: the fleet's side of a Hub membership (pairing binding, local agents, attachment points).
+                member: {
+                    // S3c's currentBinding: a fresh, fail-closed read of the pairing state (null unless consistent and connectable).
+                    boundHub: () => this.hubMemberBinding?.(this.dataDir)?.hubId ?? null,
+                    agents: () => this.hubMemberAgents(),
+                    // P1 representative mode (docs/design/hub-representative-agent.md): ordinary delivery + the report_result hook.
+                    representative: {
+                        quota: agent => this.hubAgentQuota(agent),
+                        deliver: input => this.deliverHubQuestion(input),
+                        agentToken: agent => this.hubAgentToken(agent),
+                        // attachments-v1: a question's files go into the agent's inbox; an answer's come from its own paths.
+                        files: { stateDir: this.dataDir,
+                            inboxDir: agent => isSafeInstanceDirName(agent) ? join(this.dataDir, "workspaces", agent, "inbox") : null,
+                            scratchDir: agent => isSafeInstanceDirName(agent) ? join(this.dataDir, "workspaces", agent, "hub-files") : null },
+                        attachReports: (handler, failed) => { this.hubReports = handler; this.hubDeliveryFailed = failed; },
+                    },
+                    attachExposures: api => this.attachHubMemberExposures(api),
+                    attachAttention: read => this.attachHubExecutionAttention(read),
+                    pokeAttention: () => this.needsYou?.poke(),
+                    linkState: state => { this.hubMemberLink = state; },
+                },
+            });
+            // Stop began during the import: it holds this promise and closes the runtime; do not hand it out again.
+            if (this.shuttingDown || !this.hubEffectsReady)
+                runtime.fence();
+            else
+                this.hubRuntime = runtime;
+            return runtime;
+        })();
+        return this.hubRuntimeInit;
+    }
+    /**
+     * 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.
+     */
+    async observeHubMemberPairing(on) {
+        if (!on) {
+            this.attachHubMemberPairing(null);
+            return;
+        }
+        if (this.hubMemberPairingApi)
+            return;
+        const { createHubMemberPairingApi, currentBinding } = await import("./hub/member/pairing-api.js");
+        if (this.shuttingDown || !this.hubEffectsReady || this.hubMemberPairingApi)
+            return;
+        this.hubMemberBinding = currentBinding;
+        this.attachHubMemberPairing(createHubMemberPairingApi({
+            home: this.dataDir,
+            enabled: () => this.rawFleetConfig?.hub_member?.enabled === true,
+            link: () => (this.hubMemberLink === "online" ? "online" : "offline"),
+            hold: () => (this.hubMemberLink === "revoked" ? "revoked" : null),
+            // Disconnect: stop the member client now (the runtime re-composes from the saved binding, fencing first).
+            fence: () => { void this.hubRuntime?.refresh(); },
+            // A claim saved, a disconnect tombstone or a cancel: re-compose the member side for the new binding.
+            bindingChanged: () => { void this.hubRuntime?.refresh(); },
+            // Disconnect withdraws every published exposure locally (each saved before this returns).
+            withdrawAll: () => this.hubMemberWithdrawAll(),
+        }));
+    }
+    /**
+     * 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.
+     */
+    async hubMemberWithdrawAll() {
+        const api = this.hubMemberExposureApi;
+        if (api) {
+            for (const view of api.list()) {
+                if (view.exposureId && view.state === "published")
+                    await api.withdraw(view.exposureId, view.revision);
+            }
+            return;
+        }
+        const hubId = this.hubMemberPairingApi?.boundHub()?.hubId ?? null;
+        if (!hubId)
+            return;
+        const { withdrawMemberExposuresOffline } = await import("./hub/compose/member.js");
+        await withdrawMemberExposuresOffline(this.dataDir, hubId);
+    }
+    /**
+     * 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.
+     */
+    hubMemberAgents() {
+        return Object.keys(this.fleetConfig?.instances ?? {}).map(name => ({ name, display: this.shownInstanceName(name) }));
+    }
+    /** Same cached usage source as the owner's rail, scoped to the representative's CLI and credential profile. */
+    async hubAgentQuota(agent) {
+        const binding = () => {
+            const config = this.fleetConfig?.instances[agent];
+            if (!config || isWindowsInstance(config))
+                return null; // runner usage never belongs to a Linux login
+            const backend = this.backendNameForInstance(agent), provider = usageProviderIdForBackend(backend);
+            if (!provider)
+                return null;
+            const profile = this.credentialProfileOf(agent, backend);
+            return profile ? `${provider}:${profile}` : provider;
+        };
+        const id = binding();
+        const { quotaBand } = await import("./hub/member/quota.js");
+        const paused = () => this.daemons.get(agent)?.quotaPaused?.() === true
+            || this.lifecycle.isPaused(agent) && readPauseReason(this.getInstanceDir(agent)) === "quota";
+        if (!id)
+            return { band: "unknown" };
+        try {
+            const snapshot = await getUsageSnapshot(false, new Set([id]));
+            if (binding() !== id)
+                return { band: "unknown" };
+            return quotaBand(snapshot.providers.find(p => p.id === id), paused());
+        }
+        catch {
+            return quotaBand(undefined, paused());
+        }
+    }
+    /**
+     * 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.
+     */
+    hubAgentToken(agent) {
+        const instances = this.fleetConfig?.instances ?? {};
+        if (!Object.prototype.hasOwnProperty.call(instances, agent))
+            return null;
+        if (this.hubIncarnationsBroken)
+            return null;
+        let id;
+        try {
+            this.settleHubIncarnations();
+            id = this.hubIncarnationsBroken ? null : this.hubAgentIncarnation(agent, instances[agent], true);
+        }
+        catch (err) {
+            this.logger.warn({ err: err?.message, agent }, "Hub agent incarnation could not be saved; the agent is not a deliverable representative");
+            return null;
+        }
+        return id ? createHash("sha256").update(JSON.stringify(["agend-hub-agent-v2", agent, id])).digest("hex") : null;
+    }
+    hubIncarnationsPath() { return join(this.dataDir, "hub-member", "agent-incarnations.json"); }
+    /**
+     * 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).
+     */
+    hubIncarnationsMarkerPath() { return join(this.dataDir, "hub-member-invalidate.pending"); }
+    /** Whether this process has settled the incarnations on disk (the marker handled, the file proven writable). */
+    hubIncarnationsSettled = false;
+    /**
+     * 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.
+     */
+    settleHubIncarnations() {
+        if (this.hubIncarnationsSettled || this.hubIncarnationsBroken || !this.dataDir)
+            return;
+        const path = this.hubIncarnationsPath(), marker = this.hubIncarnationsMarkerPath();
+        if (existsSync(marker)) {
+            try {
+                unlinkSync(path);
+            }
+            catch (err) {
+                if (err?.code !== "ENOENT") {
+                    this.hubIncarnationsBroken = true;
+                    this.logger.warn({ err: err?.message }, "An earlier Hub consent invalidation is still pending and cannot be applied; no Hub representative token is handed out");
+                    return;
+                }
+            }
+            // The clear is durable; a marker that cannot be removed only clears again next time (over-invalidation, never revival).
+            try {
+                unlinkSync(marker);
+            }
+            catch { /* left: harmless */ }
+            this.logger.warn("An earlier Hub consent invalidation was applied: every Hub representative needs a republish");
+        }
+        if (existsSync(path))
+            this.writeHubIncarnations(this.readHubIncarnations()); // throws (broken) when hub-member/ is not writable
+        this.hubIncarnationsSettled = true;
+    } /**
+     * #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.
+     */
+    hubIncarnationsBroken = false;
+    readHubIncarnations() {
+        try {
+            const value = JSON.parse(readFileSync(this.hubIncarnationsPath(), "utf8"));
+            return value && typeof value === "object" && !Array.isArray(value) ? Object.assign(Object.create(null), value) : Object.create(null);
+        }
+        catch {
+            return Object.create(null);
+        }
+    }
+    /**
+     * 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.
+     */
+    writeHubIncarnations(map) {
+        const path = this.hubIncarnationsPath(), tmp = `${path}.${process.pid}.tmp`;
+        try {
+            mkdirSync(join(this.dataDir, "hub-member"), { recursive: true, mode: 0o700 });
+            writeFileSync(tmp, JSON.stringify(map), { mode: 0o600 });
+            renameSync(tmp, path);
+            return "written";
+        }
+        catch (err) {
+            try {
+                rmSync(tmp, { recursive: false, force: true });
+            }
+            catch { /* a directory planted there: left alone */ }
+            try {
+                unlinkSync(path);
+            }
+            catch (gone) {
+                if (gone?.code !== "ENOENT") {
+                    this.hubIncarnationsBroken = true;
+                    // M-2451: record the withdrawal outside hub-member/, so a restart does not revive what this process withdrew.
+                    try {
+                        writeFileSync(this.hubIncarnationsMarkerPath(), "", { mode: 0o600 });
+                    }
+                    catch { /* the data directory too: nothing durable is left */ }
+                    throw err;
+                }
+            }
+            this.logger.warn({ err: err?.message }, "Hub agent incarnations could not be saved; every earlier Hub consent is invalidated (republish needed)");
+            return "cleared";
+        }
+    }
+    /** The agent's durable incarnation id (create: make one if none; else null). A changed fingerprint rotates it. */
+    hubAgentIncarnation(agent, cfg, create) {
+        const fp = createHash("sha256").update(JSON.stringify([cfg.backend ?? "claude-code", cfg.working_directory, cfg.runtime ?? "", cfg.machine_id ?? ""])).digest("hex");
+        const map = this.readHubIncarnations(), entry = Object.prototype.hasOwnProperty.call(map, agent) ? map[agent] : undefined;
+        if (entry && entry.fp === fp && typeof entry.id === "string")
+            return entry.id;
+        if (!entry && !create)
+            return null;
+        map[agent] = { id: randomUUID(), fp };
+        // A rotation that could only clear the file still invalidated the old id durably; the new one is made next time.
+        return this.writeHubIncarnations(map) === "written" ? map[agent].id : null;
+    }
+    /**
+     * 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.
+     */
+    observeHubAgentIncarnations(strict = false) {
+        // Only against a loaded configuration: never forget every agent because none is loaded yet.
+        if (!this.dataDir || !this.fleetConfig?.instances)
+            return;
+        try {
+            this.settleHubIncarnations();
+            if (this.hubIncarnationsBroken)
+                throw new Error("Hub agent incarnations cannot be written here");
+            if (!existsSync(this.hubIncarnationsPath()))
+                return;
+            const instances = this.fleetConfig.instances;
+            for (const agent of Object.keys(this.readHubIncarnations())) {
+                // Gone from the configuration in force (removed by hand in fleet.yaml, too): forgotten, never revived by a re-add.
+                if (Object.prototype.hasOwnProperty.call(instances, agent))
+                    this.hubAgentIncarnation(agent, instances[agent], false);
+                else
+                    this.forgetHubAgentIncarnation(agent, true);
+            }
+        }
+        catch (err) {
+            this.logger?.warn({ err: err?.message }, "Hub agent incarnations could not be checked");
+            if (strict)
+                throw new Error(`Hub consent for a changed agent could not be invalidated durably; the change is not saved (${err?.message})`);
+        }
+    }
+    /** A removed instance's incarnation goes with it (a later instance of the same name is a new one). strict: throw if not durable. */
+    forgetHubAgentIncarnation(agent, strict = false) {
+        try {
+            if (!this.dataDir || !existsSync(this.hubIncarnationsPath()))
+                return;
+            const map = this.readHubIncarnations();
+            if (!Object.prototype.hasOwnProperty.call(map, agent))
+                return;
+            delete map[agent];
+            this.writeHubIncarnations(map);
+        }
+        catch (err) {
+            this.logger.warn({ err: err?.message, agent }, "Hub agent incarnation could not be dropped");
+            if (strict)
+                throw new Error(`Hub consent for ${agent} could not be invalidated durably; refusing the change (${err?.message})`);
+        }
+    }
+    /**
+     * 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.
+     */
+    async deliverHubQuestion(input) {
+        const { HUB_REPORT_TARGET } = await import("./hub/representative.js");
+        if (this.shuttingDown || !this.fleetConfig?.instances[input.agent])
+            return false;
+        // Windows agents run through their own runtime, which has no pre-input hook: not a P1 representative.
+        if (isNativeExecInstance(this.fleetConfig.instances[input.agent]))
+            return false;
+        const ipcMeta = {
+            chat_id: "",
+            message_id: `hubmsg-${input.correlationId.slice(4)}`,
+            user: `instance:${HUB_REPORT_TARGET}`,
+            user_id: `instance:${HUB_REPORT_TARGET}`,
+            ts: new Date().toISOString(),
+            thread_id: "",
+            from_instance: HUB_REPORT_TARGET,
+            from_display: "Hub",
+            correlation_id: input.correlationId,
+            request_kind: "query",
+            requires_reply: "true",
+            task_summary: "A question from the Hub",
+        };
+        const result = await this.deliverToInstance(input.agent, { type: "fleet_inbound", targetSession: input.agent, content: input.text, meta: ipcMeta }, { isCrossInstance: true, stillCurrent: input.stillCurrent, beforeInput: input.beforeInput });
+        return result !== false;
+    }
+    /** S-51: why the Hub (or this fleet's Hub membership) is not running, if it is held. Empty while off or running. */
+    getHubHolds() {
+        return this.hubHolds;
+    }
+    hubBrowserCertificate() { return this.hubRuntime?.browserCertificateSettings() ?? null; }
+    hubRetention() { return this.hubRuntime?.retentionSettings() ?? null; }
     observeRuntimeSwitches() {
         setConfiguredRuntimeSwitches(this.fleetConfig?.runtimes);
         if (!this.runtimeEffects || this.runtimeEffectsScheduled)
@@ -1581,6 +2180,28 @@ export class FleetManager {
         return this.daemons.get(name)?.bootId ?? null;
     }
     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.
+     */
+    hubRuntime = null;
+    /** S3c's currentBinding reader, loaded with the pairing API (only while the member switch is on). */
+    hubMemberBinding = null;
+    /** The member link as the "Connect to a Hub" view shows it (S5's client lifecycle). */
+    hubMemberLink = "offline";
+    /** OutboundContext: the Hub representative's answer hook (null: no member service running, or not a Hub answer). */
+    hubReport(input) {
+        return this.hubReports?.(input) ?? null;
+    }
+    /** The member side's pane-failure hook for a Hub-issued correlation id (else null). */
+    hubDeliveryFailed = null;
+    /** The member side's report_result hook for HUB_REPORT_TARGET while a representative service runs (else null). */
+    hubReports = null;
+    /** The one in-flight creation (single flight): overlapping first observations share it, Stop waits for it. */
+    hubRuntimeInit = null;
+    hubEffectsReady = false;
+    hubEffectsScheduled = false;
+    hubHolds = [];
     rawFleetDocument = null;
     /** #2208: the paths a saveFleetConfig() wrote, for its check that nothing else changed. */
     fleetDocumentWrites = null;
@@ -1730,6 +2351,7 @@ export class FleetManager {
     startupRetryNotices = new Map();
     /** Unsupported-CLI refusals waiting to go out, grouped by reason (#1109). */
     unsupportedCliNotices = new Map();
+    kiroCompatibilityHolds = new Map();
     kiroIncompatNotices = new Map();
     /** Backoff between automatic startup retries; the last step repeats while the backend is down. */
     static STARTUP_RETRY_BACKOFF_MS = [60_000, 5 * 60_000, 15 * 60_000];
@@ -1758,6 +2380,8 @@ export class FleetManager {
     kiroMigrationRuns = new Map();
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     needsYou = null;
+    hubExecutionAttention = null;
+    missedOfflineStore = null;
     configHistory = null;
     configHistoryTimer = null;
     loadedFleetSource = null;
@@ -1873,6 +2497,9 @@ export class FleetManager {
     discordPresenceEagerPending = false;
     discordPresenceInFlight = null;
     static DISCORD_PRESENCE_REFRESH_MS = 15 * 60_000;
+    /** #3066 §1d: how often a fleet with no Discord bot reads the quota for its history (the user's choice: 30 min). */
+    static QUOTA_BACKGROUND_READ_MS = 30 * 60_000;
+    quotaReadTimer = null;
     /** Days of event/activity history to keep. */
     static EVENT_LOG_RETENTION_DAYS = 30;
     watchdogTimer = null;
@@ -2068,6 +2695,8 @@ export class FleetManager {
     /** #2855: a trusted guest's searches, per account. */
     guestSearches = new OfficeWriteLimiter(undefined, { perWindow: GUEST_SEARCHES.perWindow, windowMs: GUEST_SEARCHES.windowMs });
     officeSharesInstance;
+    /** #2861: when each instance was last talked to and answered (no words), for share links' dialogue box. */
+    officeTalk = new 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).
@@ -2084,6 +2713,7 @@ export class FleetManager {
                 hidden: name => crossInstanceVisibility(this.fleetConfig, name) === "hidden",
                 skins: this.officeSkins,
                 levels: () => this.officeLevelsSnapshot(),
+                talk: scope => this.officeTalk.recent(scope),
             },
             manager: new ManagedTunnel({ dataDir: join(this.dataDir, OFFICE_SHARE_TUNNEL_DIR), log: () => this.logger.warn("Office share tunnel cleanup requires attention") }),
             ensure: signal => ensureCloudflared({ dataDir: this.dataDir, pinnedOnly: true, signal }),
@@ -2440,6 +3070,26 @@ export class FleetManager {
         const baselines = this.settingsBaselineReader = new SettingsBaselines({ dataDir: this.dataDir, configPath: () => this.configPath,
             config: () => this.fleetConfig, current: () => [this.settingsGeneration, this.settingsRuntimeRevision, this.shuttingDown],
             generalLocation: input => this.previewGeneralLocation(input),
+            hubMembership: raw => hubMembershipSettings(raw),
+            // S3c (S-55): a Hub exposure publish's confirmation summary, while a member composition is attached.
+            hubBrowserCertificate: (input, binding) => {
+                const control = this.hubBrowserCertificate();
+                if (!control)
+                    throw Error("unavailable");
+                return control.preview(input, binding);
+            },
+            hubExposure: (input) => {
+                const api = this.hubMemberExposureApi;
+                if (!api)
+                    throw Object.assign(new Error("hub_member_unavailable"), { code: "hub_member_unavailable" });
+                return api.preview(input);
+            },
+            hubPairing: (action, input) => {
+                const api = this.hubMemberPairingApi;
+                if (!api)
+                    throw Object.assign(new Error("hub_member_unavailable"), { code: "hub_member_unavailable" });
+                return pairingSummary(action, input, api.view(), api.boundHub());
+            },
             proof: (kind, target, id, binding, key) => {
                 const map = kind === "provider" ? this.providerSecretChallenges : kind === "binding" ? this.connectionBindingChallenges : this.connectionSecretChallenges;
                 const proof = map.get(id);
@@ -2484,6 +3134,7 @@ export class FleetManager {
                         && sessions.isCurrent(record, tokenEpoch(this.webToken)) && (!exposure || exposure.isCurrent()) };
             }, baseline: () => baselines.read(), snapshot: () => baselines.snapshot(),
             selfConfirm: (req, id) => this.settingsSelfConfirmation(store, req, id),
+            directAgentCreation: true,
             job: async (id) => {
                 const settlement = this.settingsJobSettlements.get(id);
                 if (!settlement)
@@ -2588,6 +3239,132 @@ export class FleetManager {
         // while the request is applied fences it.
         return this.liveOwner(req, { hostOnly: false });
     }
+    /**
+     * 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.
+     */
+    deviceApprovalOwner(req) {
+        return this.liveOwner(req, { hostOnly: false });
+    }
+    /**
+     * 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() {
+        return this.isWebOnlyFleet() && this.webAuthorityState().enabled;
+    }
+    /** 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() {
+        return this.fleetConfig?.web?.login_qr === true;
+    }
+    /**
+     * 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) {
+        const webOnly = this.isWebOnlyFleet();
+        const owner = webOnly && !!this.deviceApprovalOwner(req);
+        return { webOnly, owner, authority: webOnly && this.webAuthorityState().enabled, devices: webOnly ? this.webDeviceRows(req) : [] };
+    }
+    /**
+     * 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.
+     */
+    webDeviceRows(req) {
+        const auth = authorizeSession(req, this.webToken, this.webSessions, { touch: false });
+        if (auth.kind !== "ok" || auth.session.tier !== "admin" || !this.webSessions)
+            return [];
+        const authorizations = this.sessionAuthorizationStore();
+        return this.webSessions.list(auth.session.idHash, r => r.tier === "admin").map(summary => {
+            const record = this.webSessions.findByHandle(summary.handle);
+            const gateway = summary.surface === "gateway";
+            const peer = gateway ? authorizations?.get(summary.handle)?.peer ?? "quick_link" : record?.host === true ? "loopback" : "lan";
+            return { handle: summary.handle, label: summary.label, via: summary.via, current: summary.current, surface: summary.surface,
+                created: summary.created, lastSeen: summary.lastSeen, expiresAt: Math.min(summary.absoluteExpiry, summary.idleExpiry),
+                ownerVerified: !!record && !this.webAuthority({ session: record, gateway, peer }).refusal };
+        });
+    }
+    /**
+     * 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) {
+        return !this.isWebOnlyFleet() || !!this.deviceApprovalOwner(req);
+    }
+    /**
+     * 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, handle) {
+        if (!this.isWebOnlyFleet() || !this.webSessions)
+            return { status: 404, body: { error: "not_found" } };
+        const owner = this.deviceApprovalOwner(req);
+        if (!owner)
+            return { status: 403, body: { error: "owner_required" } };
+        if (handle === owner.handle)
+            return { status: 400, body: { error: "this_device" } };
+        const target = this.webSessions.findByHandle(handle);
+        if (!target || target.tier !== "admin")
+            return { status: 404, body: { error: "not_found" } };
+        const { found, durable } = this.webSessions.revokeByHandle(handle, r => r.tier === "admin");
+        if (!found)
+            return { status: 404, body: { error: "not_found" } };
+        this.sessionAuthorizationStore()?.prune(a => a.handle !== handle);
+        this.logger.info({ by: owner.handle.slice(0, 8), handle, label: target.label, via: sessionVia(target), durable }, "Device signed out by the owner");
+        if (!durable)
+            return { status: 500, body: { ok: false, durable: false, error: "not_durable" } };
+        return { status: 200, body: { ok: true } };
+    }
+    /**
+     * 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, op, code) {
+        const owner = this.deviceApprovalOwner(req);
+        if (!owner)
+            return { status: 403, body: { error: "owner_required" } };
+        const logins = this.webDeviceLogins, token = this.webToken;
+        if (!logins || !token)
+            return { status: 404, body: { error: "not_found" } };
+        const epoch = tokenEpoch(token);
+        const shown = (v) => ({ code: v.code, label: v.label, peer: v.peer, address: v.address, expiresAt: v.expiresAt, state: v.state });
+        if (op === "lookup") {
+            const r = logins.lookup(code, epoch);
+            if (r.kind === "ok")
+                return { status: 200, body: { request: shown(r.view) } };
+            return r.kind === "paused" ? { status: 429, body: { error: "paused", retryAfterMs: r.retryAfterMs } } : { status: 404, body: { error: "not_found" } };
+        }
+        // (The owner above was asked of the live session just now, after the body was read; nothing is awaited since.)
+        const r = logins.decide(code, op === "approve" ? "approved" : "denied", owner.handle, epoch);
+        if (r.kind === "ok") {
+            this.logger.info({ approvedBy: owner.handle.slice(0, 8), label: r.view.label, peer: r.view.peer, decision: r.view.state }, op === "approve" ? "New device sign-in approved" : "New device sign-in denied");
+            return { status: 200, body: { request: shown(r.view) } };
+        }
+        if (r.kind === "decided")
+            return { status: 409, body: { error: "already_decided", state: r.state } };
+        return r.kind === "paused" ? { status: 429, body: { error: "paused", retryAfterMs: r.retryAfterMs } } : { status: 404, body: { error: "not_found" } };
+    }
     /** alpha.2: the agents' requests waiting for this web-only fleet's owner, or null when the reader is not that owner. */
     webAgentProposals(req) {
         if (!this.agentProposalOwner(req))
@@ -3145,6 +3922,8 @@ export class FleetManager {
     sseHeartbeatMs = SSE_HEARTBEAT_MS;
     /** The dashboard's login codes. Memory only: a code that outlives the process is a code nobody can prove was not copied. */
     webLoginCodes = null;
+    /** Refs #3061 (P2a): device-code sign-in requests (in memory; web-device-login.ts). Read by auth-api as `webDeviceLogins`. */
+    webDeviceLogins = null;
     /**
      * #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").
@@ -3183,6 +3962,22 @@ export class FleetManager {
      * startup-only key at startup. See checkStartupSignatureConsistency(). */
     fleetSignatureMismatch = null;
     healthServerListening = false;
+    agentCredentialsCache;
+    get agentCredentials() {
+        return this.agentCredentialsCache ??= new AgentCredentials(name => agentCredentialPolicy(this.fleetConfig, name, this.isClassicInstance(name)), name => {
+            try {
+                const token = randomBytes(32).toString("hex");
+                const result = writeSecretFile(join(this.getInstanceDir(name), "agent.token"), token);
+                if (!result.ok)
+                    this.logger.error({ name, mode: result.mode, reason: result.reason }, "Agent token file is not owner-only");
+                return token;
+            }
+            catch {
+                this.logger.error({ name }, "Agent credential renewal failed; prior generation remains retired");
+                return null;
+            }
+        });
+    }
     constructor(dataDir) {
         this.dataDir = dataDir;
         FleetManager.signalTarget = this;
@@ -3205,6 +4000,7 @@ export class FleetManager {
         this.topicCommands = new TopicCommands(this);
         this.topicArchiver = new TopicArchiver(this);
         this.statuslineWatcher = new StatuslineWatcher(this);
+        this.missedOfflineStore = new MissedOfflineStore(this.dataDir);
     }
     /** #1266: a reply's buttons — the store (reply-buttons.db) and what a click does. Created on first use. */
     replyButtonsCtl = null;
@@ -3585,6 +4381,10 @@ export class FleetManager {
                 }
             }
         }
+        // #3066 §1d: a Codex launch records the credential profile it runs under, so its usage is told by account.
+        if (daemon?.bootId === daemonBootId && this.backendNameOf(name) === "codex") {
+            void recordProfileLaunch(join(this.getInstanceDir(name), PROFILE_TIMELINE_FILE), this.credentialProfileOf(name, "codex") ?? "default");
+        }
         // #2802: no post-restart notices. The outbox still delivers or fails a row accepted before the restart, and an open
         // request is reminded by the ordinary turn-ended nudge (sweepReplyObligations) once the owner is idle.
         this.scheduleDeliveryOutboxPump();
@@ -4462,6 +5262,7 @@ export class FleetManager {
         this.enforceGuestSwitch();
         this.observeWebAuthority(); // #2453 review: a reload's web-authority switches are seen at once
         this.observeRuntimeSwitches(); // M-2255: so are the Windows runtimes' switches
+        this.observeHubSwitches(); // S-51: and the Hub's (no-op until the fleet has started)
         // Child tool/guidance readers must follow this fleet's actual config, including --config.
         // Scope the path to its owning data directory so another inherited home's override cannot enable CW.
         process.env.AGEND_FLEET_DATA_DIR = resolvePath(this.dataDir);
@@ -4515,6 +5316,8 @@ export class FleetManager {
      * guild channel.
      */
     reregisterClassicChannels() {
+        this.nativeMcpStore?.observePolicies();
+        this.agentCredentialsCache?.observePolicies();
         if (!this.classicChannels)
             return;
         const channels = this.classicChannels.getAll();
@@ -4567,13 +5370,9 @@ export class FleetManager {
     }
     /** AgEnD package version (for the Settings "current version" / What's New). */
     get currentVersion() {
-        try {
-            return JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version ?? "unknown";
-        }
-        catch {
-            return "unknown";
-        }
+        return RUNNING_BUILD.version;
     }
+    get currentBuild() { return RUNNING_BUILD; }
     /**
      * 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
@@ -5246,6 +6045,13 @@ export class FleetManager {
             changed: () => this.emitSseEvent("status", this.getUiStatus()),
         });
     }
+    /**
+     * 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, q) {
+        return viewHistory((n, rq) => this.log.readBack(n, rq), name, q);
+    }
     /** #1218: GET /ui/steps — an instance's steps, read on demand (null: no such instance). */
     logSteps(name, q) { return this.log.steps(name, q); }
     /**
@@ -5512,7 +6318,7 @@ export class FleetManager {
                 finish(false);
         });
     }
-    async deliverWithIdleGate(instanceName, payload, timeoutMs, deliveryEpoch, noInlineWake = false, stillCurrent, onStartRetryHold) {
+    async deliverWithIdleGate(instanceName, payload, timeoutMs, deliveryEpoch, noInlineWake = false, stillCurrent, onStartRetryHold, beforeInput) {
         if (this.shuttingDown || !this.deliveryCurrent(instanceName, deliveryEpoch, stillCurrent))
             return false;
         await this.holdDeliveryForStorm(instanceName, deliveryEpoch);
@@ -5551,7 +6357,8 @@ export class FleetManager {
             const log = idleGateTimeoutLog(instanceName, timeoutMs, this.instanceStateCache.get(instanceName), Date.now());
             this.logger[log.level](log.fields, log.message);
         }
-        const sent = await this.sendWhenConnected(instanceName, payload, deliveryEpoch, stillCurrent, onStartRetryHold);
+        // The Hub representative's begin lease + input intent run inside the final connected hand-off (sendWhenConnected).
+        const sent = await this.sendWhenConnected(instanceName, payload, deliveryEpoch, stillCurrent, onStartRetryHold, beforeInput);
         if (!sent)
             return false;
         if (this.deliveryCurrent(instanceName, deliveryEpoch, stillCurrent)) {
@@ -5584,21 +6391,25 @@ export class FleetManager {
      * `onStartRetryHold` (#2484, a person's message): an instance in its own start-retry backoff is waited for until that
      * retry brings it up, however long the backoff, and fails only once the retries give up.
      */
-    async sendWhenConnected(instanceName, payload, deliveryEpoch = this.getDeliveryEpoch(instanceName), stillCurrent, onStartRetryHold) {
+    async sendWhenConnected(instanceName, payload, deliveryEpoch = this.getDeliveryEpoch(instanceName), stillCurrent, onStartRetryHold, beforeInput) {
         if (!this.deliveryCurrent(instanceName, deliveryEpoch, stillCurrent))
             return false;
         const queued = this.ipcWaitTails.get(instanceName);
         if (!queued) {
             const ipc = this.instanceIpcClients.get(instanceName);
-            if (ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
-                return true;
+            if (ipc?.connected) {
+                if (beforeInput)
+                    return this.handOffAfterBeforeInput(instanceName, payload, deliveryEpoch, stillCurrent, beforeInput);
+                if (ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
+                    return true;
+            }
         }
         const attempt = (queued ?? Promise.resolve())
             .catch(() => { })
             .then(() => {
             if (!this.deliveryCurrent(instanceName, deliveryEpoch, stillCurrent))
                 return false;
-            return this.sendAfterIpcReturns(instanceName, payload, deliveryEpoch, stillCurrent, onStartRetryHold);
+            return this.sendAfterIpcReturns(instanceName, payload, deliveryEpoch, stillCurrent, onStartRetryHold, beforeInput);
         });
         // The chain stores a settled-either-way promise so one failed delivery cannot
         // wedge every later one, and so `queued` above is safe to await unguarded.
@@ -5615,8 +6426,21 @@ export class FleetManager {
             }
         }
     }
+    /**
+     * 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.
+     */
+    async handOffAfterBeforeInput(instanceName, payload, deliveryEpoch, stillCurrent, beforeInput) {
+        if (!(await beforeInput()))
+            return false;
+        if (this.shuttingDown || !this.deliveryCurrent(instanceName, deliveryEpoch, stillCurrent))
+            return false;
+        const ipc = this.instanceIpcClients.get(instanceName);
+        return !!ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload));
+    }
     /** Poll for the instance's IPC to come back, then send. Throws if it does not. */
-    async sendAfterIpcReturns(instanceName, payload, deliveryEpoch = this.getDeliveryEpoch(instanceName), stillCurrent, onStartRetryHold) {
+    async sendAfterIpcReturns(instanceName, payload, deliveryEpoch = this.getDeliveryEpoch(instanceName), stillCurrent, onStartRetryHold, beforeInput) {
         let deadline = Date.now() + IPC_RECONNECT_GRACE_MS;
         let warned = false;
         let held = false;
@@ -5626,6 +6450,8 @@ export class FleetManager {
             // Re-read every round: a reconnect replaces the IpcClient object entirely,
             // so a cached reference would stay dead forever.
             const ipc = this.instanceIpcClients.get(instanceName);
+            if (ipc?.connected && beforeInput)
+                return this.handOffAfterBeforeInput(instanceName, payload, deliveryEpoch, stillCurrent, beforeInput);
             if (ipc?.connected && ipc.send(this.bindHumanReceiptPayload(instanceName, payload)))
                 return true;
             // #2484: while the instance waits for (or runs) its own start retry, the grace runs from now — so the message is
@@ -6065,6 +6891,8 @@ export class FleetManager {
         if (this.generalLocationDeliveryHold(instanceName))
             return false;
         if (isNativeExecInstance(this.fleetConfig?.instances[instanceName])) {
+            if (options.beforeInput)
+                return false; // no pre-input hook on the Windows runtime
             return this.nativeInstanceRuntime().deliver(instanceName, payload, { stillCurrent: options.stillCurrent,
                 ...(options.authorityCurrent ? { authorityCurrent: options.authorityCurrent } : {}) });
         }
@@ -6089,7 +6917,7 @@ export class FleetManager {
                     return false;
                 this.enforceWarmCap(instanceName); // woke one → evict a different LRU idle if over cap
             }
-            const sent = await this.sendWhenConnected(instanceName, deliveryPayload, deliveryEpoch, options.stillCurrent, options.onStartRetryHold);
+            const sent = await this.sendWhenConnected(instanceName, deliveryPayload, deliveryEpoch, options.stillCurrent, options.onStartRetryHold, options.beforeInput);
             if (!sent)
                 return false;
             // A cross-instance item arriving before the daemon observes this turn as
@@ -6100,7 +6928,7 @@ export class FleetManager {
             return true;
         }
         const previous = this.idleGatedDeliveryTails.get(instanceName) ?? Promise.resolve();
-        const delivery = previous.catch(() => { }).then(() => this.deliverWithIdleGate(instanceName, deliveryPayload, options.idleTimeoutMs ?? 60_000, deliveryEpoch, options.noInlineWake === true, options.stillCurrent, options.onStartRetryHold));
+        const delivery = previous.catch(() => { }).then(() => this.deliverWithIdleGate(instanceName, deliveryPayload, options.idleTimeoutMs ?? 60_000, deliveryEpoch, options.noInlineWake === true, options.stillCurrent, options.onStartRetryHold, options.beforeInput));
         this.idleGatedDeliveryTails.set(instanceName, delivery);
         try {
             return await delivery;
@@ -7371,6 +8199,17 @@ export class FleetManager {
         this.queueKiroIncompatNotice(name, err.message);
         return true;
     }
+    /** No pane is needed for a compatibility refusal to remain in Needs you. */
+    setKiroCompatibilityHold(name, message) {
+        const holds = this.kiroCompatibilityHolds ??= new Map();
+        if ((message === null && !holds.has(name)) || (message !== null && holds.get(name)?.message === message))
+            return;
+        if (message === null)
+            holds.delete(name);
+        else
+            holds.set(name, { message, since: Date.now() });
+        this.needsYou?.poke();
+    }
     /**
      * LifecycleContext: a kiro instance the installed kiro-cli cannot run as
      * configured (#1109) — at start, or at a respawn after kiro-cli replaced
@@ -7877,6 +8716,12 @@ export class FleetManager {
                 },
             });
         }
+        if (!this.webDeviceLogins) {
+            this.webDeviceLogins = new DeviceLoginRequests({
+                onEvent: event => { if (event === "breaker-open")
+                    this.logger.warn("Device sign-in approval paused: too many wrong codes"); },
+            });
+        }
         if (!this.webGuestLoginCodes) {
             this.webGuestLoginCodes = new GuestLoginCodes({
                 onEvent: event => {
@@ -8491,6 +9336,7 @@ export class FleetManager {
         void this.publicWebLink?.close("dashboard revoke");
         this.forgetPublicLinkOwner();
         this.webLoginCodes.revoke();
+        this.webDeviceLogins?.revokeAll(); // …and every new device still waiting to be approved (#3061)
         this.webGuestLoginCodes.revokeAll();
         this.guestRevokes++; // and every guest /web still on its way
         // #1570: no browser may ask the sign-in page for a code any more.
@@ -9454,8 +10300,9 @@ export class FleetManager {
         // #2910: a web-only fleet's agents run in topic mode too (their cross-instance tools work; the dashboard is their place).
         const topicMode = daemonTopicMode(fleet);
         // Set tmux socket isolation for custom AGEND_HOME
-        const { getTmuxSocketName: getSocket } = await import("./paths.js");
-        TmuxManager.setSocketName(getSocket());
+        // M-2457: the bundled tmux's socket while it is on; getTmuxSocketName() as before while off.
+        const { tmuxSocket } = await import("./tmux-binary.js");
+        TmuxManager.setSocketName(tmuxSocket());
         await TmuxManager.ensureSession(getTmuxSession());
         this.tmuxSessionEnsured = true;
         // #2072: what this host can run — probed in the background, published for every picker.
@@ -9720,6 +10567,9 @@ export class FleetManager {
         await this.startHealthServer(fleet.health_port ?? 19280);
         if (this.shuttingDown)
             return;
+        // S-51: from here on the Hub switches apply (an enabled Hub mounts now, beside the fleet; it never blocks startup).
+        this.hubEffectsReady = true;
+        this.observeHubSwitches();
         if (generals.length > 0) {
             for (const [name, cfg] of generals) {
                 try {
@@ -9822,6 +10672,9 @@ export class FleetManager {
         if (others.length > 0 || classicAtBoot.length > 0) {
             await this.startInstancesWithConcurrency(others, topicMode, () => startupProgress.markReady(), classicAtBoot);
         }
+        // #3066 §1d (Fable r1): on every fleet — a web-only one (#2910) has no chat connection at all, and is the clearest
+        // case with no Discord bot reading. Each tick decides for itself whether to read (backgroundQuotaRead).
+        this.startQuotaBackgroundReads();
         if (topicMode && (fleet.channel || fleet.channels?.length)) {
             await adapterStartup;
             this.startDiscordUsagePresence();
@@ -9997,6 +10850,178 @@ export class FleetManager {
             this.logger.warn({ health }, "Fleet started with problems — see /health");
         }
     }
+    /**
+     * #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.
+     */
+    startQuotaBackgroundReads() {
+        if (this.quotaReadTimer)
+            clearInterval(this.quotaReadTimer);
+        this.quotaReadTimer = setInterval(() => { void this.backgroundQuotaRead(); }, FleetManager.QUOTA_BACKGROUND_READ_MS);
+        this.quotaReadTimer.unref?.();
+        // #3066 §1: the measured capacity, published for the usage reads (get_usage, the page) — refreshed every 10 min.
+        setCapacityLookup((provider, metric) => this.capacityEstimates.get(`${provider}\u0000${metric}`) ?? null);
+        if (this.capacityTimer)
+            clearInterval(this.capacityTimer);
+        void this.refreshCapacity();
+        this.capacityTimer = setInterval(() => { void this.refreshCapacity(); }, FleetManager.CAPACITY_REFRESH_MS);
+        this.capacityTimer.unref?.();
+    }
+    /** #3066 §1: the latest estimates, by `provider\0metric` (what usage-api's lookup reads, synchronously). */
+    capacityEstimates = new Map();
+    capacityTimer = null;
+    static CAPACITY_REFRESH_MS = 10 * 60_000;
+    /**
+     * #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.
+     */
+    async refreshCapacity() {
+        try {
+            const readings = await readQuotaHistory();
+            const groups = new Map();
+            for (const r of readings) {
+                const k = `${r.provider}\u0000${r.metric}`;
+                (groups.get(k) ?? groups.set(k, []).get(k)).push(r);
+            }
+            if (!groups.size) {
+                this.capacityEstimates = new Map();
+                return 0;
+            }
+            const data = await this.cacheServiceFor().usageData();
+            const now = Date.now(), DAY = 24 * 3_600_000, HOUR = 3_600_000;
+            const keptFrom = now - KEEP_DAYS * DAY + HOUR; // the oldest hour still in every ledger (an hour of margin)
+            // Profiles whose names are also the ledger's own tags: their hours cannot be told from the host's / unattributed.
+            // Any trace of such a profile counts (Prism #3073 r2), not only today's config — a binding removed or switched
+            // leaves its hours in the ledger: configured now, its directory on this host, or its account in the quota history.
+            const RESERVED = new Set(["default", "unknown", PROFILE_UNRECORDED]);
+            const historyProviders = new Set(readings.map((r) => r.provider));
+            const reservedNamed = new Map();
+            const reservedFor = (backend) => {
+                const known = reservedNamed.get(backend);
+                if (known)
+                    return known;
+                const found = new Set(listConfiguredProfiles(this.fleetConfig, backend).filter((n) => RESERVED.has(n)));
+                const base = usageProviderIdForBackend(backend);
+                for (const n of RESERVED) {
+                    if (base && historyProviders.has(`${base}:${n}`))
+                        found.add(n);
+                    if (credentialHomeSpec(backend) && existsSync(credentialProfileHome(this.dataDir, backend, n)))
+                        found.add(n);
+                }
+                return reservedNamed.set(backend, found).get(backend);
+            };
+            // Every instance of a backend may have used any of its accounts (bindings change): an account is measured only
+            // where all of them were scanned (Prism #3073 r2) — one still waiting for its first scan has no hours yet, not none.
+            const daysOfBase = new Map();
+            for (const inst of data.instances) {
+                const base = usageProviderIdForBackend(inst.inst.backend);
+                if (base)
+                    (daysOfBase.get(base) ?? daysOfBase.set(base, []).get(base)).push(inst.days);
+            }
+            // provider id → hour → model key → totals; and the instances whose hours count for it (their scan coverage).
+            const byProvider = new Map();
+            const daysOf = new Map();
+            for (const inst of data.instances) {
+                for (const [hk, hour] of Object.entries(inst.ledger.hours)) {
+                    for (const src of hourSources(hour)) {
+                        const base = usageProviderIdForBackend(src.backend);
+                        if (!base)
+                            continue;
+                        // Ambiguous (a named profile with the tag's name), or no account's: counted for no one, so an account whose
+                        // hours these may be has none — and gets no estimate, never a low one.
+                        if (reservedFor(src.backend).has(src.profile) || src.profile === "unknown" || src.profile === PROFILE_UNRECORDED)
+                            continue;
+                        const provider = src.profile === "default" ? base : `${base}:${src.profile}`;
+                        const list = daysOf.get(provider) ?? daysOf.set(provider, []).get(provider);
+                        if (!list.includes(inst.days))
+                            list.push(inst.days);
+                        const hours = byProvider.get(provider) ?? byProvider.set(provider, new Map()).get(provider);
+                        const into = hours.get(Number(hk)) ?? hours.set(Number(hk), Object.create(null)).get(Number(hk));
+                        for (const [mk, tot] of Object.entries(src.m)) {
+                            const cur = into[mk] ??= [0, 0, 0, 0, 0, 0, 0];
+                            for (let i = 0; i < 7; i++)
+                                cur[i] = (cur[i] ?? 0) + (tot[i] ?? 0);
+                        }
+                    }
+                }
+            }
+            const next = new Map();
+            for (const [key, list] of groups) {
+                const [provider, metric] = key.split("\u0000");
+                // A per-model weekly ("Sonnet (weekly)", the vendor's scope "model"): that model's tokens only. Another named
+                // pool is not a model: no estimate. "Weekly", "Weekly limit": everything.
+                const named = /^(.+) \((?:weekly|monthly|\d+d)\)$/i.exec(metric)?.[1]?.toLowerCase() ?? null;
+                const perModel = list.some((r) => r.scope === "model");
+                if (named && !perModel)
+                    continue;
+                const hours = [];
+                for (const [hour, models] of byProvider.get(provider) ?? []) {
+                    let api = 0, output = 0, all = 0;
+                    for (const [mk, tot] of Object.entries(models)) {
+                        const bar = mk.lastIndexOf("|"), model = mk.slice(0, bar), long = mk.slice(bar + 1) === "1";
+                        if (named && !model.toLowerCase().includes(named))
+                            continue;
+                        const [, uncached, read, w5, w1h, w, out] = tot;
+                        const r = ratesFor(model, long ? Number.MAX_SAFE_INTEGER : 0);
+                        api = api === null || !r ? null : api + (uncached * r.input + read * r.read + w5 * r.write5m + w1h * r.write1h + w * r.write + out * r.output) / 1_000_000;
+                        output += out;
+                        all += uncached + read + w5 + w1h + w + out;
+                    }
+                    if (all > 0)
+                        hours.push({ hour, api, output, all });
+                }
+                const base = provider.split(":")[0];
+                const scanned = [...new Set([...(daysOf.get(provider) ?? []), ...(daysOfBase.get(base) ?? [])])];
+                const available = (from, to) => {
+                    if (from < keptFrom || !scanned.length)
+                        return false;
+                    for (let h = from; h <= to; h += HOUR)
+                        if (!scanned.every((d) => covered(d, h)))
+                            return false;
+                    return true;
+                };
+                const est = estimateCapacity(list, hours, available);
+                if (est)
+                    next.set(key, est);
+            }
+            this.capacityEstimates = next;
+            return next.size;
+        }
+        catch (err) {
+            this.logger.debug({ err }, "capacity estimate refresh failed");
+            return -1;
+        }
+    }
+    /** One background quota read, when nothing else reads (no Discord bot) and an account has a running agent. */
+    async backgroundQuotaRead() {
+        if (this.shuttingDown)
+            return false;
+        if ([...this.adapters.values()].some(a => a.type === "discord" && typeof a.setActivity === "function"))
+            return false;
+        const active = this.getActiveUsageProviderIds();
+        if (active.size === 0)
+            return false;
+        try {
+            await getUsageSnapshot(false, active);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /** Keep Discord profile activity aligned with the same cached usage source as /usage. */
     startDiscordUsagePresence() {
         if (this.discordPresenceTimer)
@@ -10334,8 +11359,8 @@ export class FleetManager {
      *                 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.
@@ -10368,10 +11393,20 @@ export class FleetManager {
             if (effectiveStatus === "connected")
                 connected++;
         }
-        const problems = [];
+        const problems = [], warnings = [];
+        const rawHub = this.rawFleetConfig?.hub;
+        const hub = rawHub?.enabled === true ? { server: this.shuttingDown ? "stopped"
+                : this.hubRuntime?.serverHealth?.(rawHub) ?? "unavailable" } : undefined;
+        const hubOnly = !!hub && names.length === 0 && this.adapterState.size === 0;
+        if (hub && hub.server !== "ready")
+            problems.push(`Hub server is ${hub.server}`);
         const hostMemory = this.memoryPressure.snapshot();
-        if (!this.memoryPressure.advisoryOnly() && (hostMemory.level === "critical" || hostMemory.level === "elevated")) {
-            problems.push(`host memory pressure is ${hostMemory.level}`);
+        if (hostMemory.level === "critical" || hostMemory.level === "elevated") {
+            const pressure = `host memory pressure is ${hostMemory.level}`;
+            if (hubOnly)
+                warnings.push(pressure);
+            else if (!this.memoryPressure.advisoryOnly())
+                problems.push(pressure);
         }
         if (this.adapterState.size > 0 && connected === 0)
             problems.push("no channel adapter is connected");
@@ -10383,9 +11418,8 @@ export class FleetManager {
         }
         if (!this.startupComplete)
             problems.push("startup has not completed");
-        // "down" is reserved for "cannot receive or answer a message at all". A fleet
-        // with adapters configured but none connected is exactly that.
-        const status = this.adapterState.size > 0 && connected === 0
+        // Preserve adapter scoring. A dedicated Hub also cannot serve its workload before its server mount is ready.
+        const status = (this.adapterState.size > 0 && connected === 0) || (hubOnly && hub?.server !== "ready")
             ? "down"
             : problems.length > 0 ? "degraded" : "ok";
         return {
@@ -10397,7 +11431,7 @@ export class FleetManager {
             memory: readFleetMemory(),
             hostMemory: this.memoryTop && (hostMemory.level === "elevated" || hostMemory.level === "critical")
                 ? { ...hostMemory, topProcesses: this.memoryTop.processes, topProcessesAt: this.memoryTop.at } : hostMemory,
-            problems,
+            problems, warnings, ...(hub ? { hub } : {}),
         };
     }
     /** Start the primary adapter (backward-compatible, sets this.adapter) */
@@ -10472,6 +11506,11 @@ export class FleetManager {
         adapter.on("callback_query", safeHandler(async (data) => {
             await this.receiveAdapterCallback(data, adapterId, adapter, isCurrentAdapter);
         }, this.logger, "adapter.callback_query"));
+        adapter.on("missed_offline", (ev) => {
+            if (!isCurrentAdapter())
+                return;
+            this.recordMissedOffline(ev);
+        });
         this.bindTopicClosedHandler(adapter, adapterId, "adapter.topic_closed");
         // Handle classic bot slash commands (/start, /stop, /chat, /compact, /save, /load)
         adapter.on("slash_command", safeHandler(async (data) => {
@@ -10625,6 +11664,11 @@ export class FleetManager {
         adapter.on("callback_query", safeHandler(async (data) => {
             await this.receiveAdapterCallback(data, adapterId, adapter, isCurrentAdapter);
         }, this.logger, `adapter[${adapterId}].callback_query`));
+        adapter.on("missed_offline", (ev) => {
+            if (!isCurrentAdapter())
+                return;
+            this.recordMissedOffline(ev);
+        });
         this.bindTopicClosedHandler(adapter, adapterId, `adapter[${adapterId}].topic_closed`);
         // Slash commands: classic bot + admin commands
         adapter.on("slash_command", safeHandler(async (data) => {
@@ -10784,6 +11828,9 @@ export class FleetManager {
                     this.eventLog?.insert(targetInstance, "cross_instance_delivery_failed", {
                         from: senderSession, correlation_id: correlationId, error,
                     });
+                    // A Hub question the pane never took: the representative holds it uncertain (never resent).
+                    if (senderSession === HUB_REPORT_TARGET && !senderInstance)
+                        this.hubDeliveryFailed?.(correlationId, targetInstance);
                     if (senderInstance) {
                         this.notifyInstanceTopic(senderInstance, t("cross_instance.delivery_failed_notice", targetInstance, displayError, correlationId));
                         void this.deliverToInstance(senderInstance, {
@@ -10902,13 +11949,12 @@ export class FleetManager {
                         try {
                             const { execFile } = await import("./child-process.js");
                             const { promisify } = await import("node:util");
-                            const { getTmuxSocketName } = await import("./paths.js");
+                            const { tmuxArgs, tmuxBinary, tmuxEnvOption } = await import("./tmux-binary.js");
                             // Honour socket isolation: without -L this queried the user's default
                             // tmux server instead of the fleet's, so under a custom AGEND_HOME the
                             // check was meaningless (it reported every pane dead).
-                            const socket = getTmuxSocketName();
-                            const args = socket ? ["-L", socket, "list-panes", "-t", windowId] : ["list-panes", "-t", windowId];
-                            await promisify(execFile)("tmux", args, { timeout: 5_000 });
+                            const args = tmuxArgs(["list-panes", "-t", windowId]);
+                            await promisify(execFile)(tmuxBinary(), args, { timeout: 5_000, ...tmuxEnvOption() });
                         }
                         catch {
                             // Pane dead — respawn
@@ -11365,6 +12411,34 @@ export class FleetManager {
         }
         return true;
     }
+    /** File a Telegram update that was too old to inject; Needs you lists it until Acknowledge. */
+    recordMissedOffline(ev) {
+        if (!this.missedOfflineStore)
+            this.missedOfflineStore = new MissedOfflineStore(this.dataDir);
+        const stub = {
+            source: "telegram", adapterId: ev.adapterId, chatId: ev.chatId, threadId: ev.threadId,
+            messageId: ev.messageId, userId: ev.userId, username: ev.username, text: ev.preview,
+            timestamp: ev.timestamp, isBotMessage: false,
+        };
+        const threadId = this.inboundRouteThreadId(stub);
+        const target = threadId ? this.resolveInboundTarget(stub, threadId) : undefined;
+        let instance = target?.name ?? "";
+        if (!instance) {
+            instance = Object.entries(this.fleetConfig?.instances ?? {}).find(([name, cfg]) => cfg.general_topic && this.getInstanceAdapterId(name) === ev.adapterId)?.[0] ?? "";
+        }
+        const place = [ev.chatTitle, ev.threadId ? `#${ev.threadId}` : ""].filter(Boolean).join(" · ") || ev.chatId;
+        this.missedOfflineStore.add({
+            id: `missed:${ev.adapterId}:${ev.updateId}`,
+            adapterId: ev.adapterId,
+            instance,
+            username: ev.username,
+            place,
+            preview: ev.preview,
+            since: ev.timestamp.getTime(),
+        });
+        this.logger.info({ adapterId: ev.adapterId, updateId: ev.updateId, instance, chatId: ev.chatId, threadId: ev.threadId }, "Telegram message missed while AgEnD was offline — filed for Needs you");
+        this.needsYou?.poke();
+    }
     /**
      * #1085: coincident topic numbers must not route across Telegram groups.
      */
@@ -13001,6 +14075,11 @@ export class FleetManager {
             let result;
             switch (msg.type) {
                 case "fleet_decision_create": {
+                    const supersedes = this.decisionSupersedes("ipc-typed", instanceName, payload.supersedes);
+                    if ("error" in supersedes) {
+                        ipc.send({ type: "fleet_decision_response", fleetRequestId, error: supersedes.error });
+                        return;
+                    }
                     // Prune expired decisions on create
                     db.pruneExpiredDecisions();
                     result = db.createDecision({
@@ -13011,7 +14090,7 @@ export class FleetManager {
                         tags: payload.tags,
                         ttl_days: payload.ttl_days,
                         created_by: instanceName,
-                        supersedes: payload.supersedes,
+                        supersedes: supersedes.id,
                     });
                     break;
                 }
@@ -13188,6 +14267,21 @@ export class FleetManager {
                 return "ok";
         }
     }
+    /**
+     * `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.
+     */
+    decisionSupersedes(sink, instanceName, value) {
+        if (value === undefined || value === null || value === "")
+            return { id: undefined };
+        if (typeof value !== "string")
+            return { error: "supersedes must be a decision id" };
+        const permitted = this.checkToolPermission(sink, instanceName, "update_decision");
+        if (!permitted.allowed)
+            return { error: `Superseding a decision needs update_decision. ${permitted.message}` };
+        return { id: value };
+    }
     async handleDecisionCrudHttp(instance, op, args) {
         if (!this.scheduler)
             return { error: "Scheduler not available" };
@@ -13203,16 +14297,24 @@ export class FleetManager {
                 if (!title || !content)
                     return { error: "title and content are required" };
                 const scope = args.scope === "fleet" ? "fleet" : "project";
-                return db.createDecision({
-                    project_root: projectRoot,
-                    scope,
-                    title,
-                    content,
-                    tags: asStrArr(args.tags),
-                    ttl_days: asNum(args.ttl_days),
-                    supersedes: asStr(args.supersedes),
-                    created_by: instance,
-                });
+                const supersedes = this.decisionSupersedes("agent-endpoint", instance, args.supersedes);
+                if ("error" in supersedes)
+                    return { error: supersedes.error };
+                try {
+                    return db.createDecision({
+                        project_root: projectRoot,
+                        scope,
+                        title,
+                        content,
+                        tags: asStrArr(args.tags),
+                        ttl_days: asNum(args.ttl_days),
+                        supersedes: supersedes.id,
+                        created_by: instance,
+                    });
+                }
+                catch (err) {
+                    return { error: err.message }; // a refused predecessor: nothing was inserted
+                }
             }
             // #2152: titles by default (agend-agent decision-list); one decision's full text by id (decision-get <id>).
             // The CLI sends include_archived (snake case, as the MCP tool): both spellings are read.
@@ -13255,6 +14357,8 @@ export class FleetManager {
         const asStatusFilter = normalizeStatusFilter;
         // #1336: small write ack — identifying fields only.
         const ack = (t) => ({ id: t.id, status: t.status, updated_at: t.updated_at });
+        // #3195: an update's ack also carries what was SAVED for each field it named, read back from the task.
+        const updatedAck = (t, named) => ({ ...ack(t), ...savedFields(t, named) });
         // The board's notes for the write (a send-back reason, a comment the assignee had not seen): with the ack when any.
         const noted = (a) => { const notes = db.board.takeNotes(); return notes.length ? { ...a, notes } : a; };
         try {
@@ -13312,12 +14416,12 @@ export class FleetManager {
                     const id = asStr(args.id);
                     if (!id)
                         return { error: "id is required" };
-                    return noted(ack(db.updateTask(db.getTaskByPrefix(id).id, {
+                    return noted(updatedAck(db.updateTask(db.getTaskByPrefix(id).id, {
                         status: asStatus(args.status),
                         assignee: asStr(args.assignee),
                         result: asStr(args.result),
                         priority: asPriority(args.priority),
-                    }, { kind: "instance", name: instance })));
+                    }, { kind: "instance", name: instance }), args));
                 }
                 default: return { error: `Unknown task action: ${action}` };
             }
@@ -13471,7 +14575,8 @@ export class FleetManager {
                         result: payload.result,
                         priority: payload.priority,
                     }, { kind: "instance", name: meta.instance_name || instanceName });
-                    result = noted(ack(logTask));
+                    // #3195: with what was SAVED for each field the update named, read back from the task.
+                    result = noted({ ...ack(logTask), ...savedFields(logTask, payload) });
                     break;
                 default:
                     throw new Error(`Unknown task action: ${action}`);
@@ -13501,16 +14606,101 @@ export class FleetManager {
         }
         return adapter.createTopic(topicName);
     }
-    async deleteForumTopic(topicId, adapterId) {
-        try {
-            const adapter = (adapterId ? this.worlds.get(adapterId)?.adapter : undefined) ?? this.adapter;
-            if (!adapter?.deleteTopic)
-                return;
-            await adapter.deleteTopic(topicId);
-        }
-        catch (err) {
-            this.logger.warn({ err, topicId }, "Failed to delete forum topic during rollback");
-        }
+    /**
+     * 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.
+     */
+    async removeInstanceAndTopic(name, authorization, opts) {
+        const plan = opts.deleteTopic ? this.planInstanceTopicDelete(name) : null;
+        if (opts.execution)
+            await this.removeInstance(name, authorization, opts.execution);
+        else
+            await this.removeInstance(name, authorization);
+        // #3055 review (Prism P1): asked again right before the platform call — the fleet as it is NOW, not as planned
+        // before the removal was awaited (a new owner of the topic, or the bot rebuilt).
+        return deletePlannedTopic(plan, this.logger, (p) => {
+            if (this.instanceTopicAdapter(p.adapterId) !== p.adapter)
+                return "the agent's bot changed while it was being deleted, so its topic was left";
+            return topicMustStay(p.destination, this.topicOwnership(), null); // the original is gone: every owner now counts
+        }, { begin: (d) => this.topicDeletionsInFlight.add(d), end: (d) => this.topicDeletionsInFlight.delete(d) });
+    }
+    /** #3055: destinations whose platform deletion is running now; a binding to one waits until it is over. */
+    topicDeletionsInFlight = new Set();
+    /** True while a topic with this id is being deleted on any connection (a new binding of it is refused meanwhile). */
+    isTopicDeletionInFlight(topicId) {
+        const tail = `:${topicId}`;
+        return [...this.topicDeletionsInFlight].some(d => d.endsWith(tail));
+    }
+    /**
+     * #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) {
+        if (this.topicDeletionsInFlight.size === 0 || inst.topic_id == null || inst.topic_id === "")
+            return false;
+        const adapterId = typeof inst.channel_id === "string" && inst.channel_id ? inst.channel_id : this.getPrimaryAdapterId();
+        return this.topicDeletionsInFlight.has(this.destinationFor(adapterId, inst.topic_id));
+    }
+    /** Any topic deletion running now (a connection's group or General may not be re-pointed meanwhile). */
+    topicDeletionPending() { return this.topicDeletionsInFlight.size > 0; }
+    /** The physical destination of `topicId` on the bot `adapterId`. */
+    destinationFor(adapterId, topicId) {
+        const world = adapterId ? this.worlds.get(adapterId) : undefined;
+        const platform = world?.adapter?.type ?? this.getChannelConfig(adapterId)?.type;
+        const groupId = world?.groupId ?? String(this.getChannelConfig(adapterId)?.group_id ?? "");
+        return topicDestination(platform, groupId, adapterId, topicId);
+    }
+    /** The adapter of the bot `adapterId` names — never a substitute for a bot that is not there. */
+    instanceTopicAdapter(adapterId) {
+        return (adapterId ? this.worlds.get(adapterId)?.adapter : this.worlds.size === 0 ? this.adapter ?? undefined : undefined) ?? undefined;
+    }
+    /**
+     * 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.
+     */
+    topicOwnership() {
+        const channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
+        const destinationOf = (n) => {
+            const cfg = this.fleetConfig?.instances?.[n];
+            if (!cfg || cfg.topic_id == null || cfg.topic_id === "")
+                return null;
+            return this.destinationFor(this.topicAdapterIdOf(n), cfg.topic_id);
+        };
+        const generalDestinations = () => {
+            const out = new Set();
+            for (const ch of channels) {
+                const id = ch.id ?? ch.type;
+                const groupId = this.worlds.get(id)?.groupId ?? (ch.group_id != null ? String(ch.group_id) : undefined);
+                if (ch.type === "telegram")
+                    out.add(topicDestination("telegram", groupId, id, 1));
+                if (ch.type === "discord") {
+                    const gcid = discordGeneralChannelId(ch);
+                    if (gcid)
+                        out.add(topicDestination("discord", groupId, id, gcid));
+                }
+            }
+            return out;
+        };
+        return { instances: this.fleetConfig?.instances, destinationOf, generalDestinations };
+    }
+    /**
+     * 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.
+     */
+    topicAdapterIdOf(name) {
+        const cfg = this.fleetConfig?.instances?.[name];
+        if (cfg)
+            return cfg.channel_id ?? this.getPrimaryAdapterId();
+        return this.getInstanceAdapterId(name);
+    }
+    /** What deleting `name`'s topic would act on: its own bot only — a bot that is not there is never substituted. */
+    planInstanceTopicDelete(name) {
+        const adapterId = this.topicAdapterIdOf(name);
+        return planInstanceTopicDelete({ name, adapterId, adapter: this.instanceTopicAdapter(adapterId), ...this.topicOwnership() });
     }
     getForumTopicDeleter(adapterId) {
         const adapter = (adapterId ? this.worlds.get(adapterId)?.adapter : undefined) ?? this.adapter;
@@ -13789,6 +14979,8 @@ export class FleetManager {
         this.observeWebAuthority(); // #2453 review: so is a web-authority switch (off is always seen)
         if (!this.fleetConfig || !this.configPath)
             return;
+        // #3147 r2: a changed or removed Hub representative's consent is invalidated durably BEFORE the change is written.
+        this.observeHubAgentIncarnations(true);
         if (!this.savedFleetConfigSnapshot)
             this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
         normalizeNoticeDelivery(this.fleetConfig);
@@ -13911,9 +15103,12 @@ export class FleetManager {
             Object.assign(current, resolved);
         }
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
+        this.nativeMcpStore?.observePolicies();
+        this.agentCredentialsCache?.observePolicies();
         this.refreshSavedDashboardPermissions();
         this.logger.info({ path: this.configPath, strippedDefaults: redundantPaths.length }, "Saved fleet config (lossless patch)");
         this.observeRuntimeSwitches(); // M-2255: a saved Windows runtime switch applies now
+        this.observeHubSwitches(); // S-51: so does a saved Hub switch
     }
     /** A permission tightening is effective when its save returns, independently of the later apply job or IPC. */
     refreshSavedDashboardPermissions() {
@@ -14223,6 +15418,7 @@ export class FleetManager {
         const instanceDirToClean = this.getInstanceDir(name);
         // #1774: replies sent from here on are a later instance's (a replacement registered while this one goes); the ones
         // sent before wait for the outcome before they are shown.
+        this.forgetHubAgentIncarnation(name, true); // #3147: a re-added instance never inherits Hub consent; not durable → refused
         const removedBelow = this.webChatGeneration(name) + 1, removedDaemon = this.daemons.get(name);
         this.webChatGenerations.set(name, removedBelow);
         let settleRemoval;
@@ -16207,6 +17403,11 @@ export class FleetManager {
     needsYouItems() {
         return this.needsYou?.webItems() ?? [];
     }
+    /** Enabled member composition supplies only a local attention reader, never an approval/execution callback. */
+    attachHubExecutionAttention(read) {
+        this.hubExecutionAttention = read;
+        this.needsYou?.poke();
+    }
     /**
      * #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.
@@ -16270,6 +17471,7 @@ export class FleetManager {
         const fleet = Object.entries(this.fleetConfig?.instances ?? {}).filter(([, cfg]) => !isWindowsInstance(cfg)).map(([name, cfg]) => ({
             name, backend: this.backendNameOf(name), workingDirectory: cfg.working_directory, ledgerPath: join(this.getInstanceDir(name), "cache-ledger.json"),
             claudeConfigDir: this.claudeConfigDirOf(name), profile: this.usageProfileOf(name, this.backendNameOf(name)),
+            ...(this.backendNameOf(name) === "codex" ? { profileTimelinePath: join(this.getInstanceDir(name), PROFILE_TIMELINE_FILE) } : {}),
             kiroDbPath: this.kiroDbPathOf(name, this.backendNameOf(name)),
         }));
         const taken = new Set(fleet.map(i => i.name));
@@ -16281,6 +17483,9 @@ export class FleetManager {
             claudeConfigDir: this.claudeConfigDirOf(ch.instanceName),
             profile: this.usageProfileOf(ch.instanceName, this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code"),
             kiroDbPath: this.kiroDbPathOf(ch.instanceName, this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code"),
+            // #3066 §1d (Fable r1 #2): a ClassicBot Codex room records its launches too (onDaemonReady) — read them the same way.
+            ...((this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend) === "codex"
+                ? { profileTimelinePath: join(this.getInstanceDir(ch.instanceName), PROFILE_TIMELINE_FILE) } : {}),
         }));
         return [...fleet, ...new Map(classic.map(c => [c.name, c])).values()];
     }
@@ -16441,7 +17646,8 @@ export class FleetManager {
             out.push({
                 name, state: p.state ?? undefined,
                 interaction: p.interaction ? { kind: p.interaction.kind, owner: wait?.owner ?? null, episode: p.interaction.episode, since: p.interaction.since } : null,
-                interactionSummary: p.interaction_summary ?? null,
+                interactionSummary: p.interaction?.kind === "kiro_choice" ? t("kiro3.running") : p.interaction_summary ?? null,
+                kiroCompatibility: this.kiroCompatibilityHolds?.get(name),
                 pauseReason, pausedAt,
                 crashedAt: crashed ? (this.needsCrashedAt.get(name) ?? null) : null,
                 signIn: pauseReason === "auth" ? this.signInFor(name) : null,
@@ -16533,8 +17739,18 @@ export class FleetManager {
                     throw new Error("the delivery outbox is not open");
                 return this.deliveryOutbox.acknowledge(deliveryId, by);
             },
+            missedOffline: () => (this.missedOfflineStore?.list(Date.now()) ?? []).map(m => ({
+                id: m.id, instance: m.instance, owner: m.adapterId, username: m.username, place: m.place, preview: m.preview, since: m.since,
+            })),
+            acknowledgeMissed: (id, by) => this.missedOfflineStore?.acknowledge(id, by) ?? false,
             tasks: () => this.needsYouTaskItems(),
             backendSignIns: () => this.needsYouBackendSignIns(),
+            hubExecution: () => this.hubExecutionAttention?.() ?? [],
+            hubHolds: () => this.hubHolds.map(h => {
+                // A provider hold carries a bounded setup reason; its guidance (S4b's copy) when present, else the code's text.
+                const guidance = h.reason ? t(`hub.provider.${h.reason}`) : "";
+                return { side: h.side, code: h.code, since: h.since, detail: guidance && guidance !== `hub.provider.${h.reason}` ? guidance : t(`hub.hold.${h.code}`) };
+            }),
             configIssues: () => (this.configHistory?.currentIssues() ?? []).map(issue => ({
                 ...issue, detail: configIssueText(issue, t), owner: this.worlds.keys().next().value,
             })),
@@ -17268,7 +18484,12 @@ export class FleetManager {
             if (this.shuttingDown || !this.outsideOn() || this.outsideOpening)
                 return;
             this.outsideOpening = true;
-            void this.getPublicWebLink().openUnattended(OUTSIDE_LINK_OWNER).catch(() => "failed").then(outcome => {
+            // alpha CI 4abe58cd: an On right after an Off finds the old link still closing (its tunnel stopping): wait for that
+            // close, then open — never "busy" and a 30 s retry. The switch is asked again after the wait by openUnattended
+            // itself (permitted → publicOwnerCurrent: the fleet running, the switch on): an Off meanwhile opens nothing.
+            const link = this.getPublicWebLink();
+            void link.whenClosed().then(() => link.openUnattended(OUTSIDE_LINK_OWNER))
+                .catch(() => "failed").then(outcome => {
                 this.outsideOpening = false;
                 if (outcome === "opened") {
                     this.logger.info({ attempt: n + 1 }, "Outside link opened");
@@ -17446,7 +18667,7 @@ export class FleetManager {
             // Over a link: the temporary one (§0.3), else the named one (a record from before §0.3 has no peer).
             ...(sessions.get(a.handle).surface === "gateway" ? (a.peer === "quick_link" ? { quick: true } : { named: true }) : {}) })) : [];
         const host = this.fleetConfig?.web?.public_link?.hostname;
-        return { state, configured, hours: VERIFIED_SESSION_HOURS, lanHosts, authorized, namedHost: typeof host === "string" && host ? host : null };
+        return { state, configured, hours: VERIFIED_SESSION_HOURS, lanHosts, authorized, namedHost: typeof host === "string" && host ? host : null, webOnly: this.isWebOnlyFleet() };
     }
     authorizationRequests = null;
     /**
@@ -17509,8 +18730,9 @@ export class FleetManager {
                 return r.ok ? { ok: true, until: Math.min(r.authorization.until, record.absoluteExpiry) } : { ok: false, refusal: r.refusal };
             },
             signOut: (handle) => {
-                this.webSessions?.revokeByHandle(handle);
-                this.sessionAuthorizationStore()?.prune(a => a.handle !== handle);
+                const session = this.webSessions?.revokeByHandle(handle) ?? { found: false, durable: true };
+                const authorization = this.sessionAuthorizationStore()?.prune(a => a.handle !== handle) ?? { dropped: 0, durable: true };
+                return { durable: session.durable, authorizationDurable: authorization.durable };
             },
             event: (type, payload) => { try {
                 this.eventLog?.insert("web", type, payload);
@@ -17523,6 +18745,7 @@ export class FleetManager {
                 expired: (c) => t("web_auth.card_expired", c.label),
                 refused: (c) => t("web_auth.card_refused", c.label, t(`web_auth.refusal_${c.refusal}`)),
                 revoked: (c) => t("web_auth.card_revoked", c.label),
+                notSaved: (c) => t("web_auth.card_not_saved", c.label),
                 ended: (c) => t("web_auth.card_ended", c.label),
                 generalHint: () => t("web_auth.general_hint"),
                 confirmLabel: () => t("web_auth.confirm"),
@@ -18445,7 +19668,14 @@ export class FleetManager {
             return;
         }
         const publication = this.beginCancelButtonPublication(instanceName, correlationId);
-        const initialProgressText = FleetManager.progressText(0, null, 1, this.progressPrefixFor(instanceName, 0, 1));
+        // M-2391: a re-post below a reply (preserveProgress) continues the same turn — its elapsed time continues from
+        // the live bubble's start, as its tool list does. Restarting it at 0 meant an agent replying more often than the
+        // threshold never showed elapsed time at all. A fresh turn (no preserve) starts at 0 as before.
+        const carriedStart = preserveProgress ? this.liveButtonStart(instanceName) : undefined;
+        const carriedMs = carriedStart !== undefined ? Math.max(0, Date.now() - carriedStart) : 0;
+        const initialProgressText = carriedStart !== undefined && carriedMs >= this.progressMinElapsedMs()
+            ? FleetManager.progressText(carriedMs, null, this.progressMinElapsedMs(), this.progressPrefixFor(instanceName, carriedMs))
+            : FleetManager.progressText(0, null, 1, this.progressPrefixFor(instanceName, 0, 1));
         try {
             const sent = await adapter.notifyAlert(chatId, {
                 type: "cancel",
@@ -18468,7 +19698,7 @@ export class FleetManager {
                 // Elapsed time is measured from when this button was posted — i.e. from
                 // when the work was handed over — not from the pane's working transition,
                 // which resets if the CLI blips idle mid-turn.
-                startedAt: Date.now(),
+                startedAt: carriedStart ?? Date.now(),
                 // Matches the text notifyAlert just posted, so the first 60s tick does
                 // not re-edit identical text — which put a "(edited)" mark on Discord
                 // with nothing visibly changed.
@@ -18591,14 +19821,16 @@ export class FleetManager {
      * 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.
      */
     static sanitizeActivity(activity) {
         if (!activity)
             return null;
-        const flat = activity.replace(/\s+/g, " ").replace(/@(everyone|here)/g, "@​$1").trim();
+        const flat = maskSecrets(activity.replace(/\s+/g, " ")).replace(/@(everyone|here)/g, "@​$1").trim();
         if (!flat)
             return null;
         return flat.length > PROGRESS_ACTIVITY_MAX_CHARS
@@ -18717,6 +19949,12 @@ export class FleetManager {
         }
         return PROGRESS_MIN_ELAPSED_MS;
     }
+    /** M-2391: when the instance's live (not retiring) bubble started — the current turn's start — or undefined. */
+    liveButtonStart(instanceName) {
+        const starts = [...this.cancelButtons.values()].filter((e) => e.instanceName === instanceName && !e.retiring && typeof e.startedAt === "number")
+            .map((e) => e.startedAt);
+        return starts.length ? Math.min(...starts) : undefined;
+    }
     startProgressTicker(entry) {
         const tick = () => this.refreshBubble(entry);
         entry.progressTimer = setInterval(tick, PROGRESS_UPDATE_INTERVAL_MS);
@@ -18726,7 +19964,9 @@ export class FleetManager {
         // one additional edit per turn that lives past the threshold.
         const firstAt = this.progressMinElapsedMs() - (Date.now() - (entry.startedAt ?? Date.now()));
         if (firstAt > 0 && firstAt < PROGRESS_UPDATE_INTERVAL_MS) {
-            const firstTick = setTimeout(tick, firstAt);
+            // M-2391: a little past the threshold — a timer can fire a millisecond before Date.now() reaches it, which
+            // rendered the unchanged "處理中…" text and skipped the edit until the next 60 s interval.
+            const firstTick = setTimeout(tick, firstAt + PROGRESS_THRESHOLD_MARGIN_MS);
             firstTick.unref?.();
         }
     }
@@ -19065,6 +20305,8 @@ export class FleetManager {
                 }
                 catch { /* safe metadata only */ }
                 broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed"));
+                if (event.phase === "done")
+                    this.forgetSignInIdentities(); // a sign-in may be a different account now
                 this.needsYou?.poke();
                 if (!this.browserSignInOwnerCurrent(owner))
                     return;
@@ -19103,7 +20345,10 @@ export class FleetManager {
             cancel: () => this.cancelLoginSession(),
             notice: ({ shown, label, handle }) => this.notifyFleetError(t("login.web_dashboard_notice", shown, label, handle.slice(0, 8))),
             // No details in the event: each page reads its own view (GET /ui/backend-login), as its session may see it.
-            changed: () => broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed")),
+            // The accounts are forgotten when ANY sign-in ends, even one a later one replaced (it may be a different account now), and not at every step of a
+            // running one: `changed` only tells the pages to read again.
+            changed: () => { broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed")); },
+            loginEnded: () => this.forgetSignInIdentities(),
         });
         return this.webBackendLoginsInstance;
     }
@@ -19117,6 +20362,135 @@ export class FleetManager {
      * #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. */
+    signInIdentities = new Map();
+    /** 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. */
+    signInIdentityReads = new Map();
+    /** Raised each time the accounts are forgotten: a read that began before is never allowed to write what it found. */
+    signInIdentityGeneration = 0;
+    signInIdentitySlots = 0;
+    signInIdentityWaiters = [];
+    signInIdentity(backend, profile) { return this.signInIdentities.get(`${backend}\0${profile ?? ""}`)?.identity ?? undefined; }
+    /** A sign-in finished (or changed): forget what was read and let no read that was already running put its answer back. */
+    forgetSignInIdentities() { this.signInIdentityGeneration++; this.signInIdentities.clear(); this.signInIdentityReads.clear(); }
+    /** At most three `claude auth status` at once across the whole host, however many requests ask. */
+    async withSignInIdentitySlot(task) {
+        while (this.signInIdentitySlots >= 3)
+            await new Promise(resolve => this.signInIdentityWaiters.push(resolve));
+        this.signInIdentitySlots++;
+        try {
+            return await task();
+        }
+        finally {
+            this.signInIdentitySlots--;
+            this.signInIdentityWaiters.shift()?.();
+        }
+    }
+    /** One `claude auth status` for a sign-in (the default one, or a credential profile's folder). */
+    async readSignInIdentity(target) {
+        let env;
+        if (target.profile)
+            env = credentialProfileEnv(this.dataDir, target.backend, target.profile) ?? undefined;
+        return checkAuthIdentity(target.backend, env);
+    }
+    /**
+     * 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() {
+        const now = Date.now(), fresh = (target) => { const entry = this.signInIdentities.get(`${target.backend}\0${target.profile ?? ""}`); return !!entry && now - entry.at < 5 * 60_000; };
+        const started = [];
+        for (const target of this.backendSignInTargets()) {
+            const key = `${target.backend}\0${target.profile ?? ""}`;
+            if (target.state !== "usable" || !authIdentitySupported(target.backend) || fresh(target) || this.signInIdentityReads.has(key))
+                continue;
+            const generation = this.signInIdentityGeneration;
+            const read = this.withSignInIdentitySlot(() => this.readSignInIdentity(target)).then(identity => {
+                if (generation !== this.signInIdentityGeneration)
+                    return false; // forgotten while it ran: its answer may be the old account
+                this.signInIdentities.set(key, { identity: identity ?? null, at: Date.now() });
+                return true;
+            }).catch(() => {
+                // A read that threw is an answer too: remembered as "no account" for the same five minutes, so every GET does not try again.
+                if (generation === this.signInIdentityGeneration)
+                    this.signInIdentities.set(key, { identity: null, at: Date.now() });
+                return false;
+            }).finally(() => { if (this.signInIdentityReads.get(key) === read)
+                this.signInIdentityReads.delete(key); });
+            this.signInIdentityReads.set(key, read);
+            started.push(read);
+        }
+        if (started.length)
+            void Promise.all(started).then(results => {
+                if (results.some(Boolean))
+                    broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed")); // read the list again: it knows more now
+            });
+    }
+    /**
+     * #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.
+     */
+    async accountsView(usageWaitMs = 1500) {
+        const fleet = this.fleetConfig;
+        const defaultBackend = fleet?.defaults?.backend ?? "claude-code";
+        this.refreshSignInIdentities();
+        const targets = this.backendSignInTargets();
+        const diskProfiles = new Map();
+        for (const backend of PROFILE_CLIS) {
+            const rows = [];
+            for (const profile of profilesOnDisk(this.dataDir, backend)) {
+                let login = "unknown";
+                try {
+                    login = credentialProfileLogin(this.dataDir, backend, profile).state;
+                }
+                catch { /* unknown */ }
+                const signIn = dashboardSignInSupported(backend, profile);
+                const hostCommand = signIn ? null : credentialProfileLoginCommand(this.dataDir, backend, profile);
+                const identity = this.signInIdentity(backend, profile);
+                rows.push({ profile, state: (login === "logged-in" ? "usable" : login === "signed-out" ? "not_signed_in" : "unknown"), signIn,
+                    ...(hostCommand ? { hostCommand } : {}), ...(identity ? { identity } : {}) });
+            }
+            diskProfiles.set(backend, rows);
+        }
+        // Host agents only: an agent on a paired Windows computer runs on that computer's accounts (its own scope, later).
+        const agents = Object.keys(fleet?.instances ?? {}).filter(name => !isWindowsInstance(fleet.instances[name])).sort()
+            .map(name => { const backend = this.backendNameForInstance(name); return { name, backend, profile: this.credentialProfileOf(name, backend) }; });
+        const classic = readClassicBindings(this.dataDir).map(b => {
+            const backend = b.backend ?? defaultBackend;
+            return { key: b.key, backend, profile: profileName(classicProfile(b.backend_options, fleet?.defaults?.backend_options, backend)) };
+        });
+        const fleetDefaults = new Map();
+        for (const backend of PROFILE_CLIS) {
+            const p = profileName(profileOf(fleet?.defaults?.backend_options, backend));
+            if (p)
+                fleetDefaults.set(backend, p);
+        }
+        // Weekly usage, from the usage panel's own (cached, never forced) read.
+        const usage = new Map();
+        const ids = new Map(); // provider id → backend\0profile
+        for (const backend of ACCOUNT_CLIS) {
+            const pid = usageProviderIdForBackend(backend);
+            if (!pid)
+                continue;
+            ids.set(pid, `${backend}\0`);
+            for (const p of new Set([...(diskProfiles.get(backend) ?? []).map(d => d.profile), ...targets.filter(t => t.backend === backend && t.profile).map(t => t.profile)]))
+                ids.set(`${pid}:${p}`, `${backend}\0${p}`);
+        }
+        try {
+            const payload = await Promise.race([getUsageSnapshot(false, undefined, { allowStale: true }), new Promise(r => { const tm = setTimeout(() => r(null), usageWaitMs); tm.unref?.(); })]);
+            for (const provider of payload?.providers ?? []) {
+                const at = ids.get(provider.id);
+                const w = at ? weeklyUsage(provider) : undefined;
+                if (at && w)
+                    usage.set(at, w);
+            }
+        }
+        catch { /* the view without usage */ }
+        return buildAccountsView({ targets, diskProfiles, agents, classic, fleetDefaults, usage });
+    }
     backendSignInTargets() {
         const out = [];
         for (const row of this.backendAvailabilityRows()) {
@@ -19128,6 +20502,7 @@ export class FleetManager {
                 ...(flow?.remoteLogin === "unsupported" ? { hostCommand: flow.command } : {}),
                 ...(row.state === "not_installed" && install ? { install } : {}),
                 ...(row.state === "too_old" && install ? { update: install } : {}),
+                ...(this.signInIdentity(row.backend) ? { identity: this.signInIdentity(row.backend) } : {}),
             });
         }
         const seen = new Set();
@@ -19145,7 +20520,7 @@ export class FleetManager {
             const signIn = dashboardSignInSupported(backend, profile);
             const hostCommand = signIn ? null : credentialProfileLoginCommand(this.dataDir, backend, profile);
             out.push({ backend, profile, state: login === "logged-in" ? "usable" : login === "signed-out" ? "not_signed_in" : "unknown", signIn,
-                ...(hostCommand ? { hostCommand } : {}) });
+                ...(hostCommand ? { hostCommand } : {}), ...(this.signInIdentity(backend, profile) ? { identity: this.signInIdentity(backend, profile) } : {}) });
         }
         return out;
     }
@@ -19664,9 +21039,12 @@ export class FleetManager {
             this.loginWindow.release(claim);
             return t("login.web_shutting_down");
         }
+        // The wrapper says its own exit code after this marker: tmux may never record it (unattended-install.ts).
+        const exitMarker = installExitMarker();
         const flow = {
             backend,
-            command: unattendedInstallCommand(info.unattended ?? info.install, shell),
+            command: unattendedInstallCommand(info.unattended ?? info.install, shell, exitMarker),
+            exitMarker,
             successPattern: /$^/,
             timeoutMs: this.installTimeoutMs,
         };
@@ -19967,6 +21345,8 @@ export class FleetManager {
             this.needsYou?.poke();
         const onError = (err) => this.logger.debug({ err }, "SSE client write failed; evicting");
         if (event === "message" && data && typeof data === "object") {
+            // #2861: an Office share's dialogue box hears that someone talked to an instance (never what was said).
+            this.officeTalk.noteMessage(data);
             // A chat message: record it, and send it WITH its id so a reconnecting stream can ask for what it missed.
             const m = data;
             const recorded = this.webChatHistory.record({
@@ -20011,9 +21391,12 @@ export class FleetManager {
         this.taskBoardWaker?.stop();
         // #2303: each instance's cards at once, read at every claim (a fleet.yaml edit applies to the next one).
         db.board.setCardLimit((name) => boardCardLimit(this.fleetConfig, name));
+        // An instance with the task board switched off is handed no cards and sent no notices (read at each write and wake).
+        db.board.setBoardOff((name) => taskBoardOffIn(this.fleetConfig, name));
         const waker = this.taskBoardWaker = new TaskBoardWaker({
             deliver: (instance, message, key) => this.admitTaskBoardNotice(instance, message, key),
             isInstance: (name) => this.fleetConfig?.instances?.[name] != null,
+            boardOff: (name) => taskBoardOffIn(this.fleetConfig, name),
             // #2785 (c), #2801: the maker's own message already told it; the board's line would repeat it.
             messagedAbout: (from, to, codes, sinceMs) => {
                 const outbox = this.deliveryOutbox;
@@ -23077,6 +24460,9 @@ export class FleetManager {
      * settles, so a later genuine stop (after a restart) still does the work.
      */
     stopAll() {
+        // S-51: no new Hub admission, dispatch or listener work from this tick on; doStopAll awaits the close.
+        this.hubEffectsReady = false;
+        this.hubRuntime?.fence();
         this.lifecycle.cancelNativeRecovery?.();
         this.nativeMcpStore?.closeAll();
         this.runtimeExecutor?.close();
@@ -23149,6 +24535,22 @@ export class FleetManager {
         // because we asked it to. Set synchronously — doStopAll runs to its first
         // await in the same tick as the signal handler, so no event can slip in.
         this.shuttingDown = true;
+        // Stop receive admission before the first await or any instance shutdown; outbound
+        // adapters remain available below to retire notices and pending prompts.
+        for (const state of this.adapterState.values()) {
+            if (state.retryTimer) {
+                clearTimeout(state.retryTimer);
+                state.retryTimer = undefined;
+            }
+        }
+        const inboundStopped = Promise.all([...this.adapters.values()].map(async (adapter) => {
+            try {
+                await adapter.stopReceiving?.();
+            }
+            catch (err) {
+                this.logger.warn({ adapterId: adapter.id, err }, "Adapter receive stop failed; inbound remains fenced");
+            }
+        }));
         this.workingRecovery?.reset();
         if (this.workingRecoveryTimer)
             clearInterval(this.workingRecoveryTimer);
@@ -23179,6 +24581,17 @@ export class FleetManager {
         // #1565: the web chat's last changes reach the disk (bounded: a slow disk does not hold the shutdown).
         const webChatStopped = this.webChatStore ? Promise.race([this.webChatStore.flush().catch(() => { }), new Promise(r => setTimeout(r, 3_000).unref?.())]) : Promise.resolve();
         const profileStopped = this.runtimeCpuProfiler?.shutdown("fleet shutdown");
+        // S-51: the Hub closes in the same drain, bounded so an unanswering listener does not hold the shutdown.
+        const hubInit = this.hubRuntimeInit, hubNow = this.hubRuntime;
+        this.hubRuntime = null;
+        this.hubRuntimeInit = null;
+        const hubClose = async () => {
+            const runtime = hubNow ?? (hubInit ? await hubInit.catch(() => null) : null);
+            await runtime?.close();
+        };
+        const hubStopped = hubNow || hubInit
+            ? Promise.race([hubClose().catch(err => this.logger.warn({ err: err?.message }, "Hub did not close cleanly")), new Promise(r => setTimeout(r, 10_000).unref?.())])
+            : Promise.resolve();
         this.ipcStoppingInstances.add("__fleet_stopping__");
         // Release held delivery promises before awaiting daemon shutdown, then
         // reject spawn work which has not started. Otherwise a storm backoff could
@@ -23209,9 +24622,11 @@ export class FleetManager {
         // A login/install window is a dedicated tmux server with its own TTL
         // timer and HTTP listener living in THIS process: without an explicit
         // shutdown it would outlive us as an owner-less login CLI (sol B3).
+        await inboundStopped;
         await publicStopped;
         await sharesStopped?.catch(() => { });
         await profileStopped;
+        await hubStopped;
         await needsStopped;
         await settingsControlStopped;
         await cacheStopped;
@@ -23219,13 +24634,6 @@ export class FleetManager {
         await this.cpuProfileControl?.close();
         this.cpuProfileControl = null;
         await this.shutdownLoginWindows();
-        // Cancel adapter retry timers
-        for (const state of this.adapterState.values()) {
-            if (state.retryTimer) {
-                clearTimeout(state.retryTimer);
-                state.retryTimer = undefined;
-            }
-        }
         this.clearStatuslineWatchers();
         this.costGuard?.stop();
         this.dailySummary?.stop();
@@ -23263,6 +24671,15 @@ export class FleetManager {
             clearInterval(this.discordPresenceTimer);
             this.discordPresenceTimer = null;
         }
+        if (this.quotaReadTimer) {
+            clearInterval(this.quotaReadTimer);
+            this.quotaReadTimer = null;
+        }
+        if (this.capacityTimer) {
+            clearInterval(this.capacityTimer);
+            this.capacityTimer = null;
+        }
+        setCapacityLookup(null);
         if (this.discordPresenceEagerTimer) {
             clearTimeout(this.discordPresenceEagerTimer);
             this.discordPresenceEagerTimer = null;
@@ -23549,6 +24966,7 @@ export class FleetManager {
             this.loadedFleetSource = previousSource;
             this.observeWebAuthority(); // #2453 review: the configuration back in force is the one seen
             this.observeRuntimeSwitches(); // M-2255: and the Windows runtimes' switches
+            this.observeHubSwitches(); // S-51: and the Hub's
             this.logger.error({
                 oldCount,
                 newCount,
@@ -23568,6 +24986,8 @@ export class FleetManager {
             // mark every row done and tell the user "changes applied".
             return { rejected: why };
         }
+        this.nativeMcpStore?.observePolicies();
+        this.agentCredentialsCache?.observePolicies();
         if (this.loadedFleetSource)
             this.getConfigHistory().accepted("fleet.yaml", this.configPath, this.loadedFleetSource);
         this.migrateOfficeStorage();
@@ -24468,6 +25888,9 @@ export class FleetManager {
     }
     async runConnectionBindingApply(job, binding, execution) {
         try {
+            // #3055 review r2: a connection is not re-pointed while one of its topics is being deleted (nothing is changed).
+            if (this.topicDeletionPending())
+                throw new Error("a topic deletion is running; try again in a moment");
             await this.rebuildAdapterForBinding(job.connectionId, binding, execution);
             job.result = "applied";
         }
@@ -25638,8 +27061,13 @@ export class FleetManager {
                 return;
             }
             const requestPath = new URL(req.url ?? "/", `http://localhost:${port}`).pathname;
+            const publicUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
             if (remoteRuntimeEnabled() && !gatewayRequestContext(req)
-                && this.runtimeCoordinator().handlePublicRequest(req, res, new URL(req.url ?? "/", `http://localhost:${port}`)))
+                && this.runtimeCoordinator().handlePublicRequest(req, res, publicUrl))
+                return;
+            // The read-only installer files (/runtime/install.ps1 and the bundle ZIP) grant nothing. They answer 404 while remote runtimes
+            // are off or on a public gateway link, and touch no other path.
+            if (this.runtimeInstaller().handle(req, res, publicUrl))
                 return;
             // Branding is public, after Host admission: automatic favicon requests
             // must not become noisy web-token 401s in the browser console.
@@ -25668,7 +27096,7 @@ export class FleetManager {
                         && String(req.headers.accept ?? "").includes("text/html")
                         && isWebPageNavigation(requestPath)) {
                         const link = gatewayRequestContext(req);
-                        serveSigninPage(res, 401, { webOnly: this.isWebOnlyFleet(), outside: !!link && this.isOutsideLink(link.exposureId) });
+                        serveSigninPage(res, 401, { webOnly: this.isWebOnlyFleet(), outside: !!link && this.isOutsideLink(link.exposureId), deviceLogin: !link && this.deviceLoginAvailable(), loginQr: this.loginQrEnabled() });
                         return;
                     }
                     res.writeHead(decision.status);
@@ -25840,6 +27268,7 @@ export class FleetManager {
                     res.end(JSON.stringify({
                         ...sysInfo,
                         version: this.currentVersion,
+                        build: gatewayRequestContext(req) ? undefined : this.currentBuild,
                         instances: enriched,
                         publicLink: this.getPublicWebStatus(),
                     }));
@@ -26337,6 +27766,8 @@ export class FleetManager {
                     })(),
                     capabilities: { chat: true, settings: true, pause: true, cancel: true, teams: true, schedules: true, delegation: true, mcp: true,
                         commands: true, effort: false, log: true, details: true, channels: false, terminal: false, attachments: false, usage: false, send_while_busy: true },
+                    // cc3ce4fe: the version this machine's inventory reports for the agent's CLI, and whether AgEnD has audited it.
+                    ...this.nativeCliStatus(nativeConfig.backend, nativeConfig.machine_id, this.daemons.get(name)),
                     ...(nativeConfig.machine_id ? { machine_id: nativeConfig.machine_id, machine_name: this.runtimeHub?.machine(nativeConfig.machine_id)?.name,
                         machine_status: this.runtimeHub?.machine(nativeConfig.machine_id)?.status ?? "offline" } : {}) } : {}),
                 display_name: identity.display_name || undefined,