@songsid/agend 2.3.4-beta.6 → 2.3.5-alpha.2

package/dist/fleet-manager.js

@@ -1,3 +1,7 @@
+import { NativePaneRecoveryError } from "./native-pane-recovery.js";
+import { nativePaneToolAvailable, nativePaneToolRefusal } from "./native-pane-tools.js";
+import { windowsAgentsFor } from "./windows-agents.js";
+import { buildFleetInstructions } from "./instructions.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";
@@ -9,10 +13,12 @@ import { WorkingRecoveryCoordinator, WORKING_RECOVERY_KIND, buildWorkingRecovery
 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 { SettingsConfirmationStore, settingsSourceLabel } from "./settings-confirmation.js";
+import { prepareSettingsEffect } from "./settings-effect.js";
+import { settingsDisplay } from "./settings-change.js";
+import { SettingsConfirmationError, SettingsConfirmationStore, settingsSourceLabel } from "./settings-confirmation.js";
 import { SettingsHttpConfirmation } from "./settings-http-confirmation.js";
 import { SettingsControlServer } from "./settings-control.js";
-import { SettingsExecution, settingsRevision, noteSettingsWrite, settingsFileResource, assertSettingsLease, trySettingsLease, waitSettingsLease, settingsUndo, undoSettingsPaths } from "./settings-transaction.js";
+import { settingsFingerprint, 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";
@@ -83,7 +89,8 @@ 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 { usesChannelAddress } from "./channel/mcp-tools.js";
+import { NativeDaemonClient } from "./native-daemon-client.js";
+import { usesChannelAddress, TOOLS } 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";
@@ -93,6 +100,7 @@ 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";
@@ -167,6 +175,16 @@ 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 { 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";
@@ -728,6 +746,518 @@ 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),
+            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 (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",
+            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() });
+    }
+    /** 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)
+                    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) => buildFleetInstructions({ 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" } }),
+            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 });
+            },
+        });
+    }
+    async nativePaneFor(name, config, assertCurrent) {
+        return (await this.nativePanes()).prepare(name, config, assertCurrent);
+    }
+    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. */
@@ -1495,6 +2025,8 @@ 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;
@@ -1551,7 +2083,7 @@ export class FleetManager {
             return this.settingsConfirmation;
         const generation = this.settingsGeneration;
         const current = () => !this.shuttingDown && this.settingsGeneration === generation;
-        const baselines = new SettingsBaselines({ dataDir: this.dataDir, configPath: () => this.configPath,
+        const baselines = this.settingsBaselineReader = new SettingsBaselines({ dataDir: this.dataDir, configPath: () => this.configPath,
             config: () => this.fleetConfig, current: () => [this.settingsGeneration, this.settingsRuntimeRevision, this.shuttingDown],
             proof: (kind, target, id, binding, key) => {
                 const map = kind === "provider" ? this.providerSecretChallenges : kind === "binding" ? this.connectionBindingChallenges : this.connectionSecretChallenges;
@@ -1573,6 +2105,17 @@ 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 => {
@@ -1664,6 +2207,76 @@ export class FleetManager {
             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) {
+        if (!this.isWebOnlyFleet() || gatewayRequestContext(req))
+            return null;
+        const auth = authorizeSession(req, this.webToken, this.webSessions, { touch: false });
+        if (auth.kind !== "ok")
+            return null;
+        // Each check twice over: here, and in the authority itself (it refuses the public link and a chat fleet's session).
+        // #2997 review (Prism P2): asked of the LIVE session each time — the request's own cookie authenticated again, the
+        // same handle — never a record captured at the click: a sign-out, an expiry or a revocation while the request is
+        // being applied fences it.
+        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;
+            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"), current: owner } : null;
+    }
+    /** 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) } };
+        }
+    }
     /** #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), found = [];
@@ -1736,6 +2349,119 @@ 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);
@@ -2417,9 +3143,9 @@ export class FleetManager {
         const outbox = this.deliveryOutbox;
         if (!outbox)
             throw new Error("Durable delivery store is unavailable");
-        const source = this.daemons.get(input.sourceInstance);
-        const sourceDaemonBootId = input.sourceDaemonBootId ?? source?.bootId;
-        if (!source || !sourceDaemonBootId || source.bootId !== sourceDaemonBootId) {
+        const currentSourceBootId = this.getDaemonBootId(input.sourceInstance);
+        const sourceDaemonBootId = input.sourceDaemonBootId ?? currentSourceBootId;
+        if (!currentSourceBootId || !sourceDaemonBootId || currentSourceBootId !== 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}`;
@@ -2482,6 +3208,9 @@ export class FleetManager {
         return this.daemons.get(target)?.notAcceptingReason?.() ?? null;
     }
     getDaemonBootId(instanceName) {
+        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) {
@@ -2635,6 +3364,15 @@ 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;
@@ -2647,7 +3385,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.daemons.get(target)?.bootId ?? null, this.activeDurableTargets, row => this.recoveryDeliveryEligible(row));
+                    : this.deliveryBootId(target), this.activeDurableTargets, row => this.recoveryDeliveryEligible(row));
                 if (!claimed)
                     break;
                 this.activeDurableTargets.add(claimed.targetInstance);
@@ -2708,7 +3446,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.daemons.get(target)?.bootId ?? null,
+            daemonBootId: () => this.deliveryBootId(target),
             claim: bootId => this.deliveryOutbox?.claimNext(this.managerBootId, candidate => candidate === target ? bootId : null, new Set(), row => this.recoveryDeliveryEligible(row)),
             tryAcquireBudget: () => {
                 if (this.activeDurableTargets.size >= 8)
@@ -2739,6 +3477,10 @@ 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 };
@@ -2820,6 +3562,85 @@ 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)
@@ -3276,6 +4097,7 @@ 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);
@@ -3704,6 +4526,8 @@ 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;
@@ -3766,6 +4590,8 @@ 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 ?? "");
@@ -3802,6 +4628,8 @@ 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) {
@@ -3829,9 +4657,32 @@ 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
@@ -3865,6 +4716,14 @@ 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
@@ -3875,6 +4734,8 @@ 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);
@@ -3962,6 +4823,8 @@ 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));
@@ -4568,6 +5431,8 @@ 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);
@@ -4833,6 +5698,10 @@ export class FleetManager {
     }
     /** Single delivery facade: wake paused CLIs and serialize non-user work behind idle. */
     async deliverToInstance(instanceName, payload, options = {}) {
+        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"
@@ -5390,6 +6259,10 @@ 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)));
@@ -5414,6 +6287,10 @@ 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
@@ -5591,6 +6468,14 @@ 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"));
@@ -5641,10 +6526,10 @@ export class FleetManager {
             if (resumePaused)
                 this.lifecycle.markActivitySeedNow(name);
             const backend = config.backend ?? this.fleetConfig?.defaults?.backend ?? "claude-code";
-            if (config.general_topic) {
+            if (!isWindowsInstance(config) && config.general_topic) {
                 this.ensureGeneralInstructions(config.working_directory, backend, name);
             }
-            else if (kind === "fleet-topic") {
+            else if (!isWindowsInstance(config) && 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.
@@ -5659,7 +6544,7 @@ export class FleetManager {
                     this.logger.warn({ err, name, backend }, "Failed to sync worker skills — continuing startup");
                 }
             }
-            else if (kind === "classic") {
+            else if (!isWindowsInstance(config) && 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>`
@@ -5676,7 +6561,7 @@ export class FleetManager {
                 }
             }
             const receipt = execution ? this.classicSettingsOwners.get(execution) : undefined;
-            const identity = { kind, backend, model: this.resolveInstanceModel(name).display };
+            const identity = { kind, backend, model: isWindowsInstance(config) ? config.model || "default" : 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.
@@ -5746,7 +6631,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]) => !this.lifecycle.isPaused(name));
+        const runnableEntries = entries.filter(([name, config]) => !isNativeExecInstance(config) && !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));
@@ -5812,6 +6697,8 @@ 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}`);
@@ -5953,6 +6840,8 @@ 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");
@@ -6203,7 +7092,7 @@ export class FleetManager {
         return count;
     }
     configuredStartupInstanceNames(fleet, includeClassic) {
-        const names = new Set(Object.keys(fleet.instances));
+        const names = new Set(Object.entries(fleet.instances).filter(([, config]) => !isNativeExecInstance(config)).map(([name]) => name));
         if (includeClassic) {
             for (const channel of this.classicChannels?.getAll() ?? [])
                 names.add(channel.instanceName);
@@ -6254,6 +7143,10 @@ 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);
@@ -6291,6 +7184,16 @@ export class FleetManager {
     }
     /** Restart a single instance, reloading fleet.yaml first to pick up config changes. */
     async restartSingleInstance(name, opts) {
+        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"));
@@ -6354,7 +7257,7 @@ export class FleetManager {
         return run;
     }
     isInstanceRestarting(name) {
-        return this.restartsInFlight.has(name) || this.kiroMigrationRuns?.has(name) === true;
+        return this.restartsInFlight.has(name) || this.kiroMigrationRuns?.has(name) === true || this.lifecycle?.nativeRecoveryPending?.(name) === true;
     }
     /** InstanceLifecycleContext: an explicit wake joins the restart in flight. */
     restartInFlight(name) {
@@ -8125,6 +9028,9 @@ 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);
@@ -8156,7 +9062,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).map(config => {
+        this.lifecycle.primeAuthVerification(Object.values(fleet.instances).filter(config => !isWindowsInstance(config)).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 };
@@ -8218,6 +9124,7 @@ 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);
@@ -8396,7 +9303,7 @@ export class FleetManager {
             }
         }
         // Phase 1: Start general instances first and wait for them
-        const allEntries = Object.entries(fleet.instances);
+        const allEntries = Object.entries(fleet.instances).filter(([, config]) => !isNativeExecInstance(config));
         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" });
@@ -9398,10 +10305,14 @@ export class FleetManager {
                 }
             }
         }
+        const daemon = this.daemons.get(name);
+        const native = daemon?.usesNativePane?.();
         const sockPath = join(this.getInstanceDir(name), "channel.sock");
-        if (!existsSync(sockPath))
+        if (!native && !existsSync(sockPath))
             return;
-        const ipc = new IpcClient(sockPath);
+        const ipc = native
+            ? new NativeDaemonClient(daemon, () => this.daemons.get(name) === daemon && (!this.instanceIpcClients.has(name) || this.instanceIpcClients.get(name) === ipc))
+            : new IpcClient(sockPath);
         try {
             await ipc.connect();
             this.instanceIpcClients.set(name, ipc);
@@ -9517,7 +10428,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 (!this.statuslineWatcher.has(name)) {
+            if (!native && !this.statuslineWatcher.has(name)) {
                 this.statuslineWatcher.watch(name);
             }
             // Auto-reconnect on disconnect (unless intentionally stopping)
@@ -12580,6 +13491,7 @@ export class FleetManager {
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
         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() {
@@ -12813,10 +13725,43 @@ 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);
@@ -12939,6 +13884,8 @@ export class FleetManager {
         execution?.complete();
     }
     startStatuslineWatcher(name) {
+        if (isWindowsInstance(this.fleetConfig?.instances[name]))
+            return;
         if (this.lifecycle.isPaused(name))
             return;
         this.statuslineWatcher.watch(name);
@@ -14387,6 +15334,10 @@ 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);
@@ -14866,6 +15817,8 @@ 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];
@@ -14888,7 +15841,7 @@ 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 ?? {}).map(([name, cfg]) => ({
+        const fleet = Object.entries(this.fleetConfig?.instances ?? {}).filter(([, cfg]) => !isWindowsInstance(cfg)).map(([name, cfg]) => ({
             name, backend: this.backendNameOf(name), workingDirectory: cfg.working_directory, ledgerPath: join(this.getInstanceDir(name), "cache-ledger.json"),
             claudeConfigDir: this.claudeConfigDirOf(name), profile: this.usageProfileOf(name, this.backendNameOf(name)),
             kiroDbPath: this.kiroDbPathOf(name, this.backendNameOf(name)),
@@ -15067,6 +16020,19 @@ export class FleetManager {
                 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,
+                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;
@@ -15122,6 +16088,8 @@ 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)
@@ -16755,6 +17723,8 @@ 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
@@ -17287,6 +18257,14 @@ 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;
@@ -19547,6 +20525,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                     : 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");
@@ -19628,7 +20608,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         if (this.fleetConfig?.defaults?.backend)
             backends.add(this.fleetConfig.defaults.backend);
         for (const inst of Object.values(this.fleetConfig?.instances ?? {}))
-            if (inst.backend)
+            if (!isWindowsInstance(inst) && inst.backend)
                 backends.add(inst.backend);
         for (const ch of this.classicChannels?.getAll() ?? [])
             if (ch.backend)
@@ -19643,6 +20623,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // 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);
@@ -19663,6 +20645,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * 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);
@@ -19718,6 +20702,21 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      */
     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);
@@ -19753,6 +20752,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     /** 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);
@@ -20372,6 +21373,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     /** 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") {
@@ -20382,6 +21385,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     /** 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" };
@@ -20419,6 +21424,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * instance respawns.
      */
     async applyEffort(instanceName, requested) {
+        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";
@@ -20462,6 +21469,20 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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 {
@@ -20648,6 +21669,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * 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
@@ -20661,6 +21684,40 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             }
         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
@@ -21319,6 +22376,16 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * 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) {
@@ -21777,6 +22844,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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,
@@ -23412,7 +24480,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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);
+        const restartEntries = Object.entries(fleet.instances).filter(([, config]) => !isNativeExecInstance(config));
         const restartGenerals = restartEntries.filter(([_, cfg]) => cfg.general_topic);
         const restartOthers = restartEntries.filter(([_, cfg]) => !cfg.general_topic);
         for (const [name, cfg] of restartGenerals) {
@@ -23866,6 +24934,9 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 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.
@@ -24249,6 +25320,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         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).
@@ -24473,9 +25550,36 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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 = readStatuslineJson(this.dataDir, name);
-            const cost = statusline?.cost?.total_cost_usd ?? 0;
+            const statusline = isNativePaneInstance(nativeConfig) ? undefined : readStatuslineJson(this.dataDir, name);
+            const cost = isNativePaneInstance(nativeConfig) ? null : 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
@@ -24483,7 +25587,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
                 : (this.fleetConfig?.instances[name]?.backend
                     ?? this.fleetConfig?.defaults?.backend
                     ?? "claude-code");
-            const { context } = resolveInstanceContext(this.dataDir, name, backend, { source: this.getPaneContextSource(name), statusline });
+            const { context } = isNativePaneInstance(nativeConfig) ? { context: null } : 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.
@@ -24514,6 +25618,21 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             }
             return {
                 name,
+                ...(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 } : {}),
@@ -24565,6 +25684,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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.
@@ -24574,6 +25694,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             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 } : {}),
         };
@@ -25016,4 +26138,12 @@ 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