@songsid/agend 2.3.5-alpha.4 → 2.3.5-beta.1

package/dist/fleet-manager.js

@@ -1,30 +1,22 @@
-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 { QuotaNotices } from "./usage/quota-notices.js";
+import { quotaNoticeRule } from "./quota-notice-config.js";
+import { onUsageSnapshot } from "./usage/usage-api.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 { prepareSettingsEffect } from "./settings-effect.js";
-import { settingsDisplay } from "./settings-change.js";
-import { SettingsConfirmationError, SettingsConfirmationStore, settingsSourceLabel } from "./settings-confirmation.js";
+import { SettingsConfirmationStore, settingsSourceLabel } from "./settings-confirmation.js";
 import { SettingsHttpConfirmation } from "./settings-http-confirmation.js";
 import { SettingsControlServer } from "./settings-control.js";
-import { SettingsRouteLifetime } from "./settings-route-lifetime.js";
-import { GeneralManagedFileError } from "./runtime-general-protocol.js";
-import { GeneralBindings, generalBindingRevision, parseGeneralSwitchInput, switchGeneralLocation } from "./general-binding.js";
-import { confirmGeneralHostExit } from "./general-host-owner.js";
-import { settingsFingerprint, SettingsExecution, settingsRevision, noteSettingsWrite, settingsFileResource, assertSettingsLease, trySettingsLease, waitSettingsLease, settingsUndo, undoSettingsPaths } from "./settings-transaction.js";
+import { SettingsExecution, settingsRevision, noteSettingsWrite, settingsFileResource, assertSettingsLease, trySettingsLease, waitSettingsLease, settingsUndo, undoSettingsPaths } from "./settings-transaction.js";
 import { performance } from "node:perf_hooks";
 import { withSpawnHoldReply } from "./spawn-hold-reply.js";
 import { gatewayRequestContext } from "./web-request-context.js";
@@ -39,7 +31,7 @@ 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";
@@ -54,7 +46,7 @@ import { ProfileControlServer } from "./profile-control.js";
 import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, realpathSync, lstatSync, closeSync } from "node:fs";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { freemem, totalmem, homedir, hostname } from "node:os";
+import { freemem, totalmem, homedir } from "node:os";
 import { effectiveCpuCount } from "./cpu-quota.js";
 import { createServer } from "node:http";
 import { Worker } from "node:worker_threads";
@@ -87,6 +79,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";
@@ -96,18 +89,17 @@ import { startEventLoopWatch } from "./event-loop-watch.js";
 import { TmuxManager } from "./tmux-manager.js";
 import { AccessManager } from "./channel/access-manager.js";
 import { IpcClient } from "./channel/ipc-bridge.js";
-import { NativeDaemonClient } from "./native-daemon-client.js";
-import { usesChannelAddress, TOOLS } from "./channel/mcp-tools.js";
+import { usesChannelAddress } from "./channel/mcp-tools.js";
 import { ParkedNotices, PARKED_NOTICE_LEDGER_FILE } from "./parked-notices.js";
 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";
 import { codexMetadataHomes, readCodexModelEffortLevels, resolveCodexLaunchModel } from "./backend/codex-metadata.js";
-import { readGrokModelCache } from "./backend/grok-model-cache.js";
 import { CLI_ENV_TTL_MS, isModelCompatible, noteResolvedBinary, resolveBinary, SYSINFO_BACKEND_IDS, UnsupportedCliError, ResumeBlockedError } from "./backend/types.js";
 import { createLogger, rotateLogIfNeeded } from "./logger.js";
 import { processAttachments } from "./channel/attachment-handler.js";
@@ -154,6 +146,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,17 +188,8 @@ export function applyTaskListCap(tasks, filterAssignee, filterStatus) {
     return tasks;
 }
 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 { localWindowsCliEnabled, remoteRuntimeEnabled, setConfiguredRuntimeSwitches, maxAgentsPerMachine } from "./runtime-switches.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 { 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";
@@ -225,7 +222,7 @@ 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 { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, setCapacityLookup, usageProviderIdForBackend } from "./usage/usage-api.js";
 import { LOGIN_FLOWS, checkAuthStatus, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
 import { LoginSession } from "./login-manager.js";
 import { runOnLoginShell } from "./login-shell.js";
@@ -256,6 +253,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";
@@ -286,14 +285,13 @@ 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 { WebNotices, WEB_NOTICES_FILE } from "./web-notices.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";
 import { SessionAuthorizations } from "./authority/session-authorizations.js";
@@ -315,7 +313,7 @@ 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, 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 { classifyInstanceChange, CLASSIC_HOT_CONFIG_KEYS, HOT_INSTANCE_CONFIG_KEYS, hotConfigUpdate, } from "./instance-config-impact.js";
@@ -331,6 +329,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.
@@ -482,6 +486,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;
 /**
@@ -762,974 +768,6 @@ export class FleetManager {
     /** Live view of lifecycle.daemons — used throughout; not deprecated. */
     get daemons() { return this.lifecycle.daemons; }
     fleetConfig = null;
-    fleetWindowsRuntime = null;
-    nativeMcpStore = null;
-    paneManager = null;
-    localPaneRelay = null;
-    openingLocalPane = null;
-    runtimeHub = null;
-    runtimeExecutor = null;
-    runtimeStatusScheduled = false;
-    reconciledRemoteResults = new Set();
-    /** Machine credentials are separate from dashboard sessions and per-turn agent capabilities. */
-    runtimeCoordinator() {
-        if (!remoteRuntimeEnabled())
-            throw new Error("Remote runtimes are not enabled");
-        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 ?? {}))
-                        if (config.machine_id === event.machineId) {
-                            this.nativeMcpStore?.closeInstance(name);
-                            if (config.general_topic) {
-                                this.cancelPendingDeliveries(name);
-                                this.holdGeneralOldDeliveries(name);
-                            }
-                        }
-                    this.needsYou?.poke();
-                }
-                if (this.runtimeStatusScheduled || this.shuttingDown)
-                    return;
-                this.runtimeStatusScheduled = true;
-                queueMicrotask(() => {
-                    this.runtimeStatusScheduled = false;
-                    if (this.shuttingDown)
-                        return;
-                    try {
-                        this.fleetWindowsRuntime?.importHistory();
-                        for (const snapshot of this.runtimeHub?.tasks() ?? [])
-                            this.reconcileRemoteDelivery(snapshot.machineId, snapshot.task);
-                        this.emitSseEvent("status", this.getUiStatus());
-                        this.scheduleDeliveryOutboxPump();
-                    }
-                    catch (error) {
-                        this.logger.warn({ err: error }, "Runtime status reconciliation failed");
-                    }
-                });
-            },
-        });
-    }
-    runtimeWindowsExecutor() {
-        return this.runtimeExecutor ??= new RuntimeWindowsBridge(this, () => remoteRuntimeEnabled() && !this.shuttingDown ? this.runtimeCoordinator() : null);
-    }
-    /** Per-turn capabilities for native MCP, separate from browser and Linux-agent credentials. */
-    nativeMcpSessions() {
-        return this.nativeMcpStore ??= new NativeMcpSessions(this);
-    }
-    /** The same instance registry and delivery entry point, with a native Windows execution adapter. */
-    nativeInstanceRuntime() {
-        return this.fleetWindowsRuntime ??= new FleetWindowsRuntime({
-            owner: this, fleet: () => this.fleetConfig, save: () => this.saveFleetConfig(), stopping: () => this.shuttingDown, history: this.webChatHistory,
-            openMcp: (instance, requestId, sandbox, stillCurrent) => this.healthServerListening
-                ? this.nativeMcpSessions().grant({ instance, requestId, sandbox, stillCurrent, endpoint: `http://127.0.0.1:${this.fleetConfig?.health_port ?? 19280}/agent` }) : null,
-            warn: (message, error) => this.logger.warn({ err: error }, message),
-            removed: name => this.nativeInstanceRemoved(name),
-            paneCurrent: name => this.daemons.get(name)?.nativePaneCurrent?.() === true,
-            machineAvailable: id => remoteRuntimeEnabled() && this.runtimeCoordinator().machine(id)?.status === "online",
-            machineGeneration: id => this.runtimeCoordinator().machine(id)?.bootId ?? null,
-            paneAvailable: id => this.runtimeCoordinator().machine(id)?.paneProtocol === 1,
-            validateMachine: (id, cli, sandbox) => {
-                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");
-            },
-            emit: (event, data) => {
-                this.emitSseEvent(event, event === "status" ? this.getUiStatus() : data);
-                if (event === "activity")
-                    this.scheduleDeliveryOutboxPump();
-            },
-        }, { 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");
-        return createNativePane({ fleet: () => this.fleetConfig, runtime: this.nativeInstanceRuntime(),
-            topic: target => {
-                const world = this.worlds.get(target.id), adapter = world?.adapter;
-                if (!world || !adapter?.createTopic || !adapter.deleteTopic)
-                    throw Error("The approved connection cannot create and compensate a topic");
-                const same = () => {
-                    const channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
-                    const matches = channels.filter(row => (row.id ?? row.type) === target.id);
-                    return !this.shuttingDown && this.worlds.get(target.id) === world && world.adapter === adapter && matches.length === 1 && matches[0].type === target.type && matches[0].group_id === target.group_id;
-                };
-                return { current: same, create: name => adapter.createTopic(name), remove: id => adapter.deleteTopic(id) };
-            },
-            epoch: name => this.lifecycle.epochOf(name),
-            start: async (name, config, current) => {
-                if (!current())
-                    throw Error("Native creation expired before start");
-                await this.startInstance(name, config, true);
-                if (!current())
-                    throw Error("Native creation expired during start");
-                await this.connectIpcToInstance(name);
-                if (!current())
-                    throw Error("Native creation expired during channel connection");
-            },
-            close: (name, config, epoch) => this.lifecycle.runTransition(name, async (transition) => {
-                if (this.fleetConfig?.instances[name] !== config || this.lifecycle.epochOf(name) !== epoch)
-                    return false;
-                await this.stopInstance(name, transition);
-                return this.fleetConfig?.instances[name] === config && this.lifecycle.epochOf(name) === epoch + 1;
-            }),
-            routes: () => { if (this.fleetConfig)
-                this.routing.rebuild(this.fleetConfig); },
-            warn: error => this.logger.warn({ err: error }, "Native creation cleanup is held; retained identity and topic require attention"), }, profile, channelId, () => !this.shuttingDown && authorized(), execution);
-    }
-    /** Admin-only settings path: validate first, then close the exact old launch before changing cold fields. */
-    async updateNativePaneConfig(name, patch, authorized, transaction) {
-        return this.lifecycle.runTransition(name, async (transition) => {
-            const before = this.fleetConfig?.instances[name];
-            if (!isNativePaneInstance(before))
-                throw Error("Persistent Windows instance not found");
-            const runtime = this.nativeInstanceRuntime(), generation = this.explicitStopGeneration.get(name) ?? 0;
-            let expectedGeneration = generation;
-            const current = () => authorized() && !this.shuttingDown && this.fleetConfig?.instances[name] === before
-                && (this.explicitStopGeneration.get(name) ?? 0) === expectedGeneration
-                && (before.machine_id ? remoteRuntimeEnabled() : localWindowsCliEnabled());
-            if (!current())
-                throw Error("Native settings authority expired");
-            runtime.previewUpdate(name, patch);
-            const cold = ["working_directory", "model", "systemPrompt", "native_sandbox"].some(key => Object.hasOwn(patch, key) && (patch[key] ?? "") !== (before[key] ?? ""));
-            const running = this.daemons.get(name);
-            if (cold) {
-                if (running && !running.nativePaneHasExited() && (!await running.nativePauseReady({ current, accepts: () => true, revalidate: async () => current() }) || !running.nativePauseStillReady()))
-                    throw Error("Wait for this Windows agent to be idle before changing its launch settings");
-                if (!current())
-                    throw Error("Native settings authority expired before closing its old pane");
-                await this.stopInstance(name, transition);
-                expectedGeneration = generation + 1;
-                if (!current())
-                    throw Error("Native settings authority expired after closing its old pane");
-                if (runtime.get(name)?.activeId)
-                    throw Error("Native pane exit is unconfirmed; its settings were not changed");
-            }
-            const result = runtime.update(name, patch, current, transaction), next = this.fleetConfig.instances[name];
-            if (cold && running) {
-                if (!authorized() || this.shuttingDown || this.fleetConfig?.instances[name] !== next || (this.explicitStopGeneration.get(name) ?? 0) !== expectedGeneration)
-                    throw Error("Native settings saved; restart authority expired");
-                await this.startInstance(name, next, true, "fleet-topic", false, transition);
-            }
-            return result;
-        });
-    }
-    async localNativePaneEndpoint() {
-        const admit = () => { if (this.shuttingDown || this.localPaneDrain || !localWindowsCliEnabled())
-            throw Error("Local Windows runtime is switched off or draining"); };
-        admit();
-        if (this.localPaneDrain)
-            throw Error("Local Windows runtime cleanup is pending");
-        if (this.localPaneRelay?.online())
-            return this.localPaneRelay;
-        if (this.openingLocalPane)
-            return this.openingLocalPane;
-        const opening = (async () => {
-            const [{ LocalPaneEndpoint }, { launchLocalPaneRelay, localPaneScope }, inventory] = await Promise.all([
-                import("./local-pane-endpoint.js"), import("./local-pane-launcher.js"), this.runtimeWindowsExecutor().probe({ force: false }),
-            ]);
-            admit();
-            this.localPaneRelay?.stop();
-            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,
-                launch: () => launchLocalPaneRelay(this.dataDir, admit),
-                mcp: async (body, current) => (await this.nativePanes()).handle("local", body, current),
-            });
-            try {
-                admit();
-                this.localPaneRelay = relay;
-                return relay;
-            }
-            catch (error) {
-                relay.stop();
-                throw error;
-            }
-        })();
-        this.openingLocalPane = opening;
-        try {
-            return await opening;
-        }
-        finally {
-            if (this.openingLocalPane === opening)
-                this.openingLocalPane = null;
-        }
-    }
-    /** Persistent ownership is independent of the exec worker's per-turn capabilities. */
-    async nativePanes() {
-        if (this.paneManager)
-            return this.paneManager;
-        const { NativePaneManager } = await import("./native-pane-manager.js");
-        if (this.paneManager)
-            return this.paneManager;
-        const store = windowsAgentsFor(this, this.runtimeWindowsExecutor());
-        const allowed = (name, tool) => nativePaneToolAvailable(tool) && mayUseTool(resolveToolSet(this.fleetConfig?.instances[name], name), tool)
-            && !dashboardRefusalIn(this.fleetConfig, name, tool);
-        return this.paneManager = new NativePaneManager({
-            home: this.dataDir, store, config: name => this.fleetConfig?.instances[name],
-            freshNotice: async (name, provider) => {
-                const message = t(provider === "codex" ? "native_pane.codex_fresh_started" : "native_pane.fresh_started");
-                this.eventLog?.insert(name, "native_pane_fresh_started", {});
-                this.logger.info({ name }, message);
-                await this.notifyInstanceTopic(name, message);
-            },
-            admit: (name, config) => {
-                const now = this.fleetConfig?.instances[name];
-                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)
-                    throw Error("Native pane configuration or lifetime changed");
-                if (config.machine_id ? this.remotePaneDrain || !remoteRuntimeEnabled() : this.localPaneDrain || !localWindowsCliEnabled())
-                    throw Error("Native runtime is switched off");
-            },
-            endpoint: async (agent, cleanup = false) => {
-                if (!agent.machineId) {
-                    if (!cleanup)
-                        return this.localNativePaneEndpoint();
-                    if (!this.localPaneRelay)
-                        throw Error("Local cleanup transport is unavailable; pane remains reserved");
-                    return this.localPaneRelay;
-                }
-                const hub = cleanup ? this.runtimeHub : this.runtimeCoordinator(), machineId = agent.machineId;
-                if (!hub)
-                    throw Error("Remote cleanup transport is unavailable; pane remains reserved");
-                const draining = () => !!this.remotePaneDrain;
-                return { machineId, online: () => !this.shuttingDown && (draining() || remoteRuntimeEnabled()) && this.runtimeHub === hub && hub.machine(machineId)?.status === "online",
-                    call: request => {
-                        if (this.runtimeHub !== hub || !(draining() || remoteRuntimeEnabled()) || draining() && request.action !== "snapshot" && request.action !== "close")
-                            return Promise.reject(Error("Remote pane transport only permits owned cleanup"));
-                        return hub.callPane(machineId, request, maxAgentsPerMachine());
-                    }, subscribe: listener => hub.subscribe(listener),
-                    epoch: () => hub.paneTransportEpoch(machineId), version: provider => hub.machine(machineId)?.inventory?.clis.find(row => row.id === provider && row.runnable)?.version ?? null };
-            },
-            instructions: (name, config) => buildNativeFleetInstructions({ instanceName: name, workingDirectory: config.working_directory,
-                displayName: config.display_name, description: config.description, customPrompt: config.systemPrompt,
-                workflow: config.workflow, taskBoard: !dashboardRefusalIn(this.fleetConfig, name, "task"),
-                runtimeIdentity: { kind: "fleet-topic", backend: config.backend ?? "codex", model: config.model || "default" } }, config.general_topic === true),
-            menu: name => TOOLS.filter(tool => allowed(name, tool.name)).map(tool => ({ ...tool })),
-            allowed: (name, tool, args) => allowed(name, tool) && !nativePaneToolRefusal(tool, args), published: (name, daemon) => this.daemons.get(name) === daemon,
-            invoke: async (daemon, input, current, name) => {
-                if (input.tool === "list_models") {
-                    const { ListModelsArgs } = await import("./outbound-schemas.js");
-                    const parsed = ListModelsArgs.safeParse(input.args);
-                    if (!parsed.success || !current())
-                        return { result: null, error: "Invalid native model request or expired owner" };
-                    const target = parsed.data.instance_name ?? name;
-                    if (!isWindowsInstance(this.fleetConfig?.instances[target]))
-                        return { result: null, error: "Native panes can only read Windows runtime model inventories" };
-                    return { result: await this.listModelCatalog({ instanceName: target }) };
-                }
-                const ops = { list_instances: "list", describe_instance: "describe", task: "task", send_to_instance: "send",
-                    delegate_task: "delegate", request_information: "ask", report_result: "report", delivery_status: "delivery-status" };
-                const { nativeAgentAdmissionContext } = await import("./native-agent-admission.js");
-                const { dispatchAgentOperation } = await import("./agent-endpoint.js");
-                return daemon.handlePaneToolCall(input, { current, allowed: tool => allowed(name, tool),
-                    dispatch: (tool, args) => ops[tool] ? dispatchAgentOperation(nativeAgentAdmissionContext(this, {
-                        instance: name, current: () => current() && allowed(name, tool), taskAllowed: () => current() && allowed(name, "task"),
-                    }), name, ops[tool], args, input.operationId) : undefined });
-            },
-        });
-    }
-    /** Prepare only bundled role files; this neither switches General nor starts a provider process. */
-    async prepareWindowsGeneralWorkspace(name, machineId, cli, bindingId, authorized) {
-        const config = this.fleetConfig?.instances[name], hub = this.runtimeCoordinator(), epoch = hub.paneTransportEpoch(machineId);
-        if (!config?.general_topic || !epoch)
-            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([
-            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);
-        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())
-            throw Error("General workspace authority expired");
-        if (inventory?.capabilities?.generalWorkspace !== true)
-            throw new NativePaneRecoveryError({ kind: "host-upgrade" });
-        const result = await hub.callPane(machineId, request, maxAgentsPerMachine());
-        if (!current())
-            throw Error("General workspace authority expired");
-        if (generalWorkspaceUpgrade(result, request))
-            throw new NativePaneRecoveryError({ kind: "host-upgrade" });
-        return validateGeneralWorkspaceReceipt(result, request);
-    }
-    generalLocationFlights = new Map();
-    generalAttentionEpisodes = new Map();
-    generalBindings() { return new GeneralBindings(this.dataDir); }
-    generalLocations() {
-        const store = this.generalBindings();
-        return { generals: Object.entries(this.fleetConfig?.instances ?? {}).filter(([, cfg]) => cfg.general_topic).map(([name, cfg]) => {
-                const record = store.read(name), machine = cfg.machine_id ? this.runtimeHub?.machine(cfg.machine_id) : null;
-                return { name, displayName: cfg.display_name ?? name, location: isWindowsInstance(cfg) ? "windows" : "host",
-                    machineId: cfg.machine_id ?? null, cli: cfg.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code", model: cfg.model ?? "",
-                    revision: generalBindingRevision(record, cfg), canSwitchBack: !!record && record.active !== "host",
-                    offline: isWindowsInstance(cfg) && (!remoteRuntimeEnabled() || machine?.status !== "online" || !this.runtimeHub?.paneTransportEpoch(cfg.machine_id)),
-                    retryTarget: record?.pending?.phase === "selected" ? (record.pending.to === "host" ? { location: "host" } : (() => { const row = record.windows.find(item => item.id === record.pending.to); return { location: "windows", machineId: row.machineId, cli: row.cli, model: row.config.model ?? "" }; })()) : null,
-                    hold: record?.hold ?? (record?.pending ? record.pending.phase === "selected" ? "start" : "exit" : null), switching: this.generalLocationFlights.has(name) };
-            }), machines: (this.runtimeHub?.listMachines() ?? []).filter(row => row.status !== "pending" && row.status !== "revoked").map(row => ({
-                id: row.id, name: row.name, online: row.status === "online" && !!this.runtimeHub?.paneTransportEpoch(row.id),
-                clis: row.inventory?.clis.filter(cli => cli.runnable && (cli.id === "claude-code" || cli.id === "codex")).map(cli => ({ id: cli.id, version: cli.version })) ?? [],
-            })) };
-    }
-    /** Pure preflight for the confirmation diff and stale-tab refusal; never prepares files or starts a CLI. */
-    previewGeneralLocation(raw) {
-        const input = parseGeneralSwitchInput(raw), cfg = this.fleetConfig?.instances[input.name];
-        if (!cfg?.general_topic || this.shuttingDown)
-            throw Error("General is unavailable");
-        const record = this.generalBindings().read(input.name);
-        if (input.revision !== generalBindingRevision(record, cfg))
-            throw Error("General location changed; read its settings again");
-        const connections = cfg.channel_id ? [cfg.channel_id] : [];
-        const channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
-        if (channels.length && (connections.length !== 1 || channels.filter(row => (row.id ?? row.type) === connections[0]).length !== 1))
-            throw Error("General's connection cannot be resolved");
-        if (input.target.location === "host") {
-            if (!record)
-                throw Error("General's saved host location is unavailable");
-            return { input, connections, summary: [t("general_location.confirm_host"), t("general_location.history")] };
-        }
-        const active = record?.windows.find(row => row.id === record.active);
-        if (!record?.pending && record?.hold !== "start" && active?.machineId === input.target.machineId && active.cli === input.target.cli)
-            throw Error("General already runs at this location");
-        const machine = this.runtimeHub?.machine(input.target.machineId);
-        if (!remoteRuntimeEnabled() || machine?.status !== "online" || !this.runtimeHub?.paneTransportEpoch(machine.id))
-            throw Error(t("general_location.offline"));
-        const provider = input.target.cli;
-        if (!machine.inventory?.clis.some(cli => cli.id === provider && cli.runnable))
-            throw Error("The chosen Windows CLI is unavailable");
-        return { input, connections, summary: [t("general_location.confirm_windows", settingsDisplay(machine.name)), t("general_location.history")] };
-    }
-    /** All entry points, including automatic native recovery, must respect an interrupted binding switch. */
-    assertGeneralBindingStart(name, config) {
-        if (!config.general_topic)
-            return;
-        try {
-            this.generalBindings().assertStart(name, config);
-        }
-        catch (err) {
-            this.logger.warn({ name, err }, "General location start held by its saved binding");
-            this.needsYou?.poke();
-            throw new UnsupportedCliError(t("general_location.exit_unconfirmed"));
-        }
-    }
-    /** Only the Settings replay's confirmed admin can enter; the whole switch owns one lifecycle transition. */
-    async switchGeneralLocation(raw, authorized, execution) {
-        const { input } = this.previewGeneralLocation(raw), name = input.name;
-        return this.lifecycle.runTransition(name, async (transition) => {
-            execution.assert();
-            if (!authorized() || this.generalLocationFlights.has(name))
-                throw Error("General location authority expired or a switch is already running");
-            const token = Symbol(name), generation = this.settingsGeneration;
-            const destinationEpoch = input.target.location === "windows" ? this.runtimeHub?.paneTransportEpoch(input.target.machineId) : null;
-            let expected = this.fleetConfig.instances[name], stopGeneration = this.explicitStopGeneration.get(name) ?? 0, epoch = this.lifecycle.epochOf(name);
-            const hostSnapshot = !isWindowsInstance(expected) ? structuredClone(this.daemons.get(name)?.getConfigSnapshot() ?? expected) : undefined;
-            const current = () => !this.shuttingDown && this.settingsGeneration === generation && authorized()
-                && this.generalLocationFlights.get(name) === token && this.fleetConfig?.instances[name] === expected
-                && (input.target.location !== "windows" || remoteRuntimeEnabled() && !!destinationEpoch && this.runtimeHub?.paneTransportEpoch(input.target.machineId) === destinationEpoch)
-                && (this.explicitStopGeneration.get(name) ?? 0) === stopGeneration && this.lifecycle.epochOf(name) === epoch;
-            const check = () => { if (!current())
-                throw Error("General location switch was superseded"); };
-            this.generalLocationFlights.set(name, token);
-            // Old ephemeral waiters carry this epoch; they cannot wake into the selected conversation.
-            this.cancelPendingDeliveries(name);
-            let lease = null;
-            try {
-                lease = await waitSettingsLease([settingsFileResource(this.getSettingsConfigPath()), `general:${this.dataDir}:${name}`], () => current() && execution.current(), performance.now() + execution.remainingMs, execution.owner);
-                const store = this.generalBindings();
-                const result = await switchGeneralLocation({ store, current: () => expected, assert: check,
-                    prepare: async (target, retained) => {
-                        if (target.location !== "windows")
-                            return null;
-                        const old = retained.windows.find(row => row.machineId === target.machineId && row.cli === target.cli);
-                        const id = old?.id ?? randomUUID(), agentId = old?.agentId ?? randomUUID();
-                        const publication = await this.prepareWindowsGeneralWorkspace(name, target.machineId, target.cli, id, () => current() && execution.current());
-                        check();
-                        execution.assert();
-                        const config = { ...structuredClone(expected), runtime: "windows", machine_id: target.machineId,
-                            native_adapter: "pane", native_agent_id: agentId, native_general_binding: id, native_sandbox: "workspace-write",
-                            backend: target.cli, model: target.model, working_directory: publication.cwd, systemPrompt: "", agent_mode: "cli" };
-                        // Host credentials, shell hooks and provider-specific options never become Windows launch configuration.
-                        for (const key of ["backend_options", "credential_profile", "pre_task_command"])
-                            delete config[key];
-                        windowsAgentsFor(this, this.runtimeWindowsExecutor()).ensureGeneralBinding({ id: agentId, instance: name, machineId: target.machineId,
-                            cli: target.cli, cwd: publication.cwd, name: (expected.display_name ?? name).slice(0, 64), model: target.model, instructions: "", description: expected.description ?? "" }, () => current() && execution.current());
-                        return { id, agentId, machineId: target.machineId, cli: target.cli, config };
-                    },
-                    idle: async () => {
-                        check();
-                        const daemon = this.daemons.get(name);
-                        return !daemon || daemon.getInstanceStateSnapshot().state === "idle" && daemon.getWorkingRecoveryState().idle
-                            && daemon.getInteractionSnapshot().phase === "clear" && !this.lifecycle.hasWorkLease(name)
-                            && Date.now() - (this.lastDeliveryAt.get(name) ?? 0) >= 2000;
-                    },
-                    hostSnapshot: () => hostSnapshot,
-                    capture: async () => {
-                        if (isWindowsInstance(expected))
-                            return undefined;
-                        const daemon = this.daemons.get(name);
-                        if (!daemon)
-                            throw Error(t("general_location.exit_unconfirmed"));
-                        const owner = await daemon.generalHostOwner();
-                        check();
-                        execution.assert();
-                        return owner;
-                    },
-                    stop: async (owner) => {
-                        check();
-                        const stopping = this.stopInstance(name, transition);
-                        stopGeneration++;
-                        epoch++;
-                        await stopping;
-                        check();
-                        if (isWindowsInstance(expected)) {
-                            const profile = windowsAgentsFor(this, this.runtimeWindowsExecutor()).get(expected.native_agent_id);
-                            if (profile.activeId || profile.paneLaunchId)
-                                throw Error(t("general_location.exit_unconfirmed"));
-                            execution.mutate(() => this.holdGeneralOldDeliveries(name));
-                            return undefined;
-                        }
-                        if (!owner || !await confirmGeneralHostExit(owner, getTmuxSession()))
-                            throw Error(t("general_location.exit_unconfirmed"));
-                        check();
-                        execution.mutate(() => this.holdGeneralOldDeliveries(name));
-                        return owner.pin;
-                    },
-                    save: next => {
-                        check();
-                        const previous = expected;
-                        try {
-                            this.fleetConfig.instances[name] = next;
-                            this.saveFleetConfig([{ path: ["instances", name], value: next }]);
-                            expected = next;
-                            this.routing.rebuild(this.fleetConfig);
-                        }
-                        catch (err) {
-                            this.fleetConfig.instances[name] = previous;
-                            throw err;
-                        }
-                    },
-                    start: async () => {
-                        check();
-                        if (!execution.completed)
-                            throw Error("General's selected binding has no committed approval");
-                        // The committed receipt permits only this selected startup. Live authority still fences every awaited spawn boundary.
-                        const startup = new SettingsExecution({ current: () => current() && execution.completed && execution.remainingMs > 0,
-                            snapshot: () => this.fleetConfig });
-                        try {
-                            await this.startInstance(name, expected, true, "fleet-topic", false, transition, startup);
-                        }
-                        finally {
-                            startup.close();
-                        }
-                        check();
-                        const daemon = this.daemons.get(name);
-                        if (!daemon || daemon.getProcessStatus() !== "running" || isNativePaneInstance(expected) && !daemon.nativePaneCurrent())
-                            throw Error(t("general_location.start_failed"));
-                        await this.connectIpcToInstance(name);
-                        check();
-                    },
-                    notify: (kind, err) => {
-                        const message = t(kind === "exit" ? "general_location.exit_unconfirmed" : kind === "start" ? "general_location.start_failed" : "general_location.complete", isWindowsInstance(expected) ? this.runtimeHub?.machine(expected.machine_id)?.name ?? t("general_location.windows") : t("general_location.host"));
-                        this.eventLog?.insert(name, "general_location", { phase: kind, message });
-                        if (err)
-                            this.logger.warn({ name, phase: kind, err }, message);
-                        else
-                            this.logger.info({ name, phase: kind }, message);
-                        this.needsYou?.poke();
-                        this.emitSseEvent("status", this.getUiStatus());
-                        this.notifyInstanceTopic(name, message);
-                    },
-                }, input, execution);
-                return { ...result, message: result.started ? t("general_location.complete", isWindowsInstance(expected)
-                        ? this.runtimeHub?.machine(expected.machine_id)?.name ?? t("general_location.windows") : t("general_location.host")) : t("general_location.start_failed") };
-            }
-            finally {
-                lease?.release();
-                if (this.generalLocationFlights.get(name) === token)
-                    this.generalLocationFlights.delete(name);
-                this.needsYou?.poke();
-            }
-        });
-    }
-    /** An offline PC or a confirmed binding boundary holds old waiting input; it never becomes another conversation's queue. */
-    holdGeneralOldDeliveries(name) {
-        const outbox = this.deliveryOutbox;
-        if (!outbox)
-            return;
-        for (const row of outbox.listPending().filter(row => row.targetInstance === name)) {
-            if (row.state !== "submission_started")
-                outbox.failBeforeBegin(row.deliveryId, t("general_location.input_not_replayed"));
-            else if (row.targetDaemonBootId) {
-                outbox.markTargetReconciliationPending(name, row.targetDaemonBootId);
-                if (!outbox.reconcileAttempt(row.deliveryId, row.targetDaemonBootId, row.attemptNo, "uncertain", t("general_location.input_not_replayed")))
-                    throw Error("General's old delivery could not be held");
-            }
-            else
-                throw Error("General's old delivery has no confirmed owner");
-        }
-        this.needsYou?.poke();
-    }
-    generalLocationDeliveryHold(name) {
-        const config = this.fleetConfig?.instances[name];
-        if (!config?.general_topic)
-            return null;
-        if (this.generalLocationFlights?.has(name))
-            return t("general_location.exit_unconfirmed");
-        let record;
-        try {
-            record = this.generalBindings().read(name);
-        }
-        catch {
-            return t("general_location.start_failed");
-        }
-        if (record?.pending || record?.hold)
-            return t(record.pending?.phase === "selected" || record.hold === "start" ? "general_location.start_failed" : "general_location.exit_unconfirmed");
-        if (isWindowsInstance(config) && config.machine_id && (!remoteRuntimeEnabled() || this.runtimeHub?.machine(config.machine_id)?.status !== "online" || !this.runtimeHub?.paneTransportEpoch(config.machine_id)))
-            return t("general_location.offline");
-        return null;
-    }
-    generalLocationAttention(name) {
-        const cfg = this.fleetConfig?.instances[name];
-        if (!cfg?.general_topic)
-            return null;
-        const detail = this.generalLocationDeliveryHold(name);
-        if (!detail) {
-            this.generalAttentionEpisodes.delete(name);
-            return null;
-        }
-        let record = null;
-        try {
-            record = this.generalBindings().read(name);
-        }
-        catch { /* a corrupt journal is a visible hold too */ }
-        const offline = !record?.pending && !record?.hold && isWindowsInstance(cfg) && detail === t("general_location.offline");
-        const key = record?.pending?.id ?? `${record?.revision ?? "unknown"}:${offline ? "offline" : "hold"}`;
-        let episode = this.generalAttentionEpisodes.get(name);
-        if (!episode || episode.key !== key) {
-            episode = { key, since: record?.pending?.at ?? Date.now() };
-            this.generalAttentionEpisodes.set(name, episode);
-        }
-        return { ...episode, detail, offline };
-    }
-    async nativePaneFor(name, config, assertCurrent) {
-        try {
-            return await (await this.nativePanes()).prepare(name, config, assertCurrent);
-        }
-        catch (err) {
-            if (config.general_topic && err instanceof GeneralManagedFileError) {
-                assertCurrent();
-                const store = this.generalBindings(), record = store.read(name);
-                if (record && record.active === config.native_general_binding) {
-                    record.hold = "start";
-                    store.write(record);
-                }
-                this.logger.warn({ name, managedFile: err.file }, t("general_location.start_failed"));
-                this.needsYou?.poke();
-                throw new UnsupportedCliError(t("general_location.start_failed"));
-            }
-            throw err;
-        }
-    }
-    async recoverNativePane(name, launchId, authorized) {
-        const config = this.fleetConfig?.instances[name];
-        if (!isNativePaneInstance(config))
-            throw Error("Persistent Windows pane is not configured");
-        const generation = this.explicitStopGeneration.get(name) ?? 0;
-        await this.lifecycle.runTransition(name, async (transition) => {
-            const current = () => { if (!authorized() || this.shuttingDown || this.fleetConfig?.instances[name] !== config || (this.explicitStopGeneration.get(name) ?? 0) !== generation)
-                throw Error(t("native_pane.authority_expired")); };
-            current();
-            if (this.daemons.get(name)?.nativePaneCurrent())
-                throw Error(t("native_pane.still_running"));
-            this.cancelStartupRetry(name);
-            this.lifecycle.cancelNativeRecovery(name);
-            await (await this.nativePanes()).recover(name, config, launchId, true, current);
-            current();
-            // The host supplied a positive exit before ordinary lifecycle cleanup. No signal or input is required.
-            await this.lifecycle.stop(name, transition);
-            current();
-            this.instanceProcessStatus.set(name, "stopped");
-            this.eventLog?.insert(name, "native_pane_recovered", { launchId, confirmedStopped: true });
-            this.logger.info({ name, launchId }, "Windows saved pane recovered by an administrator; waiting for Start");
-            this.emitSseEvent("status", this.getUiStatus());
-        });
-    }
-    holdNativePaneRecovery(name, error) {
-        if (!(error instanceof NativePaneRecoveryError))
-            return false;
-        this.instanceProcessStatus.set(name, "stopped");
-        this.logger.warn({ name, recovery: error.recovery }, error.message);
-        this.eventLog?.insert(name, "native_pane_recovery_needed", { ...error.recovery });
-        this.needsYou?.poke();
-        this.emitSseEvent("status", this.getUiStatus());
-        return true;
-    }
-    async startFreshNativePane(name, launchId, sessionId, authorized) {
-        const config = this.fleetConfig?.instances[name];
-        if (!isNativePaneInstance(config))
-            throw Error("Persistent Windows pane is not configured");
-        const generation = this.explicitStopGeneration.get(name) ?? 0;
-        await this.lifecycle.runTransition(name, async (transition) => {
-            const current = () => { if (!authorized() || this.shuttingDown || this.fleetConfig?.instances[name] !== config || (this.explicitStopGeneration.get(name) ?? 0) !== generation)
-                throw Error(t("native_pane.authority_expired")); };
-            current();
-            const held = windowsAgentsFor(this, this.runtimeWindowsExecutor()).get(config.native_agent_id).paneRecovery;
-            if (held?.kind !== "session-unconfirmed" || held.launchId !== launchId || (held.sessionId ?? null) !== sessionId)
-                throw Error(t("native_pane.changed"));
-            if (this.daemons.get(name)?.nativePaneCurrent())
-                throw Error(t("native_pane.still_running"));
-            this.cancelStartupRetry(name);
-            this.lifecycle.cancelNativeRecovery(name);
-            await this.lifecycle.stop(name, transition);
-            current();
-            try {
-                await (await this.nativePanes()).startFresh(name, config, launchId, sessionId, current);
-                current();
-            }
-            catch (error) {
-                current();
-                this.needsYou?.poke();
-                this.emitSseEvent("status", this.getUiStatus());
-                throw error;
-            }
-            this.eventLog?.insert(name, "native_pane_new_conversation", { launchId, sessionId });
-            await this.startInstance(name, config, true, "fleet-topic", true, transition);
-            current();
-            this.needsYou?.poke();
-            this.emitSseEvent("status", this.getUiStatus());
-        });
-    }
-    nativePanePinnedSession(name) {
-        const config = this.fleetConfig?.instances[name];
-        if (!isNativePaneInstance(config) || !config.native_agent_id)
-            return null;
-        const agent = windowsAgentsFor(this, this.runtimeWindowsExecutor()).get(config.native_agent_id);
-        return agent.fleet_instance === name && agent.machineId === config.machine_id ? agent.threadId ?? null : null;
-    }
-    onNativePaneRecoverySettled(name) {
-        if (this.daemons.get(name)?.nativePaneCurrent())
-            this.instanceProcessStatus.delete(name);
-        this.onAttentionChanged(name);
-        this.scheduleDeliveryOutboxPump();
-    }
-    setNativePanePaused(name, paused) {
-        const id = this.fleetConfig?.instances[name]?.native_agent_id;
-        if (!id)
-            throw Error("Native profile is missing");
-        windowsAgentsFor(this, this.runtimeWindowsExecutor()).setPaused(id, paused);
-    }
-    async closeRetainedNativePane(name) {
-        const config = this.fleetConfig?.instances[name];
-        if (!config)
-            throw Error("Native instance configuration is missing");
-        await (await this.nativePanes()).closeRetained(name, config, () => { if (this.shuttingDown)
-            throw Error("Fleet is stopping"); });
-    }
-    async reconcileNativePaneBeforeStart(name, daemon) {
-        const outbox = this.deliveryOutbox;
-        if (!outbox)
-            return true;
-        const epoch = this.lifecycle.epochOf(name);
-        return daemon.reconcileNativeDeliveries(outbox, () => !this.shuttingDown && this.lifecycle.epochOf(name) === epoch);
-    }
-    /** M-2255: the Windows runtimes' switches the fleet's own state reflects (null until the start-up has applied them). */
-    runtimeEffects = null;
-    runtimeEffectsScheduled = false;
-    localPaneDrain = null;
-    remotePaneDrain = null;
-    /** Revoke admissions synchronously; keep the captured transport only long enough for exact owned closes. */
-    drainNativeRuntime(remote) {
-        const existing = remote ? this.remotePaneDrain : this.localPaneDrain;
-        if (existing)
-            return existing;
-        const hub = this.runtimeHub, relay = this.localPaneRelay;
-        if (!remote)
-            relay?.beginCleanup();
-        const targets = Object.entries(this.fleetConfig?.instances ?? {}).filter(([, config]) => isWindowsInstance(config) && !!config.machine_id === remote);
-        for (const [name, config] of targets) {
-            this.nativeMcpStore?.closeInstance(name);
-            if (isNativePaneInstance(config)) {
-                this.lifecycle.cancelNativeRecovery(name);
-                this.lifecycle.invalidate(name);
-                this.daemons.get(name)?.fenceDeliveryWritesForStop();
-            }
-        }
-        const run = Promise.resolve().then(async () => {
-            const results = await Promise.allSettled(targets.filter(([, config]) => isNativePaneInstance(config)).map(([name]) => this.stopInstance(name)));
-            results.forEach((result, index) => { if (result.status === "rejected")
-                this.logger.warn({ err: result.reason, remote, index }, "Windows pane cleanup unconfirmed; its reservation is retained"); });
-            try {
-                if (remote)
-                    await hub?.shutdownPaneHosts();
-                else
-                    await relay?.shutdownHost();
-            }
-            catch (error) {
-                this.logger.warn({ err: error, remote }, "Windows pane host shutdown unconfirmed; owned state is retained");
-            }
-        }).finally(() => {
-            if (remote) {
-                hub?.close();
-                if (this.runtimeHub === hub)
-                    this.runtimeHub = null;
-            }
-            else {
-                relay?.stop();
-                if (this.localPaneRelay === relay)
-                    this.localPaneRelay = null;
-                closeWindowsBridge(this);
-            }
-        });
-        if (remote)
-            this.remotePaneDrain = run;
-        else
-            this.localPaneDrain = run;
-        void run.finally(() => {
-            if (remote) {
-                if (this.remotePaneDrain === run)
-                    this.remotePaneDrain = null;
-            }
-            else if (this.localPaneDrain === run)
-                this.localPaneDrain = null;
-            if (!this.shuttingDown && (remote ? remoteRuntimeEnabled() : localWindowsCliEnabled())) {
-                this.initializeNativeInstances();
-                this.initializeNativeInstances(true);
-            }
-            try {
-                this.emitSseEvent("status", this.getUiStatus());
-            }
-            catch { }
-        }).catch(error => this.logger.warn({ err: error }, "Windows runtime cleanup failed; retained ownership requires reconciliation"));
-        return run;
-    }
-    /**
-     * M-2255: Settings → Runtime's switches (fleet.yaml `runtimes`, or their environment override) in force — set each time
-     * the configuration in force changes (a load, a save, a reload's rollback), next to the web authority's. Every gate reads
-     * 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.
-     */
-    observeRuntimeSwitches() {
-        setConfiguredRuntimeSwitches(this.fleetConfig?.runtimes);
-        if (!this.runtimeEffects || this.runtimeEffectsScheduled)
-            return;
-        this.runtimeEffectsScheduled = true;
-        queueMicrotask(() => { this.runtimeEffectsScheduled = false; this.applyRuntimeSwitches(); });
-    }
-    /**
-     * Turned off: what it allowed ends now — the paired computers' connections (their agents show as offline) or this PC's
-     * Windows process (a turn in progress is cancelled, as when the fleet stops), and those agents' tool sessions.
-     * Turned on: the Windows agents are registered and their chat history read, as at start-up.
-     */
-    applyRuntimeSwitches() {
-        const was = this.runtimeEffects;
-        if (!was || this.shuttingDown)
-            return;
-        const now = { windows_cli: localWindowsCliEnabled(), remote_runtime: remoteRuntimeEnabled() };
-        if (was.windows_cli === now.windows_cli && was.remote_runtime === now.remote_runtime)
-            return;
-        this.runtimeEffects = now;
-        try {
-            if (was.remote_runtime && !now.remote_runtime) {
-                void this.drainNativeRuntime(true);
-            }
-            if (was.windows_cli && !now.windows_cli) {
-                void this.drainNativeRuntime(false);
-            }
-            if (!was.windows_cli && !was.remote_runtime && !this.localPaneDrain && !this.remotePaneDrain) {
-                this.initializeNativeInstances();
-                this.initializeNativeInstances(true);
-            }
-            this.logger.info({ windows_cli: now.windows_cli, remote_runtime: now.remote_runtime }, "Windows runtime switches applied");
-        }
-        catch (error) {
-            this.logger.warn({ err: error }, "Windows runtime switches could not be applied in full");
-        }
-        try {
-            this.emitSseEvent("status", this.getUiStatus());
-        }
-        catch { /* the next status frame carries it */ }
-    }
-    /** An unavailable opt-in runtime must not prevent the Linux fleet from starting or restoring its own history. */
-    initializeNativeInstances(history = false) {
-        if (!windowsCliEnabled())
-            return;
-        try {
-            const runtime = this.nativeInstanceRuntime();
-            if (history)
-                runtime.importHistory();
-            else
-                runtime.register();
-        }
-        catch (error) {
-            this.logger.warn({ err: error }, "Windows runtime state could not be loaded; affected native instances remain unavailable");
-        }
-    }
-    /** Native CLIs are headless: the manager owns the durable delivery generation instead of a tmux daemon. */
-    deliveryBootId(name) {
-        const config = this.fleetConfig?.instances[name];
-        if (isNativeExecInstance(config)) {
-            if (!this.nativeInstanceRuntime().available(name))
-                return null;
-            const machine = config.machine_id ? this.runtimeCoordinator().machine(config.machine_id) : null;
-            return machine ? `runtime:${machine.id}:${machine.bootId ?? machine.generation}` : this.managerBootId;
-        }
-        return this.daemons.get(name)?.bootId ?? null;
-    }
     rawFleetConfig = {};
     rawFleetDocument = null;
     /** #2208: the paths a saveFleetConfig() wrote, for its check that nothing else changed. */
@@ -1880,6 +918,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];
@@ -1908,6 +947,7 @@ export class FleetManager {
     kiroMigrationRuns = new Map();
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     needsYou = null;
+    missedOfflineStore = null;
     configHistory = null;
     configHistoryTimer = null;
     loadedFleetSource = null;
@@ -2023,6 +1063,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;
@@ -2529,8 +1572,6 @@ export class FleetManager {
      * authorizing revoked links and cookies until the fleet restarted.
      */
     settingsGeneration = 0;
-    /** #2942: the settings baseline the agent-requested Windows changes are checked against (set with the gate). */
-    settingsBaselineReader = null;
     settingsRuntimeRevision = 0;
     settingsConfirmation = null;
     settingsControl = null;
@@ -2587,9 +1628,8 @@ export class FleetManager {
             return this.settingsConfirmation;
         const generation = this.settingsGeneration;
         const current = () => !this.shuttingDown && this.settingsGeneration === generation;
-        const baselines = this.settingsBaselineReader = new SettingsBaselines({ dataDir: this.dataDir, configPath: () => this.configPath,
+        const baselines = new SettingsBaselines({ dataDir: this.dataDir, configPath: () => this.configPath,
             config: () => this.fleetConfig, current: () => [this.settingsGeneration, this.settingsRuntimeRevision, this.shuttingDown],
-            generalLocation: input => this.previewGeneralLocation(input),
             proof: (kind, target, id, binding, key) => {
                 const map = kind === "provider" ? this.providerSecretChallenges : kind === "binding" ? this.connectionBindingChallenges : this.connectionSecretChallenges;
                 const proof = map.get(id);
@@ -2610,17 +1650,6 @@ export class FleetManager {
         const store = new SettingsConfirmationStore({
             audit: (event, fields) => this.logger.info({ event: `settings_confirmation.${event}`, ...fields }, "Settings confirmation audit"),
             notify: view => view.state === "pending" ? this.promptSettingsChange(store, view) : Promise.resolve(),
-            // alpha.2 (M-2300): an agent's request came, was decided or ran out — the open pages read the list again (a ping
-            // with nothing in it: only a web-only fleet's verified owner may read it, GET /ui/agent-proposals).
-            changed: view => {
-                if (view.source !== "agent_request")
-                    return;
-                this.agentProposalsRev++;
-                broadcastSseEvent(this.sseClients, "agent_proposals", {}, err => this.logger.debug({ err }, "agent_proposals event failed"));
-                // …and a status frame with the new revision: a tab from before the upgrade (its stream knows no `agent_proposals`)
-                // applies status frames, and a polling page reads the same frame at its next /ui/poll.
-                this.emitSseEvent("status", this.getUiStatus());
-            },
         });
         const gate = new SettingsHttpConfirmation(store, {
             principal: req => {
@@ -2634,7 +1663,6 @@ 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)
@@ -2669,10 +1697,8 @@ export class FleetManager {
         const auth = authorizeSession(req, this.webToken, this.webSessions, { touch: false });
         if (auth.kind !== "ok")
             return null;
-        // #2453 (§0.2): never over the public link — not even a named-link session that is web-verified there. #3008: except
-        // this computer's admin signed in from outside (the authenticator's code, over the link connections from outside
-        // opened): the web-only fleet's owner, judged below by the same authority as here (hostOperator).
-        if (gatewayRequestContext(req) && auth.session.remote !== "totp")
+        // #2453 (§0.2): never over the public link — not even a named-link session that is web-verified there.
+        if (gatewayRequestContext(req))
             return null;
         // …and never a change that turns the named-link option on: that one needs a General's card or the host.
         if (!store.selfConfirmable(id))
@@ -2705,97 +1731,30 @@ export class FleetManager {
         if (own.length !== 1 || own[0].type !== chat.platform || !chat.admin(actor.user_id))
             return null;
         const affected = [...store.affectedConnections(id)]; // read now: a finished change no longer has them
-        const destinations = this.settingsNoticeGenerals(affected, chat.platform);
-        if (!destinations.length)
+        if (!this.settingsNoticeGenerals(affected, chat.platform).length)
             return null;
         const name = this.webPerson({ adapterId: actor.adapter_id, userId: actor.user_id }).name;
         return {
             label: t("settings_confirm.web_verified_label", name),
             // admin() asks chat.current() too; a General a card could go to must still be there (else the host CLI's).
-            current: () => !!verified() && chat.admin(actor.user_id) && destinations.some(route => route.current()),
-            followStop: async (name, begin) => { const route = destinations.find(item => item.current()); if (!route)
-                throw Error("Settings route expired"); await route.followStop(name, begin); },
+            current: () => !!verified() && chat.admin(actor.user_id) && this.settingsNoticeGenerals(affected, chat.platform).length > 0,
             done: view => this.settingsWebConfirmedNotice(view, affected, name, chat.platform),
         };
     }
-    /**
-     * alpha.2 (M-2300; #2973's agent requests, junsion's §6): on a fleet with no chat connection there is no General to
-     * post an agent's Windows request in — it waited for `agend settings confirm` on the host. Its owner (decision
-     * 28c2d3a3: the `agend web --code` session on this computer, web-verified) now sees and decides it from the web's
-     * Needs you. The authority is asked from the request each time, and again at execution by the store (`current`):
-     * still that owner now (this computer, not revoked, signed out or run out), still a fleet with no chat connection,
-     * never over the public link. Anyone else — a guest, a LAN or public-link session, a chat-connected fleet's admin —
-     * gets nothing (a chat fleet keeps General's card as its way).
-     */
-    /**
-     * #2997 review (Prism P2): how many times an agent's request came or was decided — in a web-only fleet's status frame,
-     * so a page that never hears the stream's ping (one polling /ui/poll, one reconnecting, a tab from before the upgrade)
-     * reads the list again when it moves. A count, nothing more.
-     */
-    agentProposalsRev = 0;
-    agentProposalOwner(req) {
-        // #3008: this computer's admin here, or signed in from outside (over the link connections from outside opened) —
-        // asked of the LIVE session each time (#2997 review): a sign-out, an expiry, a revocation or the switch going off
-        // while the request is applied fences it.
-        return this.liveOwner(req, { hostOnly: false });
-    }
-    /** 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))
-            return null;
-        return this.settingsGate().store.listBySource("agent_request");
-    }
-    /**
-     * alpha.2: the owner's Approve or Reject of an agent's request. The store claims it before its first await (a second
-     * click, from here or the host, finds it no longer pending) and asks the owner, the request (its fleet generation and
-     * Windows switch) and the target machine again before and while it runs the same creation code the web uses. The
-     * answer is always the request as it now stands: applied (with the new agent's name), rejected, expired, stale or
-     * failed (with its reason), or already decided.
-     */
-    async webDecideAgentProposal(req, id, decision) {
-        const owner = this.agentProposalOwner(req);
-        if (!owner)
-            return { status: 403, body: { error: "owner_required", message: t("settings_confirm.web_owner_required") } };
-        const store = this.settingsGate().store, before = store.inspect(id);
-        if (!before || before.source !== "agent_request")
-            return { status: 404, body: { error: "not_found", message: t("settings_confirm.no_longer_pending") } };
-        try {
-            const view = await store.decide(id, decision, { ...owner, via: "web" });
-            this.logger.info({ id, decision, state: view.state }, "Agent request decided from the web by this computer's admin");
-            return { status: 200, body: { view, agent: agentNameOf(view) } };
-        }
-        catch (err) {
-            const code = err instanceof SettingsConfirmationError ? err.code : "decide_failed";
-            const status = err instanceof SettingsConfirmationError ? err.status : 500;
-            // Already decided (a double click, the host's command), run out or withdrawn: say what it is now.
-            return { status, body: { error: code, message: t(code === "admin_required" ? "settings_confirm.web_owner_required" : "settings_confirm.no_longer_pending"), view: store.inspect(id) } };
-        }
-    }
-    /** A confirmation belongs to the server route/lifetime, not the availability of General's model. */
-    settingsGeneralRoute(name, platform, excluded) {
-        const config = this.fleetConfig?.instances[name];
-        if (!config?.general_topic || this.shuttingDown || this.ipcStoppingInstances.has(name))
-            return null;
-        const adapterId = this.getInstanceAdapterId(name), adapter = this.getAdapterForInstance(name);
-        if (!adapterId || !adapter || excluded.has(adapterId) || adapter.type !== platform)
-            return null;
-        const chatId = this.getGroupIdForInstance(name), topic = String(config.topic_id ?? "");
-        if (!chatId || !topic)
-            return null;
-        const route = () => !this.shuttingDown && this.fleetConfig?.instances[name]?.general_topic === true
-            && this.adapterState.get(adapterId)?.status === "connected"
-            && this.getInstanceAdapterId(name) === adapterId && this.getAdapterForInstance(name) === adapter
-            && this.getGroupIdForInstance(name) === chatId && String(this.fleetConfig?.instances[name]?.topic_id ?? "") === topic;
-        const lifetime = new SettingsRouteLifetime(name, route, () => this.lifecycle.epochOf(name), () => this.ipcStoppingInstances.has(name));
-        return lifetime.current() ? { adapterId, adapter, chatId, topic, current: lifetime.current, followStop: lifetime.followStop.bind(lifetime) } : null;
-    }
-    /** Connected, same-platform, unaffected server routes can post cards even while the model is offline. */
+    /** #2170: the Generals a chat card could be posted in (promptSettingsChange's rule): connected, on the platform, unaffected. */
     settingsNoticeGenerals(affected, platform) {
-        const excluded = new Set(affected);
-        return Object.keys(this.fleetConfig?.instances ?? {}).flatMap(name => {
-            const route = this.settingsGeneralRoute(name, platform, excluded);
-            return route ? [route] : [];
-        });
+        const excluded = new Set(affected), found = [];
+        for (const [name, config] of Object.entries(this.fleetConfig?.instances ?? {})) {
+            if (!config.general_topic || !this.daemons.get(name))
+                continue;
+            const adapterId = this.getInstanceAdapterId(name), adapter = this.getAdapterForInstance(name);
+            if (!adapterId || !adapter || excluded.has(adapterId) || adapter.type !== platform || this.adapterState.get(adapterId)?.status !== "connected")
+                continue;
+            const chatId = this.getGroupIdForInstance(name), topic = String(config.topic_id ?? "");
+            if (chatId && topic)
+                found.push({ adapterId, adapter, chatId, topic });
+        }
+        return found;
     }
     /**
      * #2170: General's notice of a change confirmed from the web — the first General a chat card could have been posted
@@ -2854,119 +1813,6 @@ export class FleetManager {
         return { platform, current, admin: userId => current() && !!userId
                 && identities.every(owner => this.isFleetAdmin(userId, owner.id)) };
     }
-    /**
-     * #2942: a Windows create or settings change an AGENT asked for. Nothing is created or written here: it becomes a
-     * pending settings change whose General card a fleet admin must confirm (promptSettingsChange — the same admin rule
-     * as every card). Its apply runs the same creation/patch code the web uses, inside the store's SettingsExecution, with
-     * the confirming admin, the Windows switch and the target machine asked again at that moment.
-     */
-    async proposeAgentWindowsChange(input) {
-        const gate = this.settingsGate(), baselines = this.settingsBaselineReader;
-        if (!baselines || !this.fleetConfig)
-            throw new Error("Fleet configuration is unavailable");
-        const generation = this.settingsGeneration, machineId = input.machineId;
-        const switchOn = () => machineId ? remoteRuntimeEnabled() : localWindowsCliEnabled();
-        const online = () => !machineId || (remoteRuntimeEnabled() && this.runtimeCoordinator().machine(machineId)?.status === "online");
-        if (!switchOn())
-            throw new Error(machineId ? "Remote runtime is not enabled" : LOCAL_WINDOWS_CLI_OFF);
-        const baseline = await baselines.read(), snapshot = settingsFingerprint(baselines.snapshot());
-        const { view } = gate.store.propose({ session: `agent:${input.requester}`, key: `agent-windows:${input.key}`,
-            requestFingerprint: input.fingerprint, fingerprint: input.fingerprint, section: "channel", requestedBy: input.requester,
-            source: "agent_request", summary: input.summary, bytes: input.bytes, authority: input.authority, affectedConnections: [],
-            current: () => !this.shuttingDown && this.settingsGeneration === generation && switchOn(),
-            snapshot: () => baselines.snapshot(),
-            unchanged: async () => (await baselines.read()).fingerprint === baseline.fingerprint && settingsFingerprint(baselines.snapshot()) === snapshot,
-            // The store's own fence (this confirming admin, the session, the state) plus the switch and machine now.
-            apply: async (actorCurrent, execution) => {
-                execution.assert();
-                // alpha.2 polish: a paired machine whose CLI inventory has not arrived yet (just paired) is asked for its own
-                // report first (it runs on that PC), so the creation validates against what is installed there — never a refusal
-                // that only a manual Refresh would undo. Its answer or failure changes nothing else; the fence is asked again.
-                if (machineId && online() && !inventoryProbed(this.runtimeCoordinator().machine(machineId)?.inventory)) {
-                    // `force`: the runner's cached answer on a fresh profile is the placeholder itself (#3005 rig recheck).
-                    try {
-                        await this.runtimeCoordinator().call(machineId, "probe", { force: true });
-                    }
-                    catch { /* validation says what is missing */ }
-                    execution.assert();
-                }
-                return input.apply(() => actorCurrent() && online(), execution);
-            } });
-        return view;
-    }
-    /** #2942: create_instance with runtime "windows" from an agent: validated like the web, then held for General. */
-    async requestWindowsCreate(requester, rawArgs) {
-        const cfg = this.fleetConfig;
-        if (!cfg)
-            throw new Error("Fleet configuration is unavailable");
-        let parsed;
-        try {
-            parsed = parseNativeInstanceCreate(rawArgs);
-        }
-        catch {
-            throw new Error("Invalid Windows agent request: check the directory, sandbox, backend and model");
-        }
-        // The web's own projection: the same validation, topic target and diff the admin's dashboard confirmation shows.
-        let diff;
-        try {
-            diff = prepareSettingsEffect("POST", "/ui/instances", rawArgs, { config: cfg, classic: {} }).diff;
-        }
-        catch {
-            throw new Error("Invalid Windows agent request: its topic connection is not one this fleet can use");
-        }
-        if (!diff)
-            throw new Error("Invalid Windows agent request");
-        return this.proposeAgentWindowsChange({ requester, key: diff.fingerprint, fingerprint: diff.fingerprint, summary: diff.summary,
-            machineId: parsed.input.machineId, bytes: JSON.stringify(rawArgs).length,
-            // The General card is the confirmation for an agent's request, whatever the requested connection (a topic or none).
-            authority: { connections: diff.authority?.connections ?? [], primaryGeneral: true, unknown: false },
-            apply: (allowed, execution) => createNativeWindowsInstance(this, parsed, allowed, execution) });
-    }
-    /** #2942: update_instance_config on a Windows agent: only the fields the web editor allows, held for General. */
-    async requestWindowsConfig(requester, name, patch) {
-        const inst = this.fleetConfig?.instances[name];
-        if (!isWindowsInstance(inst))
-            throw new Error("Windows agent not found");
-        let edit;
-        try {
-            edit = NativeInstanceConfigEdit.parse(patch);
-        }
-        catch {
-            throw new Error("Invalid Windows agent settings: display_name, description and model only");
-        }
-        const before = { display_name: inst.display_name ?? "", description: inst.description ?? "", model: inst.model ?? "" };
-        const changed = Object.keys(edit).filter(key => edit[key] !== before[key]);
-        if (!changed.length)
-            throw new Error("Nothing to change: these settings already have these values");
-        const summary = changed.map(key => `${name} ${key}: ${settingsDisplay(before[key])} → ${settingsDisplay(edit[key])}`);
-        const machineId = typeof inst.machine_id === "string" ? inst.machine_id : undefined;
-        // #2973 review (Prism P1): a persistent pane is bound to a chat connection; changing it (a model change restarts it)
-        // needs that connection's admins as well as the primary General's, exactly as its creation did. An instance whose
-        // binding names no single configured connection is refused (fail closed), never confirmed by the General alone.
-        const connections = [];
-        if (isNativePaneInstance(inst) || inst.channel_id !== undefined) {
-            const bound = inst.channel_id, channels = this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : []);
-            if (typeof bound !== "string" || channels.filter(ch => (ch.id ?? ch.type) === bound).length !== 1)
-                throw new Error("This Windows agent's chat connection cannot be resolved; change its settings in the web dashboard");
-            connections.push(bound);
-        }
-        return this.proposeAgentWindowsChange({ requester, key: `${name}:${settingsFingerprint(edit)}`, fingerprint: settingsFingerprint([name, edit]),
-            summary, machineId, bytes: JSON.stringify(edit).length, authority: { connections, primaryGeneral: true, unknown: false },
-            // #2973 review (Prism P2): the update may wait for its lifecycle turn; if the agent is rebound meanwhile (B → C), the
-            // approval for B must not stop or change it on C. Pin the approved target and require the execution's snapshot to be
-            // unchanged before every pre-commit effect; the post-commit restart keeps its own (refreshed) checks.
-            apply: (allowed, execution) => {
-                const pinned = { channel: inst.channel_id, machine: inst.machine_id, adapter: inst.native_adapter, runtime: inst.runtime };
-                const sameTarget = () => {
-                    const now = this.fleetConfig?.instances[name];
-                    return !!now && now.channel_id === pinned.channel && now.machine_id === pinned.machine && now.native_adapter === pinned.adapter && now.runtime === pinned.runtime;
-                };
-                // Before the commit: the exact target and an unchanged snapshot. After runtime.update completes the transaction,
-                // current() is false by design; the committed operation's restart receipt then needs the same actor, target and
-                // switch checks plus `completed` — a completed execution can never authorize another write (mutate refuses).
-                return updateNativeWindowsInstance(this, name, edit, () => allowed() && sameTarget() && (execution.completed || execution.current()), execution);
-            } });
-    }
     async promptSettingsChange(store, view) {
         const generation = this.settingsGeneration;
         const authority = this.settingsChatAuthority(store, view.id);
@@ -2975,15 +1821,25 @@ export class FleetManager {
             return;
         }
         const excluded = new Set(store.affectedConnections(view.id));
-        for (const name of Object.keys(this.fleetConfig?.instances ?? {})) {
-            const route = this.settingsGeneralRoute(name, authority.platform, excluded);
-            if (!route)
+        for (const [name, config] of Object.entries(this.fleetConfig?.instances ?? {})) {
+            if (!config.general_topic)
+                continue;
+            const adapterId = this.getInstanceAdapterId(name), adapter = this.getAdapterForInstance(name);
+            const general = this.daemons.get(name);
+            if (!adapterId || !adapter || !general || excluded.has(adapterId) || adapter.type !== authority.platform)
+                continue;
+            const chatId = this.getGroupIdForInstance(name), topic = String(config.topic_id ?? "");
+            if (!chatId || !topic)
                 continue;
-            const { adapterId, adapter, chatId, topic } = route;
             let retired = false, attached = false;
             const postingDeadline = performance.now() + Math.min(5000, view.remaining_ms);
-            const current = () => !retired && (attached || performance.now() < postingDeadline) && this.settingsGeneration === generation
-                && route.current() && authority.current();
+            const current = () => !retired && (attached || performance.now() < postingDeadline) && !this.shuttingDown && this.settingsGeneration === generation
+                && this.fleetConfig?.instances[name]?.general_topic === true
+                && this.daemons.get(name) === general && !this.ipcStoppingInstances.has(name)
+                && this.adapterState.get(adapterId)?.status === "connected"
+                && this.getInstanceAdapterId(name) === adapterId && this.getAdapterForInstance(name) === adapter
+                && this.getGroupIdForInstance(name) === chatId && String(this.fleetConfig?.instances[name]?.topic_id ?? "") === topic
+                && authority.current();
             if (!current())
                 continue;
             try {
@@ -2993,7 +1849,7 @@ export class FleetManager {
                         t("settings_confirm.requester", view.requested_by), ...view.summary].join("\n"),
                     choices: [{ action: "confirm", label: t("settings_confirm.confirm_button") }, { action: "reject", label: t("settings_confirm.reject_button") }],
                     expiredText: t("settings_confirm.no_longer_pending"), timeoutMs: view.remaining_ms,
-                    extra: { pendingChangeId: view.id, confirmationCurrent: current, confirmationAdmin: userId => current() && authority.admin(userId), confirmationStop: route.followStop },
+                    extra: { pendingChangeId: view.id, confirmationCurrent: current, confirmationAdmin: userId => current() && authority.admin(userId) },
                 });
                 void posted.then(nonce => {
                     if (!retired)
@@ -3261,7 +2117,6 @@ export class FleetManager {
         try {
             const view = await this.settingsGate().store.decide(entry.pendingChangeId, action, {
                 label: t("settings_confirm.admin_label", data.userId ?? ""),
-                followStop: entry.confirmationStop,
                 current: () => entry.confirmationCurrent?.() === true && this.getAdapterForInstance(entry.instanceName) === entry.adapter
                     && !!data.userId && entry.confirmationAdmin?.(data.userId) === true,
             });
@@ -3334,6 +2189,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;
@@ -3356,6 +2227,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;
@@ -3636,15 +2508,12 @@ export class FleetManager {
     }
     /** Synchronous SQLite admission; the caller may acknowledge only after this returns. */
     admitDurableDelivery(input) {
-        const bindingHold = this.generalLocationDeliveryHold(input.targetInstance);
-        if (bindingHold)
-            throw Error(bindingHold);
         const outbox = this.deliveryOutbox;
         if (!outbox)
             throw new Error("Durable delivery store is unavailable");
-        const currentSourceBootId = this.getDaemonBootId(input.sourceInstance);
-        const sourceDaemonBootId = input.sourceDaemonBootId ?? currentSourceBootId;
-        if (!currentSourceBootId || !sourceDaemonBootId || currentSourceBootId !== sourceDaemonBootId) {
+        const source = this.daemons.get(input.sourceInstance);
+        const sourceDaemonBootId = input.sourceDaemonBootId ?? source?.bootId;
+        if (!source || !sourceDaemonBootId || source.bootId !== sourceDaemonBootId) {
             throw new Error("Source daemon generation is no longer current; outcome is unknown");
         }
         const sourceKey = `mcp:${input.sourceInstance}:${input.operationId}:${input.targetInstance}:${input.targetSession ?? ""}:${input.kind}`;
@@ -3678,7 +2547,7 @@ export class FleetManager {
         const human = (item) => {
             if (!item.authority || !state)
                 return item;
-            const authority = this.receiptAuthorityNow(item.authority, state);
+            const authority = authorityNow(item.authority, state);
             return { ...item, authority, ...(authority.downgraded ? { source_instance: "human:web:unknown" } : {}) };
         };
         // #1641: a sender that sees only `queued` cannot tell "next in line" from "the target is stuck": say which.
@@ -3707,11 +2576,6 @@ export class FleetManager {
         return this.daemons.get(target)?.notAcceptingReason?.() ?? null;
     }
     getDaemonBootId(instanceName) {
-        if (this.generalLocationDeliveryHold(instanceName))
-            return undefined;
-        if (isNativeExecInstance(this.fleetConfig?.instances[instanceName])) {
-            return !this.shuttingDown && windowsCliEnabled() && this.nativeMcpStore?.hasActive(instanceName) ? this.managerBootId : undefined;
-        }
         return this.daemons.get(instanceName)?.bootId;
     }
     markDurableResponseDelivered(sourceInstance, operationId) {
@@ -3720,21 +2584,11 @@ export class FleetManager {
     /** Called after a replacement Daemon object is installed in lifecycle.daemons. */
     onDaemonReady(name, daemonBootId) {
         const daemon = this.daemons.get(name);
-        if (daemon?.bootId === daemonBootId) {
+        if (daemon?.bootId === daemonBootId)
             this.listenForWorkingState(name, daemon);
-            const cfg = this.fleetConfig?.instances[name];
-            if (cfg?.general_topic && !this.generalLocationFlights.has(name) && daemon.getProcessStatus() === "running"
-                && (!isNativePaneInstance(cfg) || daemon.nativePaneCurrent())) {
-                try {
-                    if (this.generalBindings().completeSelected(name, cfg)) {
-                        this.needsYou?.poke();
-                        this.logger.info({ name }, "General location's selected start receipt settled after recovery");
-                    }
-                }
-                catch (err) {
-                    this.logger.warn({ name, err }, "General location start receipt remains held");
-                }
-            }
+        // #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.
@@ -3879,15 +2733,6 @@ export class FleetManager {
         this.deliveryPumpRunning = true;
         this.deliveryPumpScheduled = false;
         try {
-            // Native workers have no resident daemon to wake. Pending durable work resumes their logical instance;
-            // the Windows bridge still owns the single physical execution slot.
-            for (const target of new Set(outbox.listPending().map(row => row.targetInstance))) {
-                if (isNativeExecInstance(this.fleetConfig?.instances[target])) {
-                    const runtime = this.nativeInstanceRuntime(), agent = runtime.get(target);
-                    if (agent?.paused && !agent.blocked)
-                        runtime.setPaused(target, false);
-                }
-            }
             outbox.expireStale(undefined, undefined, target => {
                 const failure = this.wakeCoordinator?.wakeFailure(target);
                 return failure ? `target could not be woken (${failure})` : undefined;
@@ -3900,7 +2745,7 @@ export class FleetManager {
                 // Phase 2c: a lane a queue worker owns is never claimed here.
                 target => this.queueWorkers.has(target) || this.isInstanceRestarting(target) || this.wakeCoordinator?.blocksClaim(target)
                     ? null
-                    : this.deliveryBootId(target), this.activeDurableTargets, row => this.recoveryDeliveryEligible(row));
+                    : this.daemons.get(target)?.bootId ?? null, this.activeDurableTargets, row => this.recoveryDeliveryEligible(row));
                 if (!claimed)
                     break;
                 this.activeDurableTargets.add(claimed.targetInstance);
@@ -3961,7 +2806,7 @@ export class FleetManager {
             wanted: () => this.deliveryWorkerMode(target) === "on",
             available: () => !this.shuttingDown && this.deliveryOutbox?.isOpen === true,
             blocked: () => this.isInstanceRestarting(target) || this.wakeCoordinator?.blocksClaim(target) === true,
-            daemonBootId: () => this.deliveryBootId(target),
+            daemonBootId: () => this.daemons.get(target)?.bootId ?? null,
             claim: bootId => this.deliveryOutbox?.claimNext(this.managerBootId, candidate => candidate === target ? bootId : null, new Set(), row => this.recoveryDeliveryEligible(row)),
             tryAcquireBudget: () => {
                 if (this.activeDurableTargets.size >= 8)
@@ -3992,10 +2837,6 @@ export class FleetManager {
         const outbox = this.deliveryOutbox;
         if (!outbox)
             return;
-        if (isNativeExecInstance(this.fleetConfig?.instances[claimed.targetInstance])) {
-            await this.dispatchNativeDurableDelivery(claimed);
-            return;
-        }
         const target = claimed.targetInstance;
         const attempt = claimed.attemptNo;
         const payload = { ...claimed.payload };
@@ -4077,85 +2918,6 @@ export class FleetManager {
         }
         await laneReleased;
     }
-    /** The ordinary durable lane, with provider completion proof instead of terminal/IPC submission proof. */
-    async dispatchNativeDurableDelivery(claimed) {
-        const outbox = this.deliveryOutbox;
-        if (!outbox)
-            return;
-        const { deliveryId, targetDaemonBootId, attemptNo, targetInstance: target } = claimed;
-        let begun = false;
-        try {
-            if (["raw_paste", "steer"].includes(claimed.kind)) {
-                if (outbox.begin(deliveryId, targetDaemonBootId, attemptNo) === "begun")
-                    outbox.complete(deliveryId, targetDaemonBootId, attemptNo, "failed", "Windows runtime does not support terminal input or steering");
-                return;
-            }
-            const meta = claimed.payload.meta && typeof claimed.payload.meta === "object" ? claimed.payload.meta : {};
-            const task = await this.nativeInstanceRuntime().execute(target, { ...claimed.payload, requestId: deliveryId, meta: { ...meta, from_instance: claimed.sourceInstance, correlation_id: claimed.correlationId } }, {
-                stillCurrent: () => !this.shuttingDown,
-                beforeStart: () => { if (outbox.begin(deliveryId, targetDaemonBootId, attemptNo) !== "begun")
-                    throw new Error("Windows delivery attempt is no longer current"); begun = true; },
-            });
-            const outcome = task.outcomeConfirmed === false ? "uncertain" : task.status === "completed" ? "delivered" : "failed";
-            outbox.complete(deliveryId, targetDaemonBootId, attemptNo, outcome, task.error || task.status);
-            // Return a requested peer report when the provider did not explicitly report it through scoped MCP.
-            if (meta.requires_reply === "true" && claimed.correlationId && !task.reportedCorrelationIds?.includes(claimed.correlationId) && this.fleetConfig?.instances[claimed.sourceInstance]) {
-                const text = (task.status === "completed" ? task.output : `Windows task ${task.status}: ${task.error || task.output}`).slice(0, 8000);
-                outbox.admit({ sourceKey: `native-result:${deliveryId}`, operationId: `native-result:${deliveryId}`, sourceInstance: target, sourceDaemonBootId: this.managerBootId,
-                    targetInstance: claimed.sourceInstance, kind: "fleet_inbound", correlationId: claimed.correlationId,
-                    payload: { type: "fleet_inbound", content: text || "Windows task completed without text output", meta: { from_instance: target, correlation_id: claimed.correlationId, requires_reply: "false", source: "native_runtime" } } });
-                this.scheduleDeliveryOutboxPump();
-            }
-        }
-        catch (error) {
-            const reason = error instanceof Error ? error.message : String(error);
-            if (begun)
-                outbox.complete(deliveryId, targetDaemonBootId, attemptNo, "uncertain", reason);
-            else
-                outbox.retryBeforeBegin(deliveryId, targetDaemonBootId, attemptNo, reason, 5000);
-            this.logger.warn({ target, deliveryId, err: reason }, "Windows durable delivery did not complete");
-        }
-    }
-    /** A runtime's persisted completion can outlive this manager. Resolve its original delivery fence, never send
-     * the prompt again, and reconstruct a missing peer report using the same durable operation ID. */
-    reconcileRemoteDelivery(machineId, task) {
-        const outbox = this.deliveryOutbox;
-        if (!outbox?.isOpen || !task.finishedAt || task.outcomeConfirmed !== true || !["completed", "failed", "cancelled"].includes(task.status))
-            return;
-        const key = `${task.id}:${task.finishedAt}:${task.status}`;
-        if (this.reconciledRemoteResults.has(key))
-            return;
-        const row = outbox.get(task.id);
-        if (!row || !isNativeExecInstance(this.fleetConfig?.instances[row.targetInstance]) || this.fleetConfig?.instances[row.targetInstance]?.machine_id !== machineId
-            || !row.targetDaemonBootId || this.activeDurableTargets.has(row.targetInstance))
-            return;
-        if (row.state === "submission_started" || row.state === "reconciliation_pending") {
-            if (!outbox.complete(row.deliveryId, row.targetDaemonBootId, row.attemptNo, task.status === "completed" ? "delivered" : "failed", task.error || "Runtime completion recovered after reconnect"))
-                return;
-        }
-        else if (row.state === "uncertain" && task.status === "completed") {
-            if (outbox.markConsumed(row.deliveryId, row.targetDaemonBootId, row.attemptNo, "turn", "Paired runtime journal confirmed this exact execution completed") === "ignored")
-                return;
-        }
-        else if (row.state !== "delivered" && row.state !== "failed")
-            return;
-        const meta = row.payload.meta && typeof row.payload.meta === "object" ? row.payload.meta : {};
-        if (meta.requires_reply !== "true" || !row.correlationId || !this.fleetConfig?.instances[row.sourceInstance]) {
-            this.reconciledRemoteResults.add(key);
-            return;
-        }
-        const reports = outbox.queryStatusForInstance(row.targetInstance, { correlationId: row.correlationId, limit: 100 }).items;
-        if (reports.some(report => report.source_instance === row.targetInstance && report.target_instance === row.sourceInstance
-            && report.kind === "report" && !["failed", "cancelled"].includes(report.state))) {
-            this.reconciledRemoteResults.add(key);
-            return;
-        }
-        const text = (task.status === "completed" ? task.output : `Windows task ${task.status}: ${task.error || task.output}`).slice(0, 8000);
-        outbox.admit({ sourceKey: `native-result:${row.deliveryId}`, operationId: `native-result:${row.deliveryId}`, sourceInstance: row.targetInstance, sourceDaemonBootId: this.managerBootId,
-            targetInstance: row.sourceInstance, kind: "fleet_inbound", correlationId: row.correlationId,
-            payload: { type: "fleet_inbound", content: text || "Windows task completed without text output", meta: { from_instance: row.targetInstance, correlation_id: row.correlationId, requires_reply: "false", source: "native_runtime" } } });
-        this.reconciledRemoteResults.add(key);
-    }
     async waitForDurableLaneRelease(claimed) {
         const outbox = this.deliveryOutbox;
         if (!outbox)
@@ -4612,7 +3374,6 @@ export class FleetManager {
         this.warnAboutRemovedLoginMode(loaded);
         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
         // 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);
@@ -4666,6 +3427,7 @@ export class FleetManager {
      * guild channel.
      */
     reregisterClassicChannels() {
+        this.agentCredentialsCache?.observePolicies();
         if (!this.classicChannels)
             return;
         const channels = this.classicChannels.getAll();
@@ -5041,8 +3803,6 @@ export class FleetManager {
     }
     /** Get the adapter bound to an instance, falling back to primary adapter */
     getAdapterForInstance(name) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name]))
-            return null;
         const worldId = this.getInstanceAdapterId(name);
         if (worldId)
             return this.worlds.get(worldId)?.adapter ?? this.adapter;
@@ -5105,8 +3865,6 @@ export class FleetManager {
     }
     /** Get the group_id for an instance's bound adapter */
     getGroupIdForInstance(name) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name]))
-            return "";
         const adapterId = this.getInstanceAdapterId(name);
         const world = adapterId ? this.worlds.get(adapterId) : undefined;
         return world?.groupId ?? String(this.getChannelConfig(adapterId)?.group_id ?? "");
@@ -5143,8 +3901,6 @@ export class FleetManager {
      */
     getInstanceAdapterId(name) {
         const cfg = this.fleetConfig?.instances[name];
-        if (isNativeExecInstance(cfg))
-            return undefined;
         if (cfg)
             return cfg.channel_id ?? this.getPrimaryAdapterId();
         if (this.classicChannels?.getChannelIdByInstance(name) !== undefined) {
@@ -5172,32 +3928,9 @@ export class FleetManager {
         this.instanceWorldBinding.set(name, adapterId);
     }
     getInstanceStatus(name) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
-            try {
-                return this.nativeInstanceRuntime().status(name);
-            }
-            catch {
-                return "crashed";
-            }
-        }
         if (this.lifecycle.isPaused(name))
             return "paused";
         const daemon = this.lifecycle.daemons.get(name);
-        if (isNativePaneInstance(this.fleetConfig?.instances[name])) {
-            const config = this.fleetConfig.instances[name];
-            if (config.machine_id ? !remoteRuntimeEnabled() : !localWindowsCliEnabled())
-                return "stopped";
-            if (daemon) {
-                const native = daemon, status = native.getProcessStatus?.() ?? "crashed";
-                return status === "running" && native.nativePaneCurrent?.() !== true ? "crashed" : status;
-            }
-            try {
-                return this.nativeInstanceRuntime().get(name)?.activeId ? "crashed" : "stopped";
-            }
-            catch {
-                return "crashed";
-            }
-        }
         const processStatus = this.instanceProcessStatus.get(name);
         // IPC can be disconnected during a respawn, so the event which announces
         // the new live pane may be missed.  The in-process daemon is authoritative
@@ -5231,14 +3964,6 @@ export class FleetManager {
         }
     }
     getInstanceExecutionState(name) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
-            try {
-                return this.nativeInstanceRuntime().execution(name);
-            }
-            catch {
-                return null;
-            }
-        }
         if (this.lifecycle.isPaused(name))
             return null;
         // Process status wins over a stale pane snapshot. A dead remain-on-exit pane
@@ -5249,8 +3974,6 @@ export class FleetManager {
     }
     /** Pure read of the single daemon-owned observation; no probe/capture or second tracker. */
     getInstanceInteraction(name) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name]))
-            return null;
         if (this.lifecycle.isPaused(name) || this.instanceProcessStatus.has(name))
             return null;
         const daemon = this.lifecycle.daemons.get(name);
@@ -5338,8 +4061,6 @@ export class FleetManager {
                 bindings.push([name, backend, profile]);
         };
         for (const [name, config] of Object.entries(this.fleetConfig?.instances ?? {})) {
-            if (isWindowsInstance(config))
-                continue; // Windows sign-ins and usage do not belong to the Linux account.
             // loadFleetConfig() has already merged the fleet default into each row.
             const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
             add(name, backend, instanceCredentialProfile(config, this.fleetConfig?.defaults, backend));
@@ -5397,6 +4118,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); }
     /**
@@ -5946,8 +4674,6 @@ export class FleetManager {
      * id is no platform message, and the echo is the fleet's own post. The web send calls this on the echo's lane.
      */
     startWebChatProgress(instanceName) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[instanceName]))
-            return Promise.resolve();
         if (this.shuttingDown)
             return Promise.resolve();
         return this.sendCancelButton(instanceName);
@@ -6213,12 +4939,6 @@ export class FleetManager {
     }
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     async deliverToInstance(instanceName, payload, options = {}) {
-        if (this.generalLocationDeliveryHold(instanceName))
-            return false;
-        if (isNativeExecInstance(this.fleetConfig?.instances[instanceName])) {
-            return this.nativeInstanceRuntime().deliver(instanceName, payload, { stillCurrent: options.stillCurrent,
-                ...(options.authorityCurrent ? { authorityCurrent: options.authorityCurrent } : {}) });
-        }
         const deliveryEpoch = this.getDeliveryEpoch(instanceName);
         const deliveryPayload = { ...payload, delivery_epoch: deliveryEpoch };
         const meta = payload.meta && typeof payload.meta === "object"
@@ -6776,10 +5496,6 @@ export class FleetManager {
      * slot admission and joins any wake already in flight for the target.
      */
     async explicitWake(name, timeoutMs = 30_000, retryStoppedSession = false) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
-            this.nativeInstanceRuntime().setPaused(name, false);
-            return;
-        }
         if (this.sessionOomStopped(name)) {
             if (!retryStoppedSession)
                 throw new SessionOomStoppedError(false, readSessionOomStop(this.getInstanceDir(name)));
@@ -6804,10 +5520,6 @@ export class FleetManager {
             .sort((a, b) => (readLastInboundAt(this.getInstanceDir(a)) ?? 0) - (readLastInboundAt(this.getInstanceDir(b)) ?? 0))[0];
     }
     async changeInstancePauseState(name, action) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
-            this.nativeInstanceRuntime().setPaused(name, action === "pause");
-            return action === "pause" ? "paused" : "awake";
-        }
         if (action === "wake") {
             await this.explicitWake(name, 30_000, true);
             this.enforceWarmCap(name); // manual wake still respects the fleet warm cap
@@ -6834,6 +5546,7 @@ export class FleetManager {
     }
     classicBehaviorUpdate(instanceName) {
         return {
+            quota_notice: this.classicChannels?.getQuotaNoticeByInstance?.(instanceName) ?? null,
             reply_triggers: this.classicChannels?.getReplyTriggersByInstance(instanceName, this.fleetConfig?.defaults?.reply_triggers) ?? DEFAULT_REPLY_TRIGGERS,
             tool_progress: this.classicChannels?.getToolProgressByInstance(instanceName, this.fleetConfig?.defaults?.tool_progress) ?? "off",
             reply_completion_guard: this.classicChannels?.getReplyCompletionGuardByInstance(instanceName, this.fleetConfig?.defaults?.reply_completion_guard) ?? true,
@@ -6985,14 +5698,6 @@ export class FleetManager {
     resumePaused = false, 
     /** Phase 2a: the caller's transition, for a start made from inside a restart or wake. */
     transition, execution, kiroMigration) {
-        if (isNativeExecInstance(config)) {
-            execution?.assert();
-            if (!windowsCliEnabled())
-                throw new Error("Windows runtime is disabled");
-            if (resumePaused)
-                this.nativeInstanceRuntime().setPaused(name, false);
-            return;
-        }
         const migration = this.kiroMigrationRuns?.get(name);
         if (migration && migration.token !== kiroMigration)
             throw new Error(t("kiro_migrate.in_progress"));
@@ -7043,29 +5748,27 @@ export class FleetManager {
             if (resumePaused)
                 this.lifecycle.markActivitySeedNow(name);
             const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
-            // #1490 row 67 (main): off-loop resolve before skill/instruction publication
+            // #1490 row 67: off-loop resolve before skill/instruction publication
             // constructs a backend (resolveKnowledgeWorkDir). Capture stop/lifecycle
             // ownership first: a Stop during this wait finishes and bumps the epoch,
             // and the inner lifecycle check would otherwise capture the new epoch and
             // accept the stale start. Lifecycle start looks up again before its own
-            // createBackend; the probe cache makes that cheap. (alpha: a native Windows
-            // agent's CLI is on that PC — nothing to resolve on this one.)
+            // createBackend; the probe cache makes that cheap.
             const epoch = this.lifecycle.epochOf(name);
             const stopGen = this.explicitStopGeneration.get(name) ?? 0;
-            const windows = isWindowsInstance(config);
-            const resolved = windows ? null : await resolveBackendBinary(backend);
+            const resolved = await resolveBackendBinary(backend);
             execution?.assert();
             if (this.lifecycle.epochOf(name) !== epoch
                 || (this.explicitStopGeneration.get(name) ?? 0) !== stopGen) {
                 throw new SupersededStartError(name);
             }
             const binary = BACKEND_INSTALLATION_INFO[backend]?.binary;
-            if (binary && !windows)
+            if (binary)
                 noteResolvedBinary(binary, resolved ?? binary);
-            if (!windows && config.general_topic) {
+            if (config.general_topic) {
                 this.ensureGeneralInstructions(config.working_directory, backend, name);
             }
-            else if (!isWindowsInstance(config) && kind === "fleet-topic") {
+            else if (kind === "fleet-topic") {
                 // Workers get only role-eligible on-demand skills. Classic instances are
                 // deliberately excluded: their workspace and conversation lifecycle are
                 // managed independently from fleet-topic workers.
@@ -7080,7 +5783,7 @@ export class FleetManager {
                     this.logger.warn({ err, name, backend }, "Failed to sync worker skills — continuing startup");
                 }
             }
-            else if (!isWindowsInstance(config) && kind === "classic") {
+            else if (kind === "classic") {
                 // #2163: a Classic bot gets only the skills marked `classic` (its own look, the dashboard) — never the fleet's
                 // coordination playbooks (#557 kept those out of end-user bots) — and only into a workspace AgEnD manages: the
                 // room's own folder under <AGEND_HOME>/workspaces/. Anywhere else, nothing is written; `agend-agent skill <name>`
@@ -7097,7 +5800,7 @@ export class FleetManager {
                 }
             }
             const receipt = execution ? this.classicSettingsOwners.get(execution) : undefined;
-            const identity = { kind, backend, model: isWindowsInstance(config) ? config.model || "default" : this.resolveInstanceModel(name).display };
+            const identity = { kind, backend, model: this.resolveInstanceModel(name).display };
             if (receipt) {
                 await this.lifecycle.start(name, config, topicMode, identity, transition, execution, daemon => {
                     // Only this transition's actual publication can acquire its replacement.
@@ -7167,7 +5870,7 @@ export class FleetManager {
         // them before grouping/staggering: startInstance() retains its own guard as
         // a final backstop, but putting a no-op entry in this queue still consumes a
         // full stagger slot for every distinct working directory.
-        const runnableEntries = entries.filter(([name, config]) => !isNativeExecInstance(config) && !this.lifecycle.isPaused(name));
+        const runnableEntries = entries.filter(([name]) => !this.lifecycle.isPaused(name));
         // ClassicBot rooms queue with the fleet instances, at the same pressure pacing (#2642 follow-up): they used to start
         // only after the whole fleet, the chat connections, topics and icons. A name the fleet also configures is the fleet's.
         const fleetNames = new Set(entries.map(([name]) => name));
@@ -7233,8 +5936,6 @@ export class FleetManager {
                 return false;
             if (err instanceof SessionOomStoppedError)
                 await this.notifySessionOomStop(name);
-            if (this.holdNativePaneRecovery(name, err))
-                return false;
             if (this.stopOnUnsupportedCli(name, err, what))
                 return false;
             this.logger.error({ err, name }, `Failed to start ${what}`);
@@ -7376,8 +6077,6 @@ export class FleetManager {
             if (err instanceof SupersededStartError)
                 return;
             // An earlier attempt could not tell (unknown probe); this one could.
-            if (this.holdNativePaneRecovery(name, err))
-                return;
             if (this.stopOnUnsupportedCli(name, err, "instance"))
                 return;
             this.logger.error({ err, name, attempt: attempt + 1 }, "Automatic startup retry failed");
@@ -7522,6 +6221,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
@@ -7628,7 +6338,7 @@ export class FleetManager {
         return count;
     }
     configuredStartupInstanceNames(fleet, includeClassic) {
-        const names = new Set(Object.entries(fleet.instances).filter(([, config]) => !isNativeExecInstance(config)).map(([name]) => name));
+        const names = new Set(Object.keys(fleet.instances));
         if (includeClassic) {
             for (const channel of this.classicChannels?.getAll() ?? [])
                 names.add(channel.instanceName);
@@ -7679,10 +6389,6 @@ export class FleetManager {
         return poster.postCompletion({ resolveAdapter: () => this.readyProgressAdapter(adapterId), chatId, threadId }, text);
     }
     async stopInstance(name, transition) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
-            this.nativeInstanceRuntime().setPaused(name, true);
-            return { backgroundWorkEnded: false };
-        }
         this.explicitStopGeneration.set(name, (this.explicitStopGeneration.get(name) ?? 0) + 1);
         this.cancelStartupRetry(name);
         this.failoverActive.delete(name);
@@ -7722,16 +6428,6 @@ export class FleetManager {
     async restartSingleInstance(name, opts) {
         if (opts?.ownerCurrent && !opts.ownerCurrent())
             throw new RestartSupersededError(this.shownInstanceName(name));
-        if (isNativeExecInstance(this.fleetConfig?.instances[name])) {
-            const runtime = this.nativeInstanceRuntime();
-            if (runtime.get(name)?.blocked)
-                throw new Error("Verify the disconnected Windows process stopped and recover this agent before restarting");
-            runtime.cancel(name);
-            runtime.setPaused(name, false);
-            return;
-        }
-        if (opts?.explicit && isNativePaneInstance(this.fleetConfig?.instances[name]))
-            this.lifecycle.resetNativeCrashBudget(name);
         const migration = this.kiroMigrationRuns?.get(name);
         if (migration && migration.token !== opts?.kiroMigration)
             throw new Error(t("kiro_migrate.in_progress"));
@@ -7795,7 +6491,7 @@ export class FleetManager {
         return run;
     }
     isInstanceRestarting(name) {
-        return this.restartsInFlight.has(name) || this.kiroMigrationRuns?.has(name) === true || this.lifecycle?.nativeRecoveryPending?.(name) === true;
+        return this.restartsInFlight.has(name) || this.kiroMigrationRuns?.has(name) === true;
     }
     /** InstanceLifecycleContext: an explicit wake joins the restart in flight. */
     restartInFlight(name) {
@@ -8090,9 +6786,6 @@ export class FleetManager {
             log: () => this.logger.warn("Managed tunnel cleanup requires attention") }));
     }
     publicOwnerCurrent(owner) {
-        // #3008: the outside link is this computer's admin's — while "Allow connections from outside" is on, web-only.
-        if (isOutsideLinkOwner(owner))
-            return !this.shuttingDown && this.outsideOn();
         if (this.shuttingDown || !this.hasFleetAdmins(owner.adapterId) || !this.isFleetAdmin(owner.userId, owner.adapterId))
             return false;
         const configured = (this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : [])).find(ch => (ch.id ?? ch.type) === owner.adapterId);
@@ -8182,11 +6875,7 @@ export class FleetManager {
     }
     getPublicWebLink() {
         this.initializeWebSessions();
-        return this.publicWebLink ??= new PublicWebLink(this.publicWebLinkDeps());
-    }
-    /** The public link's wiring to this fleet (a test builds one with the tunnel itself stubbed: `ensure`, `provider`). */
-    publicWebLinkDeps() {
-        return {
+        return this.publicWebLink ??= new PublicWebLink({
             dataDir: this.dataDir, web: () => this.fleetConfig?.web,
             permitted: owner => this.publicOwnerCurrent(owner),
             reserve: id => this.getTunnelLane().reserve("dashboard", id),
@@ -8219,9 +6908,7 @@ export class FleetManager {
                 if (world && world.adapter === owner.binding)
                     void world.adapter.sendText(owner.chatId, t("dashboard.public_cleanup"), { threadId: owner.threadId }).catch(() => { });
             },
-            onClose: (owner, reason) => { if (isOutsideLinkOwner(owner))
-                this.outsideLinkClosed(reason); },
-        };
+        });
     }
     publicLinkAutoOpen = null;
     /**
@@ -9580,9 +8267,6 @@ export class FleetManager {
         const fleet = this.loadConfig(configPath, { startup: true });
         this.slimFleetConfigAtStartup();
         this.logConfigWarningsAtStartup();
-        this.initializeNativeInstances();
-        // M-2255: from here on a change to the Windows runtimes' switches applies live (observeRuntimeSwitches).
-        this.runtimeEffects = { windows_cli: localWindowsCliEnabled(), remote_runtime: remoteRuntimeEnabled() };
         setLocale(detectLocale(fleet)); // user-facing text language (fleet.yaml defaults.locale / timezone)
         // #1737 review: the marker this boot adopts — the startup clear may only ever clear this one.
         const bootUpdateMarker = updateMarkerIdentity(this.dataDir);
@@ -9605,8 +8289,20 @@ 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");
+        const { getTmuxSocketName: getSocket, isDefaultAgendHome } = await import("./paths.js");
         TmuxManager.setSocketName(getSocket());
+        // M-2457 §7: after a raw downgrade from 2.4, its own tmux server may still run the agents — start none beside it.
+        // main / the 2.3 line ONLY: on the 2.4 line (release/2.3.5-alpha) AgEnD's own server IS the one on `agend` — a
+        // main → alpha sync must keep alpha's side of this block, never both.
+        {
+            const { newerTmuxServer, realGuardDeps, guardMessage } = await import("./bundled-tmux-guard.js");
+            const hit = await newerTmuxServer(realGuardDeps(getAgendHome(), isDefaultAgendHome(), getSocket()));
+            if (hit) {
+                const message = guardMessage(hit);
+                this.logger.error({ socket: hit.socket, confirmed: hit.confirmed }, message);
+                throw new Error(message);
+            }
+        }
         await TmuxManager.ensureSession(getTmuxSession());
         this.tmuxSessionEnsured = true;
         // #2072: what this host can run — probed in the background, published for every picker.
@@ -9614,7 +8310,7 @@ export class FleetManager {
         // Pre-flight (advisory, fire-and-forget): warm the per-backend auth cache
         // before instances spawn, so a CLI that comes up on its sign-in screen gets
         // an instant 🔑 verdict instead of decaying into crash/MCP-died noise.
-        this.lifecycle.primeAuthVerification(Object.values(fleet.instances).filter(config => !isWindowsInstance(config)).map(config => {
+        this.lifecycle.primeAuthVerification(Object.values(fleet.instances).map(config => {
             const backend = config.backend ?? fleet.defaults?.backend ?? "claude-code";
             // #1699 follow-up: each instance's own login — a profile is probed with its own environment.
             return { backend, profile: credentialHomeSpec(backend) ? instanceCredentialProfile(config, fleet.defaults, backend) : null };
@@ -9676,7 +8372,6 @@ export class FleetManager {
         // #1565: the web chat as it was before this process — the configured instances' only (fleet.yaml and ClassicBot
         // rooms), before the dashboard serves anything; from now on every change is written back (off the loop).
         this.restoreWebChat(fleet);
-        this.initializeNativeInstances(true);
         this.startSearchIndex(fleet);
         // Parse-only source monitoring; it does not apply hand-edited Fleet settings.
         this.configHistoryTimer = setInterval(() => this.configHistory?.check(), 1_000);
@@ -9859,7 +8554,7 @@ export class FleetManager {
             }
         }
         // Phase 1: Start general instances first and wait for them
-        const allEntries = Object.entries(fleet.instances).filter(([, config]) => !isNativeExecInstance(config));
+        const allEntries = Object.entries(fleet.instances);
         const generals = allEntries.filter(([_, cfg]) => cfg.general_topic);
         const others = allEntries.filter(([_, cfg]) => !cfg.general_topic);
         const startupProgress = new RestartProgress(this.runnableStartupCount(fleet, topicMode), pendingUpdateProgress?.startedAt ?? startupStartedAt, this.logger, { mode: pendingProgressOperation === "full-restart" ? "reload" : pendingUpdateProgress ? "update" : "restart" });
@@ -9973,6 +8668,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();
@@ -10098,10 +8796,6 @@ export class FleetManager {
             // #named-link-ttl: a named link with auto_open comes back now — after the web listener and the chat connections.
             this.startPublicLinkAutoOpen();
         }
-        // #3008: connections from outside were on when the fleet stopped: the link opens again (its address is new for a
-        // quick link — Settings shows it on this computer).
-        if (this.outsideOn())
-            this.openOutsideLink([0, ...OUTSIDE_LINK_RETRY_MS]);
         // #1266: buttons that ended while AgEnD was down (expired, or chosen before a restart) are shown as ended now.
         // #1823: and polls: a deadline that passed meanwhile closes now (results once); an open one's countdown is redrawn.
         void this.replyButtons()?.sweep().catch(err => this.logger.warn({ err }, "Reply-button sweep failed"));
@@ -10148,6 +8842,214 @@ 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.
+     */
+    quotaNotices = null;
+    stopQuotaObserver = null;
+    quotaNoticePolicy() {
+        const defaults = this.fleetConfig?.defaults.quota_notice;
+        const wanted = defaults?.target ?? "general";
+        const instances = this.fleetConfig?.instances ?? {};
+        const target = wanted === "general"
+            ? Object.entries(instances).find(([name, c]) => c.general_topic === true || name === "general")?.[0]
+            : Object.hasOwn(instances, wanted) ? wanted : undefined;
+        const webOnly = !!this.webOnlyPromptPlace();
+        const config = target ? instances[target] : undefined;
+        const adapterId = target ? this.getInstanceAdapterId(target) : undefined;
+        const groupId = target ? this.getChannelConfig(adapterId)?.group_id : undefined;
+        const ready = !!target && (webOnly || (config?.topic_id != null && !!groupId && !!(this.getAdapterForInstance(target) ?? this.adapter)));
+        return {
+            target: this.shuttingDown ? "" : ready ? target : !target && wanted === "general" && webOnly ? "/notices" : "",
+            destinationBinding: JSON.stringify([webOnly, adapterId, groupId, config?.topic_id]),
+            locale: this.fleetConfig?.defaults.locale ?? getLocale(),
+            subscriptions: this.shuttingDown ? [] : this.activeBackendBindings().flatMap(([name, backend, profile]) => {
+                const provider = usageProviderIdForBackend(backend);
+                if (!provider)
+                    return [];
+                const providerId = profile ? `${provider}:${profile}` : provider;
+                return [{ account: `${backend}:host:${profile ?? ""}`, providerId,
+                        rule: quotaNoticeRule(defaults, backend, instances[name]?.quota_notice ?? this.classicChannels?.getQuotaNoticeByInstance?.(name)) }];
+            }),
+        };
+    }
+    startQuotaBackgroundReads() {
+        if (!this.quotaNotices) {
+            this.quotaNotices = new QuotaNotices({
+                file: join(this.dataDir, "quota-notices.json"), policy: () => this.quotaNoticePolicy(),
+                send: (target, text) => target === "/notices" ? this.recordWebNotice("fleet", text) : this.notifyInstanceTopic(target, text),
+                warn: err => this.logger.warn({ err }, "Optional quota reminders held: could not retain dispatch state"),
+            });
+            this.stopQuotaObserver = onUsageSnapshot(payload => { void this.quotaNotices?.observe(payload); });
+        }
+        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)
@@ -10623,6 +9525,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) => {
@@ -10776,6 +9683,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) => {
@@ -10865,14 +9777,10 @@ export class FleetManager {
                 }
             }
         }
-        const daemon = this.daemons.get(name);
-        const native = daemon?.usesNativePane?.();
         const sockPath = join(this.getInstanceDir(name), "channel.sock");
-        if (!native && !existsSync(sockPath))
+        if (!existsSync(sockPath))
             return;
-        const ipc = native
-            ? new NativeDaemonClient(daemon, () => this.daemons.get(name) === daemon && (!this.instanceIpcClients.has(name) || this.instanceIpcClients.get(name) === ipc))
-            : new IpcClient(sockPath);
+        const ipc = new IpcClient(sockPath);
         try {
             await ipc.connect();
             this.instanceIpcClients.set(name, ipc);
@@ -10988,7 +9896,7 @@ export class FleetManager {
             // connected, so seed the cache instead of waiting for another transition.
             ipc.send({ type: "query_instance_state", requestId: `fleet-state-${Date.now()}` });
             this.logger.debug({ name }, "Connected to instance IPC");
-            if (!native && !this.statuslineWatcher.has(name)) {
+            if (!this.statuslineWatcher.has(name)) {
                 this.statuslineWatcher.watch(name);
             }
             // Auto-reconnect on disconnect (unless intentionally stopping)
@@ -11516,6 +10424,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.
      */
@@ -12035,12 +10971,6 @@ export class FleetManager {
                 if (msg.adapterId)
                     this.bindInstanceAdapter(generalInstance, msg.adapterId, true);
                 const inboundAdapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-                const locationHold = this.generalLocationDeliveryHold(generalInstance);
-                if (locationHold) {
-                    await inboundAdapter.sendText(msg.chatId, locationHold, { threadId: msg.threadId || undefined });
-                    this.needsYou?.poke();
-                    return;
-                }
                 // React immediately — before any other API calls — through the status
                 // path, which tracks Telegram slot ownership and Discord status adds.
                 if (msg.chatId && msg.messageId) {
@@ -12128,13 +11058,6 @@ export class FleetManager {
         if (instanceConfig?.general_topic && await this.topicCommands.handleGeneralCommand(msg, instanceName)) {
             return;
         }
-        const locationHold = this.generalLocationDeliveryHold(instanceName);
-        if (locationHold) {
-            const adapter = this.worlds.get(msg.adapterId ?? "")?.adapter ?? this.adapter;
-            await adapter.sendText(msg.chatId, locationHold, { threadId: msg.threadId || undefined });
-            this.needsYou?.poke();
-            return;
-        }
         // Bind instance to the adapter that delivered this message
         if (msg.adapterId)
             this.bindInstanceAdapter(instanceName, msg.adapterId, true);
@@ -13152,6 +12075,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({
@@ -13162,7 +12090,7 @@ export class FleetManager {
                         tags: payload.tags,
                         ttl_days: payload.ttl_days,
                         created_by: instanceName,
-                        supersedes: payload.supersedes,
+                        supersedes: supersedes.id,
                     });
                     break;
                 }
@@ -13339,6 +12267,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" };
@@ -13354,16 +12297,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.
@@ -13406,6 +12357,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 {
@@ -13463,12 +12416,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}` };
             }
@@ -13622,7 +12575,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}`);
@@ -13652,16 +12606,89 @@ 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.getInstanceAdapterId(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 };
+    }
+    /** 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.getInstanceAdapterId(name);
+        return planInstanceTopicDelete({ name, adapterId, adapter: this.instanceTopicAdapter(adapterId), ...this.topicOwnership() });
     }
     getForumTopicDeleter(adapterId) {
         const adapter = (adapterId ? this.worlds.get(adapterId)?.adapter : undefined) ?? this.adapter;
@@ -14062,9 +13089,9 @@ export class FleetManager {
             Object.assign(current, resolved);
         }
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
+        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
     }
     /** A permission tightening is effective when its save returns, independently of the later apply job or IPC. */
     refreshSavedDashboardPermissions() {
@@ -14298,43 +13325,10 @@ export class FleetManager {
     }
     getSettingsConfigPath() { return this.configPath; }
     async removeInstance(name, authorization, execution) {
-        if (isWindowsInstance(this.fleetConfig?.instances[name])) {
-            execution?.assert();
-            assertExplicitInstanceRemoval(authorization);
-            if (isNativePaneInstance(this.fleetConfig?.instances[name])) {
-                await this.stopInstance(name);
-                execution?.assert();
-            }
-            this.nativeInstanceRuntime().remove(name, () => !this.shuttingDown && (!execution || execution.current()), execution);
-            return;
-        }
         if (execution)
             return this.lifecycle.runTransition(name, transition => this.removeInstanceOwned(name, authorization, execution, transition));
         return this.removeInstanceOwned(name, authorization);
     }
-    /** Shared instance metadata goes with a native identity; its Windows workspace and provider sessions stay intact. */
-    nativeInstanceRemoved(name) {
-        const clean = (what, run) => { try {
-            run();
-        }
-        catch (error) {
-            this.logger.warn({ name, err: error }, `Native instance ${what} cleanup failed`);
-        } };
-        clean("delivery", () => { this.cancelPendingDeliveries(name); });
-        forgetInstanceContext(name);
-        clean("schedules", () => { for (const schedule of this.scheduler?.list(name) ?? [])
-            this.scheduler.delete(schedule.id); });
-        this.lastActivity.delete(name);
-        this.lastInboundUser.delete(name);
-        this.rateLimitWarnedAt.delete(name);
-        this.lastInboundMsg.delete(name);
-        clean("history", () => this.webChatHistory.forget(name));
-        clean("search", () => this.searchIndex?.removeInstance(name));
-        clean("files", () => this.webFiles.forget(name));
-        clean("compact", () => this.compactWatchService?.forget(name));
-        clean("preferences", () => this.webPrefs.forgetInstance(name));
-        clean("appearance", () => { this.themeStore.forget(name); this.webAppearance.forget(name); this.appearanceTools.forget(name); this.mods.forgetInstance(name); this.officeActsInstance?.forget(name); this.officePackToolsInstance?.forget(name); });
-    }
     async removeInstanceOwned(name, authorization, execution, transition) {
         execution?.assert();
         assertExplicitInstanceRemoval(authorization);
@@ -14460,8 +13454,6 @@ export class FleetManager {
         execution?.complete();
     }
     startStatuslineWatcher(name) {
-        if (isWindowsInstance(this.fleetConfig?.instances[name]))
-            return;
         if (this.lifecycle.isPaused(name))
             return;
         this.statuslineWatcher.watch(name);
@@ -15910,10 +14902,6 @@ export class FleetManager {
      * would have to make this async and change every caller.
      */
     notifyInstanceTopic(instanceName, text, extraOpts) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[instanceName])) {
-            this.emitSseEvent("message", { instance: instanceName, role: "status", sender: "AgEnD", text, ts: new Date().toISOString() });
-            return true;
-        }
         // #2910 D2: a web-only fleet has no topics: what the agent's topic would have been told is a Notice about it.
         if (this.webOnlyPromptPlace())
             return this.recordWebNotice("instance", text, instanceName);
@@ -16394,8 +15382,6 @@ export class FleetManager {
      * (also for a backend that has no profiles, where the option is ignored).
      */
     credentialProfileOf(name, backend) {
-        if (isWindowsInstance(this.fleetConfig?.instances[name]))
-            return null;
         if (!credentialHomeSpec(backend))
             return null;
         const cfg = this.fleetConfig?.instances?.[name];
@@ -16418,9 +15404,10 @@ export class FleetManager {
     }
     /** The instances the cache analysis reads: fleet.yaml's, then the ClassicBot rooms (their workspace under the AgEnD home, their own backend). */
     cacheInstances() {
-        const fleet = Object.entries(this.fleetConfig?.instances ?? {}).filter(([, cfg]) => !isWindowsInstance(cfg)).map(([name, cfg]) => ({
+        const fleet = Object.entries(this.fleetConfig?.instances ?? {}).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));
@@ -16432,6 +15419,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()];
     }
@@ -16592,25 +15582,12 @@ 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,
                 usageHold: this.daemons.get(name)?.usageHold?.() ?? null,
-                nativeDeliveryHold: this.daemons.get(name)?.nativeDeliveryHold?.() ?? null,
-                generalLocation: this.generalLocationAttention(name),
-                paneRecovery: (() => {
-                    const config = this.fleetConfig?.instances[name];
-                    if (!isNativePaneInstance(config) || !config.native_agent_id)
-                        return null;
-                    try {
-                        const profile = windowsAgentsFor(this, this.runtimeWindowsExecutor()).get(config.native_agent_id);
-                        return profile.paneRecovery ? { key: `${profile.paneRecovery.kind}:${profile.paneRecovery.launchId ?? "-"}`, detail: new NativePaneRecoveryError(profile.paneRecovery).message, since: profile.paneRecoveryAt ?? profile.createdAt } : null;
-                    }
-                    catch {
-                        return null;
-                    }
-                })(),
             });
         }
         return out;
@@ -16666,8 +15643,6 @@ export class FleetManager {
                 const target = this.fleetNoticeTarget(world);
                 return target ? { chatId: target.chatId, ...(target.opts.threadId !== undefined ? { threadId: String(target.opts.threadId) } : {}) } : null;
             },
-            // The name the web page shows for the instance (its View alias, else its own name), never the raw id alone.
-            instanceName: instance => resolveInstanceIdentity({ cfg: this.fleetConfig?.instances[instance], profile: profileIdentities(this.dataDir).get(instance) }).display_name || instance,
             instanceTopic: instance => {
                 const topic = this.fleetConfig?.instances[instance]?.topic_id;
                 if (topic != null)
@@ -16684,6 +15659,10 @@ 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(),
             configIssues: () => (this.configHistory?.currentIssues() ?? []).map(issue => ({
@@ -17212,7 +16191,7 @@ export class FleetManager {
             isAdmin: (userId, adapterId) => this.adminGate(userId, adapterId) === "ok",
             authorization: input.session ? this.sessionAuthorizationStore()?.get(input.session.handle) ?? null : null,
             policy: { ...webAuthorityPolicy(this.fleetConfig?.web), enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink, quickLink: state.quickLink }, epoch: state.epoch, now: Date.now(),
-            hostOperator: this.isWebOnlyFleet(), outside: this.outsideLink(),
+            hostOperator: this.isWebOnlyFleet(),
         });
     }
     sessionAuthorizations = null;
@@ -17272,269 +16251,6 @@ export class FleetManager {
         const { durable } = store.authorize(session.handle, HOST_OPERATOR, now, state.epoch, now + policy.maxSessionMs, peer);
         this.logger.info({ handle: session.handle, durable }, "Host web session authorized (this computer's admin)");
     }
-    // ── #3008: connections from outside (a web-only fleet; decision 28c2d3a3 rule 3, the user's simplified form) ──
-    webRemoteAccessState = null;
-    /** The authenticator, the outside switch and the wrong-code limiter (web-remote-access.json), read on first use. */
-    webRemoteAccess() {
-        if (!this.dataDir)
-            return null;
-        this.webRemoteAccessState ??= new WebRemoteAccess(join(this.dataDir, WEB_REMOTE_ACCESS_FILE), this.logger);
-        return this.webRemoteAccessState;
-    }
-    /** "Allow connections from outside" is on (an app set up) and this is a web-only fleet. */
-    outsideOn() {
-        return this.isWebOnlyFleet() && (this.webRemoteAccess()?.outside ?? false);
-    }
-    /** The link connections from outside opened, while it is open and still theirs: its exposure. Else null. */
-    outsideLink() {
-        if (!this.outsideOn())
-            return null;
-        const open = this.publicWebLink?.openSignin();
-        return open && isOutsideLinkOwner(open.owner) ? { exposureId: open.exposureId } : null;
-    }
-    /**
-     * The request's live session, asked again each time `current()` is called (its own cookie authenticated anew, the same
-     * handle): this web-only fleet's owner — this computer's admin, on this computer (`hostOnly`), or also signed in from
-     * outside — and web-verified now. Null when it is not (a guest, a LAN session, a chat fleet's admin, nobody).
-     */
-    liveOwner(req, opts) {
-        if (!this.isWebOnlyFleet())
-            return null;
-        if (opts.hostOnly && gatewayRequestContext(req))
-            return null;
-        const auth = authorizeSession(req, this.webToken, this.webSessions, { touch: false });
-        if (auth.kind !== "ok")
-            return null;
-        const handle = auth.session.handle, peer = webPeerOf(req), gateway = !!gatewayRequestContext(req);
-        const owner = () => {
-            if (!this.isWebOnlyFleet())
-                return false;
-            const live = authorizeSession(req, this.webToken, this.webSessions, { touch: false });
-            if (live.kind !== "ok" || live.session.handle !== handle)
-                return false;
-            if (opts.hostOnly && (live.session.host !== true || peer !== "loopback"))
-                return false;
-            const now = this.webAuthority({ session: live.session, gateway, peer });
-            const a = now.authority.kind === "web-verified" && now.authority.session?.handle === handle ? now.authority.actor : null;
-            return !!a && a.adapter_id === HOST_OPERATOR.adapterId && a.user_id === HOST_OPERATOR.userId;
-        };
-        return owner() ? { label: t("settings_confirm.host_operator_label"), handle, current: owner } : null;
-    }
-    /** Every session signed in from outside ends (and the authorizations kept for them). */
-    endOutsideSessions() {
-        const ended = new Set(this.webSessions?.list(undefined, r => r.remote === "totp").map(r => r.handle) ?? []);
-        if (!ended.size)
-            return;
-        this.sessionAuthorizationStore()?.prune(a => !ended.has(a.handle));
-        const result = this.webSessions?.revokeAll(r => r.remote === "totp");
-        if (result && !result.durable)
-            this.logger.warn("Outside sessions ended, but that could not be saved");
-        this.logger.info({ count: ended.size }, "Sessions signed in from outside ended");
-    }
-    /**
-     * #1939 §10 / #3008: a stored receipt's authority as it reads now — the web authority state, and for this computer's
-     * admin from outside the switch and the last revocation of remote authority (Prism P2 2).
-     */
-    receiptAuthorityNow(stored, state = this.webAuthorityState()) {
-        return authorityNow(stored, { ...state, outside: this.outsideOn(), outsideHandles: this.webRemoteAccess()?.admitted ?? new Set() });
-    }
-    /** #3008 (the sign-in page): this exposure is the outside link, open now. */
-    isOutsideLink(exposureId) {
-        return this.outsideLink()?.exposureId === exposureId;
-    }
-    /** What Settings shows: set up or not, the switch, a wait in force, the link — its address only to this computer. */
-    webOutsideStatus(req) {
-        const store = this.webRemoteAccess(), status = store?.status();
-        const here = !!this.liveOwner(req, { hostOnly: true });
-        const open = this.outsideOn() ? this.publicWebLink?.openSignin() : null;
-        const mine = !!open && isOutsideLinkOwner(open.owner);
-        const linkStatus = this.outsideOn() ? this.getPublicWebStatus() : null;
-        return { webOnly: this.isWebOnlyFleet(), here, enrolled: !!status?.enrolled, enrolledAt: status?.enrolledAt ?? null,
-            outside: this.outsideOn(), pausedForMs: status?.pausedForMs ?? 0,
-            link: linkStatus && linkStatus.state !== "closed" ? { ...linkStatus, ...(here && mine ? { url: open.url } : {}), quick: !publicLinkNamedHostname(this.fleetConfig?.web) } : null };
-    }
-    /** Set up (or set up again): a new secret, shown once to this computer's admin. Null: not them. */
-    webOutsideBeginEnrollment(req) {
-        const owner = this.liveOwner(req, { hostOnly: true }), store = this.webRemoteAccess();
-        if (!owner || !store)
-            return null;
-        return store.beginEnrollment(owner.handle, hostname() || "fleet");
-    }
-    /** The new app's first code: on "ok" it replaces the old one, whose sessions from outside end. */
-    webOutsideConfirmEnrollment(req, code) {
-        const owner = this.liveOwner(req, { hostOnly: true }), store = this.webRemoteAccess();
-        if (!owner || !store || !owner.current())
-            return "not_here";
-        const had = store.enrolled;
-        const r = store.confirmEnrollment(owner.handle, code);
-        if (r === "ok") {
-            this.logger.info({ again: had }, "Authenticator app set up for connections from outside");
-            if (had)
-                this.endOutsideSessions();
-        }
-        return r;
-    }
-    /** Forget the app: the switch goes off, the link closes, every session from outside ends. */
-    webOutsideRemove(req) {
-        const owner = this.liveOwner(req, { hostOnly: true }), store = this.webRemoteAccess();
-        if (!owner || !store || !owner.current())
-            return "not_here";
-        // #3008 review (Prism P2 1): shut at once whatever the disk says; say so when it could not be saved (retried).
-        const saved = store.remove();
-        this.closeOutsideLink("outside removed");
-        this.logger.info({ saved }, "Authenticator app removed; connections from outside off");
-        return saved ? "ok" : "unsaved";
-    }
-    /** The switch. On: needs an app set up; the link opens. Off: it closes and every session from outside ends. */
-    webOutsideSwitch(req, on) {
-        const owner = this.liveOwner(req, { hostOnly: true }), store = this.webRemoteAccess();
-        if (!owner || !store || !owner.current())
-            return "not_here";
-        if (on && !publicLinkSettings(this.fleetConfig?.web).allowed)
-            return "not_allowed";
-        const r = store.setOutside(on);
-        if (r === "not_enrolled")
-            return r;
-        this.logger.info({ on, saved: r === "ok" }, "Connections from outside switched");
-        // #3008 review (Prism P2 1): Off shuts at once even when it could not be saved (the store retries); On opens only
-        // once saved — a switch the disk does not hold would not survive a restart.
-        if (!on)
-            this.closeOutsideLink("outside off");
-        else if (r === "ok")
-            this.openOutsideLink([0, ...OUTSIDE_LINK_RETRY_MS]);
-        return r;
-    }
-    outsideAttempt = null;
-    outsideOpening = false;
-    /**
-     * Open the outside link: an attempt after each delay in turn until one opens (#3008 B: twice more at most — the quick
-     * link's address service limits how often it may be asked). Every attempt asks again: the switch still on, the fleet
-     * running. A final failure: one Notice; the switch stays on, so the next start tries again.
-     */
-    openOutsideLink(delays) {
-        this.outsideAttempt?.cancel();
-        this.outsideAttempt = null;
-        const attempt = (n) => {
-            this.outsideAttempt = null;
-            if (this.shuttingDown || !this.outsideOn() || this.outsideOpening)
-                return;
-            this.outsideOpening = true;
-            // 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");
-                    return;
-                }
-                if (outcome === "busy" && this.outsideLink())
-                    return; // already open (ours)
-                if (this.shuttingDown || !this.outsideOn())
-                    return;
-                if (n + 1 < delays.length) {
-                    this.outsideAttempt = outsideTimer(() => attempt(n + 1), delays[n + 1]);
-                    return;
-                }
-                this.logger.warn({ attempts: n + 1 }, "Outside link could not be opened; giving up until the next start or switch");
-                this.recordWebNotice("fleet", t("outside.notice_ended", t("outside.reason_failed")));
-            });
-        };
-        this.outsideAttempt = outsideTimer(() => attempt(0), delays[0] ?? 0);
-    }
-    closeOutsideLink(reason) {
-        this.outsideAttempt?.cancel();
-        this.outsideAttempt = null;
-        const open = this.publicWebLink?.openSignin();
-        if (this.publicWebLink && (!open || isOutsideLinkOwner(open.owner)))
-            void this.publicWebLink.close(reason);
-        this.endOutsideSessions();
-    }
-    /** PublicWebLink.onClose for the outside link: what closed it decides what happens next (#3008 B). */
-    outsideLinkClosed(reason) {
-        if (this.shuttingDown || OUTSIDE_OWN_CLOSES.has(reason) || !this.outsideOn())
-            return;
-        // #3008 review (Prism P2 3): expiry first — its lifetime counts from the opening request, so it can run out while the
-        // opening is still under way: the switch goes off then too, and that attempt's end (outsideOn false) retries nothing.
-        if (reason === "expired") {
-            // Its lifetime ran out: the switch goes off (only this computer turns it on again — a session from outside can't).
-            this.outsideAttempt?.cancel();
-            this.outsideAttempt = null;
-            if (this.webRemoteAccess()?.setOutside(false) === "unsaved")
-                this.logger.warn("Outside link expired; the switch's Off could not be saved yet (retried)");
-            this.endOutsideSessions();
-            this.logger.info("Outside link expired; connections from outside off");
-            this.recordWebNotice("fleet", t("outside.notice_ended", t("outside.reason_expired")));
-            return;
-        }
-        if (this.outsideOpening)
-            return; // that attempt's own failure: its retry
-        // Dropped (the tunnel exited, the gateway failed, the configuration changed): reopened up to twice.
-        this.logger.info({ reason }, "Outside link closed; reopening");
-        this.openOutsideLink(OUTSIDE_LINK_RETRY_MS);
-    }
-    /**
-     * #3008 (auth-api POST /auth/totp): a sign-in through the outside link with the authenticator's code. "ok": the caller
-     * makes the session (SessionRecord.remote) and then calls authorizeOutsideSession. Each wrong code counts; a wait that
-     * starts is a Notice; a code that matches a step just outside the window logs how far this clock seems to be off.
-     */
-    outsideSignIn(exposureId, code) {
-        const link = this.outsideLink(), store = this.webRemoteAccess();
-        if (!link || !store || !exposureId || link.exposureId !== exposureId)
-            return { kind: "closed" };
-        const v = store.verify(code);
-        if (v.kind === "ok")
-            return { kind: "ok" };
-        if (v.kind === "paused")
-            return v;
-        if (v.kind === "not_enrolled")
-            return { kind: "closed" };
-        if (v.kind === "unavailable")
-            return v;
-        if (v.skewSteps !== null)
-            this.logger.warn({ offsetSeconds: v.skewSteps * TOTP_STEP_SECONDS }, "A wrong authenticator code matched a nearby time step: this computer's clock may be off");
-        if (v.paused) {
-            this.logger.warn({ waitMs: v.retryAfterMs }, "Sign-in from outside paused after wrong codes");
-            this.recordWebNotice("fleet", t("outside.notice_paused", outsideDuration(v.retryAfterMs), v.wrong));
-            return { kind: "paused", retryAfterMs: v.retryAfterMs };
-        }
-        return { kind: "wrong" };
-    }
-    /**
-     * #3008: a session just made by outsideSignIn's "ok" is this computer's admin for its authorization's life. False: it
-     * could not be admitted (its handle not saved, #3015 review r3) — the caller ends it.
-     */
-    authorizeOutsideSession(session, peer, label) {
-        const store = this.sessionAuthorizationStore(), link = this.outsideLink();
-        if (!store || session.remote !== "totp" || session.owner || !link || session.exposureId !== link.exposureId)
-            return false;
-        if (!this.webRemoteAccess()?.admit(session.handle)) {
-            this.logger.warn({ handle: session.handle }, "Session from outside not admitted: it could not be saved");
-            return false;
-        }
-        const state = this.webAuthorityState(), now = Date.now(), policy = webAuthorityPolicy(this.fleetConfig?.web);
-        const check = evaluateWebAuthority({
-            session, gateway: true, peer, tokenEpoch: this.webToken ? tokenEpoch(this.webToken) : null,
-            isAdmin: () => false,
-            authorization: { handle: session.handle, owner: HOST_OPERATOR, authorizedAt: now, until: now + policy.maxSessionMs, epoch: state.epoch },
-            policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink, quickLink: state.quickLink }, epoch: state.epoch, now,
-            hostOperator: true, outside: link,
-        });
-        if (check.refusal) {
-            this.logger.info({ handle: session.handle, refusal: check.refusal }, "Session from outside not authorized");
-            return false;
-        }
-        {
-            const live = new Set(this.webSessions?.list(undefined, () => true).map(r => r.handle) ?? []);
-            store.prune(a => a.epoch === state.epoch && now <= Math.min(a.until, a.authorizedAt + policy.maxSessionMs) && live.has(a.handle));
-            const { durable } = store.authorize(session.handle, HOST_OPERATOR, now, state.epoch, now + policy.maxSessionMs, peer);
-            this.logger.info({ handle: session.handle, durable }, "Session from outside authorized (this computer's admin)");
-        }
-        this.recordWebNotice("fleet", t("outside.notice_signed_in", label));
-        return true;
-    }
     authorityStateStore = null;
     /**
      * #1939 §10: the switch, "Only this computer can authorize" and the revocation epoch in force for the configuration as
@@ -17555,10 +16271,6 @@ export class FleetManager {
                     return true;
                 if (session.surface === "local")
                     return false;
-                // #3008 review (Prism P2 4): signed in from outside with the authenticator's code — its opt-in is the outside
-                // switch, not these options (the authority judges it so): it keeps its authorization.
-                if (session.remote === "totp")
-                    return false;
                 const peer = a.peer ?? "named_link";
                 return (!!state.namedLinkClosed && peer === "named_link") || (!!state.quickLinkClosed && peer === "quick_link");
             };
@@ -17665,8 +16377,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);
@@ -17679,6 +16392,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"),
@@ -17708,7 +16422,7 @@ export class FleetManager {
             authorization: s?.owner ? { handle: s.handle, owner: s.owner, authorizedAt: now, until: now + policy.maxSessionMs, epoch: state.epoch } : null,
             policy: { ...policy, enabled: state.enabled, loopbackOnly: state.loopbackOnly, namedLink: state.namedLink, quickLink: state.quickLink }, epoch: state.epoch, now,
             // #2910 D1: a host operator's session is never asked about (no account to ask): only a sign-in authorizes it.
-            hostOperator: this.isWebOnlyFleet(), outside: this.outsideLink(),
+            hostOperator: this.isWebOnlyFleet(),
         });
         return r.refusal;
     }
@@ -18574,8 +17288,6 @@ export class FleetManager {
         publication.retirePending = true;
     }
     async sendCancelButton(instanceName, correlationId, preserveProgress = false) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[instanceName]))
-            return;
         // Post first, retire after (see the tail of this method). Retiring up front
         // meant that from the delete until the new message came back — a chat API
         // round trip, and every reply goes through here — the instance had NO live
@@ -18601,7 +17313,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",
@@ -18624,7 +17343,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.
@@ -18747,14 +17466,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
@@ -18873,6 +17594,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);
@@ -18882,7 +17609,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?.();
         }
     }
@@ -19108,14 +17837,6 @@ export class FleetManager {
     }
     /** Interrupt an instance's current generation (cancel button / /cancel). */
     cancelInstance(instanceName) {
-        if (isNativeExecInstance(this.fleetConfig?.instances[instanceName])) {
-            this.cancelPendingDeliveries(instanceName);
-            const cancelled = this.nativeInstanceRuntime().cancel(instanceName);
-            this.lastInboundMsg.delete(instanceName);
-            for (const message of this.webChatHistory.cancelPending(instanceName))
-                this.emitSseEvent("delivery", { instance: instanceName, messageId: message.messageId, delivery: message.delivery });
-            return cancelled !== null;
-        }
         const daemon = this.daemons.get(instanceName);
         if (!daemon)
             return false;
@@ -19820,9 +18541,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,
         };
@@ -20167,9 +18891,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;
@@ -20333,7 +19060,36 @@ export class FleetManager {
         "antigravity": ".agents/AGENTS.md",
         "mock": "CLAUDE.md",
     };
-    static GENERAL_INSTRUCTIONS = GENERAL_ROLE_INSTRUCTIONS;
+    static GENERAL_INSTRUCTIONS = `# Fleet Coordinator
+
+You are the fleet coordinator — the central entry point for this AgEnD fleet.
+You route tasks, manage instances, enforce policies, and synthesize results.
+Do NOT modify project files directly — delegate file changes to the project's instance.
+You CAN write code snippets, explain code, and answer technical questions directly.
+
+## Task Routing
+
+- **Handle directly**: no file/exec access needed, answerable from knowledge, ≤2 reasoning steps (Q&A, translation, status queries, code snippets).
+- **Delegate to 1 instance**: scoped to one project/repo, needs file access or execution.
+- **Coordinate multiple**: spans repos, outputs feed each other, or parallel helps (max 3 per task).
+
+Instance discovery: start with list_instances(); follow the guidance in its response. Prefer reuse; never duplicate a running instance.
+
+## Reply Contract
+
+Every final response to the user contains: the result (the actual answer or deliverable) and gaps (anything incomplete — omit if none). Summarize instance reports; omit internal coordination noise.
+
+## After Restart
+
+BEFORE processing any new messages: 1. list_instances() 2. list_teams() 3. list_decisions(). Only then handle requests.
+
+## Playbooks (on-demand skills)
+
+Detailed procedures live in your skills — consult them when the situation comes up rather than from memory:
+- **delegation-playbook** — delegation protocol, loop prevention, parallel vs sequential, result/failure handling, team management, instance configuration tips.
+- **development-workflow** — the fleet-wide code-change policy you enforce when delegating code tasks.
+Plus the operational skills (fleet-health, instance-lifecycle, scheduling, session-management, …).
+`;
     /** Ensure the general instance has its project instructions file + knowledge */
     ensureGeneralInstructions(workDir, backendName, instanceName) {
         measureSyncWork("fleet.generalInstructions", () => this.ensureGeneralInstructionsSync(workDir, backendName, instanceName));
@@ -21355,8 +20111,6 @@ export class FleetManager {
                     : model,
         });
         const fleetInstance = this.fleetConfig?.instances[instanceName];
-        if (isWindowsInstance(fleetInstance))
-            return fleetInstance.model?.trim() ? done(fleetInstance.model.trim(), "instance") : done("default", "unresolved", "this CLI does not report a default");
         if (fleetInstance) {
             if (fleetInstance.model?.trim())
                 return done(fleetInstance.model.trim(), "instance");
@@ -21438,7 +20192,7 @@ export class FleetManager {
         if (this.fleetConfig?.defaults?.backend)
             backends.add(this.fleetConfig.defaults.backend);
         for (const inst of Object.values(this.fleetConfig?.instances ?? {}))
-            if (!isWindowsInstance(inst) && inst.backend)
+            if (inst.backend)
                 backends.add(inst.backend);
         for (const ch of this.classicChannels?.getAll() ?? [])
             if (ch.backend)
@@ -21453,8 +20207,6 @@ export class FleetManager {
         // here; a ClassicBot room on a profile is probed on its first /model (catalogProfile knows rooms too).
         const profiles = new Set();
         for (const name of Object.keys(this.fleetConfig?.instances ?? {})) {
-            if (isWindowsInstance(this.fleetConfig?.instances[name]))
-                continue;
             if (this.backendNameForInstance(name) !== "claude-code")
                 continue;
             const profile = this.catalogProfile("claude-code", name);
@@ -21475,8 +20227,6 @@ export class FleetManager {
      * instead of presenting an old list as a fresh one.
      */
     async getModelOptionsWithSource(instanceName, opts = {}) {
-        if (isWindowsInstance(this.fleetConfig?.instances[instanceName]))
-            return { models: (await this.listModelCatalog({ instanceName })).models, source: "cache" };
         const backendName = this.backendNameForInstance(instanceName);
         const profile = this.catalogProfile(backendName, instanceName);
         const cached = this.readCliEnv(backendName, profile);
@@ -21532,21 +20282,6 @@ export class FleetManager {
      */
     async listModelCatalog(opts = {}) {
         const { instanceName } = opts;
-        if (instanceName && isWindowsInstance(this.fleetConfig?.instances[instanceName])) {
-            const config = this.fleetConfig.instances[instanceName], backend = config.backend ?? "codex";
-            // Detection is admin-owned. A read never launches a provider or falls back to this host's account.
-            let inventory = null;
-            try {
-                inventory = await this.runtimeWindowsExecutor().probe({ force: false, machineId: config.machine_id });
-            }
-            catch { /* offline remains unavailable */ }
-            const row = inventory?.clis.find(value => value.id === backend);
-            return { backend, scope: "instance", instance: instanceName, current_model: config.model || null,
-                models: (row?.models ?? []).map(value => ({ id: value.id, label: value.name ?? value.id, ...(value.description ? { description: value.description } : {}) })),
-                source: row?.models?.length ? "cache" : "fallback",
-                ...(inventory?.probedAt ? { probed_at: new Date(inventory.probedAt).toISOString() } : {}),
-                note: "Windows runtime's last detected inventory; no coordinator account or live probe is used." };
-        }
         if (instanceName) {
             const backend = this.backendNameForInstance(instanceName);
             const resolved = this.resolveInstanceModel(instanceName);
@@ -21582,8 +20317,6 @@ export class FleetManager {
     }
     /** Ask a backend for its catalog using ONE instance's real config. Never throws. */
     async instanceScopedModels(instanceName, backend) {
-        if (isWindowsInstance(this.fleetConfig?.instances[instanceName]))
-            return [];
         try {
             const inst = this.fleetConfig?.instances?.[instanceName];
             const instanceDir = this.getInstanceDir(instanceName);
@@ -22221,8 +20954,6 @@ export class FleetManager {
     }
     /** The instance's backend's effort metadata; agy's levels are its model's (#1825), the one the instance runs. */
     instanceEffortMetadata(instanceName) {
-        if (isWindowsInstance(this.fleetConfig?.instances[instanceName]))
-            return { strategy: "unsupported", levels: [] };
         const backend = this.backendNameForInstance(instanceName);
         let model = null;
         if (backend === "antigravity") {
@@ -22233,8 +20964,6 @@ export class FleetManager {
     }
     /** Configured effort for an instance: per-instance, else fleet default, else none. */
     resolveInstanceEffort(instanceName) {
-        if (isWindowsInstance(this.fleetConfig?.instances[instanceName]))
-            return { effort: null, source: "unset" };
         const own = this.fleetConfig?.instances[instanceName]?.effort;
         if (own)
             return { effort: own, source: "instance" };
@@ -22272,11 +21001,9 @@ export class FleetManager {
      * instance respawns.
      */
     async applyEffort(instanceName, requested, opts) {
-        // #1490 row 27 (main): a menu's choice is for the lifecycle it was offered to — asked first and fenced into the restart.
+        // #1490 row 27: a menu's choice is for the lifecycle it was offered to — asked first and fenced into the restart.
         if (opts?.current && !opts.current())
             return t("menu.instance_replaced", this.shownInstanceName(instanceName));
-        if (isWindowsInstance(this.fleetConfig?.instances[instanceName]))
-            return t("effort.unsupported", this.backendNameForInstance(instanceName));
         const level = requested.trim().toLowerCase();
         const backendName = this.backendNameForInstance(instanceName);
         let strategy = "unsupported";
@@ -22324,20 +21051,6 @@ export class FleetManager {
         if (/[\x00-\x1f\x7f]/.test(model)) {
             return t("model.invalid_chars");
         }
-        const native = this.fleetConfig?.instances[instanceName];
-        if (isWindowsInstance(native)) {
-            if (!isNativePaneInstance(native))
-                return WINDOWS_CONFIG_REFUSED;
-            const catalog = await this.listModelCatalog({ instanceName });
-            if (!catalog.models.some(row => row.id === model))
-                return t("model.unknown_name", model, catalog.models.map(row => row.id).join(", "));
-            const id = native.native_agent_id, machine = native.machine_id;
-            await this.updateNativePaneConfig(instanceName, { model }, () => {
-                const now = this.fleetConfig?.instances[instanceName];
-                return isNativePaneInstance(now) && now.native_agent_id === id && now.machine_id === machine;
-            });
-            return t("model.restart_success", instanceName, model);
-        }
         const backendName = this.backendNameForInstance(instanceName);
         let strategy = "restart";
         try {
@@ -22526,8 +21239,6 @@ export class FleetManager {
      * profile's, when it is named and has one), claude's account catalog included. Read only: never a probe.
      */
     modelCatalogFor(backend, instance) {
-        if (instance && isWindowsInstance(this.fleetConfig?.instances[instance]))
-            return [];
         if (!KNOWN_BACKENDS.includes(backend) || backend === "mock")
             return [];
         const own = instance && Object.prototype.hasOwnProperty.call(this.fleetConfig?.instances ?? {}, instance) ? instance
@@ -22541,40 +21252,6 @@ export class FleetManager {
             }
         return out;
     }
-    /** Host-default fallback only: Grok has no modeled profile home. Never construct a backend or start a probe. */
-    async cliModelCatalogFor(backend, instance) {
-        if (backend !== "grok")
-            return [];
-        const fleet = this.fleetConfig;
-        const configured = instance && Object.prototype.hasOwnProperty.call(fleet?.instances ?? {}, instance) ? fleet.instances[instance] : undefined;
-        const classic = this.classicChannels;
-        const room = instance && !configured ? classic?.getAll().find(channel => channel.instanceName === instance) : undefined;
-        if (instance && !configured && !room)
-            return [];
-        const daemon = room ? this.daemons.get(instance) : undefined;
-        const grokHome = process.env.GROK_HOME?.trim() || join(homedir(), ".grok");
-        const stillHostDefault = () => {
-            if (this.fleetConfig !== fleet || (process.env.GROK_HOME?.trim() || join(homedir(), ".grok")) !== grokHome)
-                return false;
-            if (configured && (isWindowsInstance(configured) || !Object.prototype.hasOwnProperty.call(fleet?.instances ?? {}, instance) || fleet.instances[instance] !== configured))
-                return false;
-            if (room && (this.classicChannels !== classic || classic?.getAll().find(channel => channel.instanceName === instance) !== room || this.daemons.get(instance) !== daemon))
-                return false;
-            // The ordinary profile helpers deliberately ignore Grok: it has no credential-home mapping yet.
-            // Check raw declarations, including invalid ones, rather than mistaking them for the host login.
-            const defaults = fleet?.defaults?.backend_options;
-            const profiles = configured
-                ? [configured.backend_options?.grok?.credential_profile, defaults?.grok?.credential_profile]
-                : room
-                    ? [mergeBackendOptions(defaults, room.backendOptions)?.grok?.credential_profile, daemon?.getConfigSnapshot?.().backend_options?.grok?.credential_profile]
-                    : [defaults?.grok?.credential_profile];
-            return profiles.every(profile => profile === undefined || profile === null || profile === "");
-        };
-        if (!stillHostDefault())
-            return [];
-        const models = await readGrokModelCache(grokHome);
-        return stillHostDefault() ? models : [];
-    }
     /**
      * #2072 (#2078 review): the snapshot as THIS instance would see it. Its sign-in on a backend is its own credential
      * profile's when it has one there — the host's default login says nothing about it. A profile's login is a file check
@@ -23129,6 +21806,7 @@ export class FleetManager {
             ...this.fleetConfig?.defaults,
             working_directory: workDir,
             lightweight: true,
+            quota_notice: classicIdentity?.quotaNotice,
             tool_progress: toolProgress ?? "off",
             reply_completion_guard: replyCompletionGuard ?? true,
             ...(backend ? { backend } : {}),
@@ -23233,16 +21911,6 @@ export class FleetManager {
      * settles, so a later genuine stop (after a restart) still does the work.
      */
     stopAll() {
-        this.lifecycle.cancelNativeRecovery?.();
-        this.nativeMcpStore?.closeAll();
-        this.runtimeExecutor?.close();
-        this.runtimeExecutor = null;
-        this.fleetWindowsRuntime = null;
-        this.runtimeHub?.close();
-        this.runtimeHub = null;
-        this.localPaneRelay?.stop();
-        this.localPaneRelay = null;
-        closeWindowsBridge(this);
         this.stopAllInFlight ??= this.doStopAll().finally(() => {
             // #1956: after the stop's own tmux work; anything later goes direct. A later startAll starts it again.
             if (this.tmuxExecHelperTimer) {
@@ -23305,6 +21973,25 @@ 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;
+        this.stopQuotaObserver?.();
+        this.stopQuotaObserver = null;
+        const quotaNoticesStopped = this.quotaNotices?.stop();
+        // 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);
@@ -23321,7 +22008,6 @@ export class FleetManager {
         const settingsControlStopped = settingsControl?.close();
         this.publicLinkAutoOpen?.stop();
         const publicStopped = this.publicWebLink?.close("fleet shutdown");
-        this.webRemoteAccessState?.close(); // #3008: an unsaved switch gets its last write
         const sharesStopped = this.officeSharesInstance?.close(); // #2636: every Office share ends, and its tunnel
         // #1386: every live "Needs you" message says the fleet stopped (capabilities revoked first) — while the
         // adapters can still edit. Bounded: a platform that does not answer must not hold the shutdown.
@@ -23365,23 +22051,19 @@ 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 needsStopped;
         await settingsControlStopped;
         await cacheStopped;
+        await quotaNoticesStopped;
+        this.quotaNotices = null;
         await webChatStopped;
         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();
@@ -23419,6 +22101,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;
@@ -23704,7 +22395,6 @@ export class FleetManager {
             this.savedFleetConfigSnapshot = previousSavedSnapshot;
             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.logger.error({
                 oldCount,
                 newCount,
@@ -23724,6 +22414,7 @@ export class FleetManager {
             // mark every row done and tell the user "changes applied".
             return { rejected: why };
         }
+        this.agentCredentialsCache?.observePolicies();
         if (this.loadedFleetSource)
             this.getConfigHistory().accepted("fleet.yaml", this.configPath, this.loadedFleetSource);
         this.migrateOfficeStorage();
@@ -24624,6 +23315,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";
         }
@@ -25340,7 +24034,7 @@ export class FleetManager {
         const topicMode = daemonTopicMode(fleet);
         const restartProgress = new RestartProgress(this.runnableStartupCount(fleet, topicMode), restartStartedAt, this.logger);
         // Phase 1: generals first
-        const restartEntries = Object.entries(fleet.instances).filter(([, config]) => !isNativeExecInstance(config));
+        const restartEntries = Object.entries(fleet.instances);
         const restartGenerals = restartEntries.filter(([_, cfg]) => cfg.general_topic);
         const restartOthers = restartEntries.filter(([_, cfg]) => !cfg.general_topic);
         for (const [name, cfg] of restartGenerals) {
@@ -25794,9 +24488,6 @@ export class FleetManager {
                 return;
             }
             const requestPath = new URL(req.url ?? "/", `http://localhost:${port}`).pathname;
-            if (remoteRuntimeEnabled() && !gatewayRequestContext(req)
-                && this.runtimeCoordinator().handlePublicRequest(req, res, new URL(req.url ?? "/", `http://localhost:${port}`)))
-                return;
             // Branding is public, after Host admission: automatic favicon requests
             // must not become noisy web-token 401s in the browser console.
             // #2308: the icon routes and the pages' icon links follow the app icon set in Settings.
@@ -25823,8 +24514,7 @@ export class FleetManager {
                     if (decision.reason === "no-credential" && req.method === "GET"
                         && 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() });
                         return;
                     }
                     res.writeHead(decision.status);
@@ -26181,12 +24871,6 @@ export class FleetManager {
         if (!this.webToken || !this.webSessions)
             this.initializeWebAuthTokens();
         const server = createServer((req, res) => this.dispatchWebHttp(req, res, port, drain.closing));
-        server.on("upgrade", (req, socket, head) => {
-            if (!this.shuttingDown && remoteRuntimeEnabled() && isHostAllowed(req.headers.host, allowedHostNames(this.fleetConfig))
-                && this.runtimeCoordinator().handleUpgrade(req, socket, head))
-                return;
-            socket.destroy();
-        });
         // #1937: Node's default (300 s to receive a request) would cut a large upload on a slow link. The listener allows
         // more; the upload route keeps its own clocks (no byte for a minute, or 30 minutes in all), and every other request
         // keeps the old 300 s (limitRequestReceive in dispatchWebHttp).
@@ -26411,36 +25095,9 @@ export class FleetManager {
             this.logger.debug({ err }, "bots unreadable (getUiStatus)");
         }
         const instances = names.map(name => {
-            const nativeConfig = this.fleetConfig?.instances[name];
-            if (isNativeExecInstance(nativeConfig)) {
-                let runtime = null;
-                let agent = null;
-                try {
-                    runtime = this.nativeInstanceRuntime();
-                    agent = runtime.get(name);
-                }
-                catch { /* A damaged native profile is a crashed native row, never a Linux spawn. */ }
-                const display_name = nativeConfig.display_name || agent?.name || name;
-                const backend = nativeConfig.backend || agent?.cli || "codex";
-                return { name, display_name, description: nativeConfig.description || undefined, tags: nativeConfig.tags || [],
-                    teams: instanceTeams(this.fleetConfig?.teams, name), runtime: "windows", native_agent_id: nativeConfig.native_agent_id,
-                    ...(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" } : {}),
-                    native_blocked: !agent || agent.blocked === true,
-                    native_busy: runtime?.busy(name) ?? false,
-                    backend,
-                    model: nativeConfig.model || "default", model_source: nativeConfig.model ? "instance" : "cli-default",
-                    status: agent && runtime ? runtime.status(name) : "crashed", state: agent && runtime ? runtime.execution(name) : null, execution_state: agent && runtime ? runtime.execution(name) : null,
-                    interaction: null, interaction_summary: null, context_pct: null, cost: null,
-                    last_reply: this.webChatHistory.lastAgentReply(name) ?? undefined,
-                    avatar: avatarFor({ name, displayName: display_name }),
-                    capabilities: { chat: true, settings: true, pause: true, cancel: true, teams: true, schedules: true, delegation: true, mcp: nativeProviderMcpSupported(backend), channels: false, terminal: false, attachments: false, usage: false, send_while_busy: false },
-                    ...(!agent ? { runtime_error: "Windows profile is missing or invalid; restore its saved conversation before using this instance" }
-                        : agent.blocked ? { runtime_error: "Windows process outcome is unknown; verify it stopped before recovery" } : {}) };
-            }
             // #1956: read once for this instance; its cost, context and model come from it.
-            const statusline = isNativePaneInstance(nativeConfig) ? undefined : readStatuslineJson(this.dataDir, name);
-            const cost = isNativePaneInstance(nativeConfig) ? null : statusline?.cost?.total_cost_usd ?? 0;
+            const statusline = readStatuslineJson(this.dataDir, name);
+            const cost = statusline?.cost?.total_cost_usd ?? 0;
             // Align with /ctx: statusline for claude-code, pane scrape for kiro/grok/codex.
             const classic = classicOnly.includes(name);
             const backend = classic
@@ -26448,7 +25105,7 @@ export class FleetManager {
                 : (this.fleetConfig?.instances[name]?.backend
                     ?? this.fleetConfig?.defaults?.backend
                     ?? "claude-code");
-            const { context } = isNativePaneInstance(nativeConfig) ? { context: null } : resolveInstanceContext(this.dataDir, name, backend, { source: this.getPaneContextSource(name), statusline });
+            const { context } = resolveInstanceContext(this.dataDir, name, backend, { source: this.getPaneContextSource(name), statusline });
             // context_pct: null when unavailable, not 0
             const context_pct = context ?? null;
             // Model: Only Claude Code has live statusline; others use the effective resolver.
@@ -26479,22 +25136,6 @@ export class FleetManager {
             }
             return {
                 name,
-                general_topic: nativeConfig?.general_topic === true,
-                ...(isNativePaneInstance(nativeConfig) ? { runtime: "windows", native_adapter: "pane", native_agent_id: nativeConfig.native_agent_id,
-                    ...(() => {
-                        try {
-                            const profile = this.nativeInstanceRuntime().get(name), bound = this.daemons.get(name);
-                            return { native_recovery: profile?.paneRecovery ?? (profile?.paneLaunchId && bound?.usesNativePane?.() && !bound.nativePaneCurrent()
-                                    ? { kind: "exit-unconfirmed", launchId: profile.paneLaunchId } : null) };
-                        }
-                        catch {
-                            return { native_recovery: null };
-                        }
-                    })(),
-                    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 },
-                    ...(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,
                 avatar: image.avatar,
                 ...(image.accent ? { accent: image.accent } : {}),
@@ -26517,8 +25158,6 @@ export class FleetManager {
                 role: identity.role || undefined,
                 tags: identity.tags,
                 teams: instanceTeams(this.fleetConfig?.teams, name), // #2172: the sidebar groups a team's members under it
-                // #3008 G2: a web-only fleet's General (the agent its owner ticked) — the sidebar pins it first.
-                ...(this.isWebOnlyFleet() && this.fleetConfig?.instances[name]?.general_topic === true ? { general: true } : {}),
                 last_reply: this.webChatHistory.lastAgentReply(name) ?? undefined, // #2179: its last reply to a person (ISO)
                 // #2855: its last reply that reached the channel — the only reply time a guest's sidebar gets (guestStatus).
                 last_reply_channel: this.webChatHistory.lastAgentReply(name, { channel: true }) ?? undefined,
@@ -26548,7 +25187,6 @@ export class FleetManager {
             uptime: Math.floor((Date.now() - this.startedAt) / 1000),
             // #1519 P7: how many chat connections are configured — 0 is a web-only fleet, which gets the first-run card.
             connections: (this.fleetConfig?.channels ?? (this.fleetConfig?.channel ? [this.fleetConfig.channel] : [])).length,
-            windows_cli: localWindowsCliEnabled(),
             // #1665: the host preferences' revision — a page that has another re-reads /ui/prefs (no values in this frame).
             prefs_rev: this.webPrefs.rev(),
             // #1629: the themes' revision — the page re-reads GET /ui/themes when it moves.
@@ -26558,8 +25196,6 @@ export class FleetManager {
             host_memory: this.hostMemoryIndicator(),
             // #2910 D2: a web-only fleet's newest Notice — a polling page (no SSE `notice`) reads the list again when it moves.
             ...(this.webOnlyPromptPlace() ? { notices_newest: this.webNoticeStore()?.newest() ?? 0 } : {}),
-            // alpha.2 (M-2300, #2997 review): agents' requests changed — the owner's page reads GET /ui/agent-proposals again.
-            ...(this.isWebOnlyFleet() ? { agent_proposals_rev: this.agentProposalsRev } : {}),
             // #2015: the largest processes while it lasts (name, pid, RSS, and whose: an instance, the fleet or tmux).
             ...(this.hostMemoryIndicator() && this.memoryTop ? { host_memory_top: this.memoryTop.processes } : {}),
         };
@@ -27002,12 +25638,4 @@ load();
 </script>
 </body>
 </html>`;
-/** alpha.2 (M-2300): the agent an applied Windows request created (its name, for the page's "Open chat"), or null. */
-export function agentNameOf(view) {
-    const r = view.state === "applied" ? view.outcome?.result : null;
-    if (!r || typeof r !== "object")
-        return null;
-    const o = r, name = o.name ?? o.instance_name ?? (o.agent && typeof o.agent === "object" ? o.agent.name : undefined);
-    return typeof name === "string" && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name) ? name : null;
-}
 //# sourceMappingURL=fleet-manager.js.map