@alfe.ai/gateway 0.9.4 → 0.9.5

package/dist/health.js

@@ -2,20 +2,20 @@ import { n as logger$1 } from "./logger.js";
 import { a as captureFatal, c as captureRuntimeCrash, d as initAgentSentry, f as setAgentContext, l as captureRuntimeErrorOutput, o as captureIntegrationFailure, s as captureMcpFailure, u as flushSentry } from "./sentry.js";
 import { createRequire } from "node:module";
 import { mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { execFile, execSync, spawn } from "node:child_process";
-import { promisify } from "node:util";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import pino from "pino";
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { getEndpointFromToken, readConfig } from "@alfe.ai/config";
 import crypto from "crypto";
+import { AgentApiClient } from "@alfe.ai/agent-api-client";
 import { parse } from "smol-toml";
 import WebSocket from "ws";
-import { createConnection, createServer } from "node:net";
+import { execFile, execSync, spawn } from "node:child_process";
 import { ClaudeCodeApplier, ClaudeCodeMcpSync, HermesApplier, HermesMcpSync, IntegrationManager, IntegrationManagerAdapter, McpApplier, NoopOpenClawCliLock, OpenClawApplier, SerialOpenClawCliLock } from "@alfe.ai/integrations";
-import { AgentApiClient } from "@alfe.ai/agent-api-client";
 import { Manager, McpBundler, defaultConnect } from "@alfe.ai/mcp-bundler";
+import { promisify } from "node:util";
+import { createConnection, createServer } from "node:net";
 import stream, { Readable } from "stream";
 import util, { format } from "util";
 import http from "http";
@@ -5204,63 +5204,54 @@ async function loadDaemonConfig() {
 * Returns null if the agent has no template assigned or the fetch fails.
 */
 async function fetchAgentConfig(apiKey, apiEndpoint) {
+	const client = new AgentApiClient({
+		apiKey,
+		apiUrl: apiEndpoint
+	});
+	logger$1.debug({ apiEndpoint }, "Fetching agent workspace config...");
+	let workspace;
 	try {
-		logger$1.debug({ apiEndpoint }, "Fetching agent workspace config...");
-		const wsResponse = await fetch(`${apiEndpoint}/agents/me/workspace`, {
-			method: "GET",
-			headers: { "Authorization": `Bearer ${apiKey}` }
-		});
-		if (!wsResponse.ok) {
-			logger$1.debug({ status: wsResponse.status }, "Workspace config fetch failed");
-			return null;
-		}
-		const wsResult = await wsResponse.json();
-		const templateKey = wsResult.data?.templateKey;
-		const defaultModel = wsResult.data?.defaultModel ?? void 0;
-		const installedFrom = wsResult.data?.installedFrom;
-		if (!templateKey) {
-			logger$1.debug("No templateKey in workspace response");
-			return defaultModel ? {
-				defaultModel,
-				files: {}
-			} : null;
-		}
-		const pinnedVersion = installedFrom?.templateKey === templateKey ? installedFrom.version : void 0;
-		const filesUrl = new URL(`${apiEndpoint}/templates/${encodeURIComponent(templateKey)}/files`);
-		if (pinnedVersion !== void 0) filesUrl.searchParams.set("version", String(pinnedVersion));
-		logger$1.debug({
-			templateKey,
-			version: pinnedVersion
-		}, "Fetching template files...");
-		const filesResponse = await fetch(filesUrl.toString(), {
-			method: "GET",
-			headers: { "Authorization": `Bearer ${apiKey}` }
-		});
-		if (!filesResponse.ok) {
-			logger$1.debug({ status: filesResponse.status }, "Template files fetch failed");
-			return {
-				templateKey,
-				defaultModel,
-				files: {}
-			};
-		}
-		const files = (await filesResponse.json()).data?.files ?? {};
-		const fileCount = Object.keys(files).length;
-		logger$1.debug({
-			templateKey,
-			version: pinnedVersion,
-			fileCount
-		}, "Template files fetched");
+		workspace = await client.getWorkspace();
+	} catch (err) {
+		logger$1.debug({ err: err instanceof Error ? err.message : String(err) }, "Workspace config fetch failed");
+		return null;
+	}
+	const { templateKey, installedFrom } = workspace;
+	const defaultModel = workspace.defaultModel ?? void 0;
+	if (!templateKey) {
+		logger$1.debug("No templateKey in workspace response");
+		return defaultModel ? {
+			defaultModel,
+			files: {}
+		} : null;
+	}
+	const pinnedVersion = installedFrom?.templateKey === templateKey ? installedFrom.version : void 0;
+	logger$1.debug({
+		templateKey,
+		version: pinnedVersion
+	}, "Fetching template files...");
+	let files;
+	try {
+		files = (await client.getTemplateFiles(templateKey, { version: pinnedVersion })).files;
+	} catch (err) {
+		logger$1.debug({ err: err instanceof Error ? err.message : String(err) }, "Template files fetch failed");
 		return {
 			templateKey,
 			defaultModel,
-			files,
-			personaFiles: Object.keys(files)
+			files: {}
 		};
-	} catch (err) {
-		logger$1.debug({ err: err instanceof Error ? err.message : String(err) }, "fetchAgentConfig failed");
-		return null;
 	}
+	logger$1.debug({
+		templateKey,
+		version: pinnedVersion,
+		fileCount: Object.keys(files).length
+	}, "Template files fetched");
+	return {
+		templateKey,
+		defaultModel,
+		files,
+		personaFiles: Object.keys(files)
+	};
 }
 //#endregion
 //#region src/protocol.ts
@@ -6360,190 +6351,759 @@ var ConfigReconciler = class {
 	}
 };
 //#endregion
-//#region src/ipc-server.ts
-/**
-* IPC Server — Unix socket server for local plugin connections.
-*
-* Plugins connect to ~/.alfe/gateway.sock and speak the IPC protocol:
-*   Request:  { type: 'req', id, method, params }
-*   Response: { id, ok, payload?, error? }
-*   Event:    { type: 'event', event, payload }
-*
-* Each connected plugin registers with its name/version and receives
-* commands from the daemon (forwarded from cloud).
-*/
-var IPCServer = class {
-	server = null;
-	connections = /* @__PURE__ */ new Map();
-	socketPath;
-	requestHandler = null;
-	constructor(socketPath) {
-		this.socketPath = socketPath;
-	}
-	/**
-	* Set the handler for incoming IPC requests from plugins.
-	*/
-	setRequestHandler(handler) {
-		this.requestHandler = handler;
+//#region src/command-queue.ts
+const DEFAULT_TTL_MS$1 = 300 * 1e3;
+var CommandQueue = class {
+	queues = /* @__PURE__ */ new Map();
+	ttlMs;
+	gcTimer = null;
+	constructor(ttlMs = DEFAULT_TTL_MS$1) {
+		this.ttlMs = ttlMs;
 	}
 	/**
-	* Start listening on the Unix socket.
+	* Start periodic garbage collection of expired commands.
 	*/
-	async start() {
-		try {
-			unlinkSync(this.socketPath);
-		} catch {}
-		return new Promise((resolve, reject) => {
-			this.server = createServer((socket) => {
-				this.handleConnection(socket);
-			});
-			this.server.on("error", (err) => {
-				logger$1.error({ err: err.message }, "IPC server error");
-				reject(err);
-			});
-			this.server.listen(this.socketPath, () => {
-				try {
-					chmodSync(this.socketPath, 384);
-				} catch (err) {
-					logger$1.warn({ err }, "Failed to chmod socket");
-				}
-				logger$1.info({ path: this.socketPath }, "IPC server listening");
-				resolve();
-			});
-		});
+	startGC(intervalMs = 3e4) {
+		this.stopGC();
+		this.gcTimer = setInterval(() => this.purgeExpired(), intervalMs);
 	}
 	/**
-	* Stop the IPC server and disconnect all plugins.
+	* Stop periodic garbage collection.
 	*/
-	async stop() {
-		for (const conn of this.connections.values()) try {
-			this.sendEvent(conn, "daemon.shutdown", { reason: "daemon stopping" });
-			conn.socket.end();
-		} catch {}
-		return new Promise((resolve) => {
-			if (!this.server) {
-				resolve();
-				return;
-			}
-			this.server.close(() => {
-				try {
-					unlinkSync(this.socketPath);
-				} catch {}
-				logger$1.info("IPC server stopped");
-				resolve();
-			});
-			for (const conn of this.connections.values()) conn.socket.destroy();
-			this.connections.clear();
-		});
+	stopGC() {
+		if (this.gcTimer) {
+			clearInterval(this.gcTimer);
+			this.gcTimer = null;
+		}
 	}
 	/**
-	* Send an IPC request to a specific plugin and wait for response.
+	* Enqueue a command for a specific service.
 	*/
-	async sendRequest(pluginId, method, params, timeoutMs = 3e4) {
-		const conn = this.connections.get(pluginId);
-		if (!conn?.info) return {
-			id: "",
-			ok: false,
-			error: {
-				code: "PLUGIN_NOT_CONNECTED",
-				message: `Plugin ${pluginId} not connected`
-			}
-		};
-		const id = pluginConnectionId();
-		const request = {
-			type: "req",
-			id,
-			method,
-			params
-		};
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
-				conn.pending.delete(id);
-				resolve({
-					id,
-					ok: false,
-					error: {
-						code: "TIMEOUT",
-						message: `Request ${method} timed out after ${String(timeoutMs)}ms`
-					}
-				});
-			}, timeoutMs);
-			conn.pending.set(id, {
-				resolve,
-				reject,
-				timer
-			});
-			try {
-				conn.socket.write(JSON.stringify(request) + "\n");
-			} catch (err) {
-				clearTimeout(timer);
-				conn.pending.delete(id);
-				resolve({
-					id,
-					ok: false,
-					error: {
-						code: "SEND_FAILED",
-						message: `Failed to send to plugin: ${err instanceof Error ? err.message : String(err)}`
-					}
-				});
-			}
+	enqueue(serviceId, request, commandId) {
+		let queue = this.queues.get(serviceId);
+		if (!queue) {
+			queue = [];
+			this.queues.set(serviceId, queue);
+		}
+		queue.push({
+			request,
+			queuedAt: Date.now(),
+			commandId
 		});
 	}
 	/**
-	* Send an IPC request to ALL registered plugins.
-	* Returns responses keyed by plugin ID.
+	* Drain all pending (non-expired) commands for a service.
+	* Returns them in order and removes them from the queue.
 	*/
-	async broadcastRequest(method, params, timeoutMs = 3e4) {
-		const results = /* @__PURE__ */ new Map();
-		const registered = this.getRegisteredPlugins();
-		await Promise.all(registered.map(async ([pluginId]) => {
-			const response = await this.sendRequest(pluginId, method, params, timeoutMs);
-			results.set(pluginId, response);
-		}));
-		return results;
+	drain(serviceId) {
+		const queue = this.queues.get(serviceId);
+		if (!queue || queue.length === 0) return [];
+		const now = Date.now();
+		const valid = queue.filter((cmd) => now - cmd.queuedAt < this.ttlMs);
+		this.queues.delete(serviceId);
+		return valid;
 	}
 	/**
-	* Send an event to a specific plugin (fire-and-forget).
+	* Get the number of pending commands for a service.
 	*/
-	sendEventToPlugin(pluginId, event, payload) {
-		const conn = this.connections.get(pluginId);
-		if (!conn) return false;
-		return this.sendEvent(conn, event, payload);
+	pendingCount(serviceId) {
+		const queue = this.queues.get(serviceId);
+		if (!queue) return 0;
+		const now = Date.now();
+		return queue.filter((cmd) => now - cmd.queuedAt < this.ttlMs).length;
 	}
 	/**
-	* Broadcast an event to all connected plugins.
+	* Get total pending commands across all services.
 	*/
-	broadcastEvent(event, payload) {
-		for (const conn of this.connections.values()) if (conn.info) this.sendEvent(conn, event, payload);
+	totalPending() {
+		let total = 0;
+		for (const [serviceId] of this.queues) total += this.pendingCount(serviceId);
+		return total;
 	}
 	/**
-	* Get all registered plugins and their info.
+	* Remove expired commands from all queues.
 	*/
-	getRegisteredPlugins() {
-		const plugins = [];
-		for (const [id, conn] of this.connections) if (conn.info) plugins.push([id, conn.info]);
-		return plugins;
+	purgeExpired() {
+		const now = Date.now();
+		let purged = 0;
+		for (const [serviceId, queue] of this.queues) {
+			const before = queue.length;
+			const remaining = queue.filter((cmd) => now - cmd.queuedAt < this.ttlMs);
+			if (remaining.length === 0) this.queues.delete(serviceId);
+			else this.queues.set(serviceId, remaining);
+			purged += before - remaining.length;
+		}
+		return purged;
 	}
 	/**
-	* Get number of connected plugins (including unregistered).
+	* Clear all queues.
 	*/
-	get connectionCount() {
-		return this.connections.size;
+	clear() {
+		this.queues.clear();
 	}
 	/**
-	* Get number of registered plugins.
+	* Get all service IDs that have pending commands.
 	*/
-	get registeredCount() {
-		let count = 0;
-		for (const conn of this.connections.values()) if (conn.info) count++;
-		return count;
+	serviceIds() {
+		return Array.from(this.queues.keys());
 	}
-	handleConnection(socket) {
-		const connId = pluginConnectionId();
-		const conn = {
-			id: connId,
-			socket,
-			info: null,
+};
+//#endregion
+//#region src/process-manager.ts
+/**
+* Process management — launchd/systemd service installation.
+*
+* Generates and installs user-space service units for auto-start on boot.
+* No root required — uses user agents (Mac) or user units (Linux).
+*/
+const LAUNCHD_LABEL = "ai.alfe.gateway";
+const SYSTEMD_SERVICE = "alfe-gateway";
+/**
+* On-disk path for the boot-time self-heal guard script (Linux only).
+* Written next to the systemd unit at setup time and invoked via
+* `ExecStartPre=` — see `writeGuardScript` and `generateSystemdUnit`.
+*/
+function getGuardScriptPath() {
+	return isRootUser() ? "/usr/local/lib/alfe/alfe-cli-guard.sh" : join(homedir(), ".alfe", "alfe-cli-guard.sh");
+}
+function isRootUser() {
+	return process.getuid?.() === 0;
+}
+function getSystemdSystemServicePath() {
+	return `/etc/systemd/system/${SYSTEMD_SERVICE}.service`;
+}
+function getLaunchdPlistPath() {
+	return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function getSystemdServicePath() {
+	return join(homedir(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+}
+/**
+* Resolve the alfe CLI path. Globally installed via npm, always in PATH.
+*/
+function getAlfeBinPath() {
+	try {
+		return execSync("which alfe", { encoding: "utf-8" }).trim();
+	} catch {
+		return "alfe";
+	}
+}
+/**
+* Build the PATH for the launchd plist, ensuring the directory containing the
+* resolved alfe binary is included (e.g. /opt/homebrew/bin on Apple Silicon).
+*/
+function buildLaunchdPath(alfeBin) {
+	const basePaths = [
+		"/usr/local/bin",
+		"/usr/bin",
+		"/bin",
+		join(homedir(), ".local", "bin")
+	];
+	const binDir = dirname(alfeBin);
+	if (binDir && !basePaths.includes(binDir)) basePaths.unshift(binDir);
+	return basePaths.join(":");
+}
+/**
+* Generate a launchd plist for macOS.
+*/
+function generateLaunchdPlist() {
+	const alfeBin = getAlfeBinPath();
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${alfeBin}</string>
+    <string>gateway</string>
+    <string>daemon</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${join(homedir(), ".alfe", "logs", "gateway.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(homedir(), ".alfe", "logs", "gateway.err.log")}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NODE_ENV</key>
+    <string>production</string>
+    <key>PATH</key>
+    <string>${buildLaunchdPath(alfeBin)}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+/**
+* Boot-time self-heal guard (Linux only).
+*
+* Runs as an `ExecStartPre=` BEFORE the daemon launches, OUTSIDE the
+* (possibly-broken) `alfe` binary. It exists for the case defense #1
+* (verify-before-exit in `upgrade.ts`) structurally cannot cover: the daemon
+* is KILLED during `npm install -g @alfe.ai/cli` (reboot / OOM), leaving the
+* package with deps but no `dist/` and a dangling `/usr/bin/alfe` symlink.
+* systemd then execs a dangling binary forever → 203/EXEC crash-loop, a
+* permanent brick with no automatic recovery (real prod incident,
+* ~13,570 restarts over 2 days).
+*
+* The guard:
+*   - checks the CLI is intact: the symlink target (`dist/index.js`) exists AND
+*     `alfe --version` exits 0;
+*   - if broken, reinstalls `@alfe.ai/cli@$ALFE_CLI_VERSION` (the exact version
+*     baked into the unit's `Environment=`; falls back to `@latest` when
+*     unset), so the daemon then execs a working binary;
+*   - is idempotent + fast (no-op when healthy) and NEVER wedges boot: any of
+*     its own failures log + `exit 0` so a human can still SSH in.
+*
+* POSIX sh (dash-safe): the box may not have bash. Keep the two intactness
+* checks in lockstep with `verifyCliInstall` in `verify-cli-install.ts`.
+*/
+/** @internal exported for unit tests; not re-exported from the barrel. */
+function generateGuardScript() {
+	const version = process.env.ALFE_CLI_VERSION;
+	return `#!/bin/sh
+# Alfe CLI boot-time self-heal guard. Auto-generated by 'alfe setup' — do not edit.
+# Repairs an interrupted 'npm install -g @alfe.ai/cli' before the daemon starts,
+# so a mid-install reboot can't brick the agent with a 203/EXEC crash-loop.
+# Must never wedge boot: every failure path logs and exits 0.
+set -u
+
+TARGET='${version && version.length > 0 ? `@alfe.ai/cli@${version}` : "@alfe.ai/cli@latest"}'
+log() { echo "[alfe-cli-guard] $*" >&2; }
+
+# Resolve the alfe bin and its real target (dist/index.js). readlink -f follows
+# the whole symlink chain; fall back to the bin path itself if unavailable.
+BIN="$(command -v alfe 2>/dev/null || true)"
+if [ -n "$BIN" ]; then
+  ENTRY="$(readlink -f "$BIN" 2>/dev/null || echo "$BIN")"
+else
+  ENTRY=""
+fi
+
+healthy=1
+if [ -z "$ENTRY" ] || [ ! -f "$ENTRY" ]; then
+  healthy=0
+  log "CLI entry missing (bin=\${BIN:-<none>} entry=\${ENTRY:-<none>})"
+elif ! alfe --version >/dev/null 2>&1; then
+  healthy=0
+  log "alfe --version failed"
+fi
+
+if [ "$healthy" -eq 1 ]; then
+  exit 0
+fi
+
+log "CLI install looks broken — reinstalling $TARGET"
+# Blow away a partial tree first so npm re-materialises dist/ cleanly. Best-effort.
+GLOBAL_ROOT="$(npm root -g 2>/dev/null || true)"
+if [ -n "$GLOBAL_ROOT" ] && [ -d "$GLOBAL_ROOT/@alfe.ai/cli" ]; then
+  rm -rf "$GLOBAL_ROOT/@alfe.ai/cli" 2>/dev/null || true
+fi
+
+# Bound the reinstall so a slow/unreachable registry at boot can't stall the
+# ExecStartPre up to systemd's DefaultTimeoutStartSec (~90s). Two layers:
+#   - npm --fetch-timeout/--fetch-retries cap per-request/hung-socket time;
+#   - a wall-clock 'timeout' wrapper caps the whole install when present
+#     ('timeout' isn't guaranteed, so fall back to a bare install).
+# stdout->stderr ('>&2') so npm's chatter lands in the journal, not on fd1.
+if command -v timeout >/dev/null 2>&1; then
+  timeout 120 npm install -g "$TARGET" --fetch-timeout=60000 --fetch-retries=2 >&2
+  rc=$?
+else
+  npm install -g "$TARGET" --fetch-timeout=60000 --fetch-retries=2 >&2
+  rc=$?
+fi
+if [ "$rc" -eq 0 ]; then
+  log "reinstall succeeded"
+else
+  log "reinstall FAILED (rc=$rc) — daemon start may still fail; a human can SSH in to repair"
+fi
+
+# Always exit 0: even a failed repair must not block the unit from attempting
+# ExecStart (which then fails visibly) rather than wedging silently in pre-start.
+exit 0
+`;
+}
+/**
+* Generate a systemd unit for Linux.
+* Root users get a system-level unit; non-root get a user-level unit.
+*/
+/** @internal exported for unit tests; not re-exported from the barrel. */
+function generateSystemdUnit() {
+	const alfeBin = getAlfeBinPath();
+	const root = isRootUser();
+	const envLines = [
+		"ALFE_MANAGED",
+		"ALFE_API_KEY",
+		"LOG_LEVEL",
+		"ALFE_CLI_VERSION"
+	].filter((key) => process.env[key]).map((key) => `Environment=${key}=${process.env[key] ?? ""}`).join("\n");
+	return `[Unit]
+Description=Alfe Gateway Daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStartPre=-/bin/sh ${getGuardScriptPath()}
+ExecStart=${alfeBin} gateway daemon
+Restart=always
+RestartSec=10
+# SIGTERM only the daemon on stop/restart; it closes its MCP/runtime children
+# itself. The default (control-group) SIGTERMs the children simultaneously, so
+# they die before the daemon's orderly dispose reaches them and every planned
+# restart reports MCP "server-crash" noise to Sentry. Stragglers still get
+# SIGKILL when the stop timeout expires.
+KillMode=mixed
+Environment=NODE_ENV=production${root ? "\nEnvironment=HOME=/root\nWorkingDirectory=/root" : ""}
+${envLines}
+
+[Install]
+WantedBy=${root ? "multi-user.target" : "default.target"}`;
+}
+/**
+* Write the boot-time self-heal guard script to disk (Linux only) and make it
+* executable. Called from `installSystemd` before the unit is written.
+*/
+async function writeGuardScript() {
+	const guardPath = getGuardScriptPath();
+	await mkdir(dirname(guardPath), { recursive: true });
+	await writeFile(guardPath, generateGuardScript(), {
+		encoding: "utf-8",
+		mode: 493
+	});
+	logger$1.info({ path: guardPath }, "Wrote CLI self-heal guard script");
+}
+/**
+* Install the service unit for the current platform.
+*/
+async function installService() {
+	const platform = process.platform;
+	if (platform === "darwin") return installLaunchd();
+	if (platform === "linux") return installSystemd();
+	throw new Error(`Unsupported platform: ${platform}. Only macOS and Linux are supported.`);
+}
+/**
+* Uninstall the service unit for the current platform.
+*/
+async function uninstallService() {
+	const platform = process.platform;
+	if (platform === "darwin") return uninstallLaunchd();
+	if (platform === "linux") return uninstallSystemd();
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+function getLaunchdUid() {
+	return execSync("id -u", { encoding: "utf-8" }).trim();
+}
+async function installLaunchd() {
+	const plistPath = getLaunchdPlistPath();
+	const dir = join(homedir(), "Library", "LaunchAgents");
+	const logsDir = join(homedir(), ".alfe", "logs");
+	await mkdir(dir, { recursive: true });
+	await mkdir(logsDir, { recursive: true });
+	await writeFile(plistPath, generateLaunchdPlist(), "utf-8");
+	logger$1.info({ path: plistPath }, "Wrote launchd plist");
+	const uid = getLaunchdUid();
+	try {
+		execSync(`launchctl bootout gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+	} catch {}
+	try {
+		execSync(`launchctl bootstrap gui/${uid} ${plistPath}`, { stdio: "pipe" });
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger$1.error({
+			err: msg,
+			plistPath
+		}, "launchctl bootstrap failed");
+		return `Installed plist at ${plistPath}, but failed to bootstrap service: ${msg}`;
+	}
+	return `Installed: ${plistPath}\nService will start on boot and restart on crash.`;
+}
+async function uninstallLaunchd() {
+	const plistPath = getLaunchdPlistPath();
+	const uid = getLaunchdUid();
+	try {
+		execSync(`launchctl bootout gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+	} catch {}
+	try {
+		await unlink(plistPath);
+	} catch {}
+	return `Uninstalled: ${plistPath}`;
+}
+async function installSystemd() {
+	const root = isRootUser();
+	const unitPath = root ? getSystemdSystemServicePath() : getSystemdServicePath();
+	const dir = root ? "/etc/systemd/system" : join(homedir(), ".config", "systemd", "user");
+	const ctl = root ? "systemctl" : "systemctl --user";
+	if (!root) await mkdir(dir, { recursive: true });
+	await writeGuardScript();
+	await writeFile(unitPath, generateSystemdUnit(), "utf-8");
+	logger$1.info({
+		path: unitPath,
+		root
+	}, "Wrote systemd unit");
+	try {
+		execSync(`${ctl} daemon-reload`, { stdio: "pipe" });
+		execSync(`${ctl} enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+	} catch {}
+	return `Installed: ${unitPath}\nService enabled${root ? " (system-level)" : " for user session"}.`;
+}
+async function uninstallSystemd() {
+	const root = isRootUser();
+	const unitPath = root ? getSystemdSystemServicePath() : getSystemdServicePath();
+	const ctl = root ? "systemctl" : "systemctl --user";
+	try {
+		execSync(`${ctl} disable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		execSync(`${ctl} stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+	} catch {}
+	try {
+		await unlink(unitPath);
+	} catch {}
+	try {
+		await unlink(getGuardScriptPath());
+	} catch {}
+	try {
+		execSync(`${ctl} daemon-reload`, { stdio: "pipe" });
+	} catch {}
+	return `Uninstalled: ${unitPath}`;
+}
+/**
+* Bootstrap (load) the launchd service from its plist if it isn't already
+* loaded. Already-loaded is an error we ignore. Needed so `start`/`restart`
+* work after `stopService()` boots the service OUT.
+*/
+function ensureLaunchdLoaded(uid) {
+	try {
+		execSync(`launchctl bootstrap gui/${uid} ${getLaunchdPlistPath()}`, { stdio: "pipe" });
+	} catch {}
+}
+/**
+* Start the installed service via systemctl/launchctl. Bootstraps the launchd
+* service first so this also works after `stopService()` booted it out.
+*/
+function startService() {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		const uid = getLaunchdUid();
+		ensureLaunchdLoaded(uid);
+		execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		logger$1.info("Started launchd service");
+		return;
+	}
+	if (platform === "linux") {
+		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} start ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		logger$1.info("Started systemd service");
+		return;
+	}
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
+* Restart the installed service via systemctl/launchctl. This is the
+* service-manager-native restart (`kickstart -k` / `systemctl restart`) — the
+* CLI uses it instead of killing the process inline, which would fight launchd
+* `KeepAlive` / systemd `Restart=always`.
+*/
+function restartService() {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		const uid = getLaunchdUid();
+		ensureLaunchdLoaded(uid);
+		execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		logger$1.info("Restarted launchd service");
+		return;
+	}
+	if (platform === "linux") {
+		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} restart ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		logger$1.info("Restarted systemd service");
+		return;
+	}
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
+* Stop the installed service via systemctl/launchctl. On macOS this boots the
+* service OUT (unloads it) so launchd's `KeepAlive` does NOT respawn it;
+* `startService()` bootstraps it again. On Linux the unit stays enabled (starts
+* on next boot); `systemctl stop` just halts the current run.
+*/
+function stopService() {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		execSync(`launchctl bootout gui/${getLaunchdUid()}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
+		logger$1.info("Stopped launchd service");
+		return;
+	}
+	if (platform === "linux") {
+		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+		logger$1.info("Stopped systemd service");
+		return;
+	}
+	throw new Error(`Unsupported platform: ${platform}`);
+}
+/**
+* True when the gateway is installed as a system service (launchd plist /
+* systemd unit present). Lets the CLI restart/stop/start THROUGH the service
+* manager instead of driving the daemon inline via the PID file.
+*/
+function isServiceInstalled() {
+	const platform = process.platform;
+	if (platform === "darwin") return existsSync(getLaunchdPlistPath());
+	if (platform === "linux") return existsSync(isRootUser() ? getSystemdSystemServicePath() : getSystemdServicePath());
+	return false;
+}
+/**
+* Write the current process PID to the PID file.
+*/
+async function writePidFile() {
+	await writeFile(PID_PATH, String(process.pid), "utf-8");
+}
+/**
+* Remove the PID file.
+*/
+async function removePidFile() {
+	try {
+		await unlink(PID_PATH);
+	} catch {}
+}
+/**
+* Check if a daemon is already running.
+* Returns the PID if alive, null if not running.
+*/
+async function checkExistingDaemon() {
+	if (!existsSync(PID_PATH)) return null;
+	try {
+		const pidStr = await readFile(PID_PATH, "utf-8");
+		const pid = parseInt(pidStr.trim(), 10);
+		if (isNaN(pid)) {
+			await removePidFile();
+			return null;
+		}
+		try {
+			process.kill(pid, 0);
+			return pid;
+		} catch {
+			await removePidFile();
+			return null;
+		}
+	} catch {
+		return null;
+	}
+}
+/**
+* Send SIGTERM to an existing daemon process.
+*/
+async function stopExistingDaemon() {
+	const pid = await checkExistingDaemon();
+	if (!pid) return false;
+	try {
+		process.kill(pid, "SIGTERM");
+		for (let i = 0; i < 50; i++) {
+			await new Promise((r) => setTimeout(r, 100));
+			try {
+				process.kill(pid, 0);
+			} catch {
+				await removePidFile();
+				return true;
+			}
+		}
+		process.kill(pid, "SIGKILL");
+		await removePidFile();
+		return true;
+	} catch {
+		await removePidFile();
+		return false;
+	}
+}
+//#endregion
+//#region src/ipc-server.ts
+/**
+* IPC Server — Unix socket server for local plugin connections.
+*
+* Plugins connect to ~/.alfe/gateway.sock and speak the IPC protocol:
+*   Request:  { type: 'req', id, method, params }
+*   Response: { id, ok, payload?, error? }
+*   Event:    { type: 'event', event, payload }
+*
+* Each connected plugin registers with its name/version and receives
+* commands from the daemon (forwarded from cloud).
+*/
+var IPCServer = class {
+	server = null;
+	connections = /* @__PURE__ */ new Map();
+	socketPath;
+	requestHandler = null;
+	constructor(socketPath) {
+		this.socketPath = socketPath;
+	}
+	/**
+	* Set the handler for incoming IPC requests from plugins.
+	*/
+	setRequestHandler(handler) {
+		this.requestHandler = handler;
+	}
+	/**
+	* Start listening on the Unix socket.
+	*/
+	async start() {
+		try {
+			unlinkSync(this.socketPath);
+		} catch {}
+		return new Promise((resolve, reject) => {
+			this.server = createServer((socket) => {
+				this.handleConnection(socket);
+			});
+			this.server.on("error", (err) => {
+				logger$1.error({ err: err.message }, "IPC server error");
+				reject(err);
+			});
+			this.server.listen(this.socketPath, () => {
+				try {
+					chmodSync(this.socketPath, 384);
+				} catch (err) {
+					logger$1.warn({ err }, "Failed to chmod socket");
+				}
+				logger$1.info({ path: this.socketPath }, "IPC server listening");
+				resolve();
+			});
+		});
+	}
+	/**
+	* Stop the IPC server and disconnect all plugins.
+	*/
+	async stop() {
+		for (const conn of this.connections.values()) try {
+			this.sendEvent(conn, "daemon.shutdown", { reason: "daemon stopping" });
+			conn.socket.end();
+		} catch {}
+		return new Promise((resolve) => {
+			if (!this.server) {
+				resolve();
+				return;
+			}
+			this.server.close(() => {
+				try {
+					unlinkSync(this.socketPath);
+				} catch {}
+				logger$1.info("IPC server stopped");
+				resolve();
+			});
+			for (const conn of this.connections.values()) conn.socket.destroy();
+			this.connections.clear();
+		});
+	}
+	/**
+	* Send an IPC request to a specific plugin and wait for response.
+	*/
+	async sendRequest(pluginId, method, params, timeoutMs = 3e4) {
+		const conn = this.connections.get(pluginId);
+		if (!conn?.info) return {
+			id: "",
+			ok: false,
+			error: {
+				code: "PLUGIN_NOT_CONNECTED",
+				message: `Plugin ${pluginId} not connected`
+			}
+		};
+		const id = pluginConnectionId();
+		const request = {
+			type: "req",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				conn.pending.delete(id);
+				resolve({
+					id,
+					ok: false,
+					error: {
+						code: "TIMEOUT",
+						message: `Request ${method} timed out after ${String(timeoutMs)}ms`
+					}
+				});
+			}, timeoutMs);
+			conn.pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+			try {
+				conn.socket.write(JSON.stringify(request) + "\n");
+			} catch (err) {
+				clearTimeout(timer);
+				conn.pending.delete(id);
+				resolve({
+					id,
+					ok: false,
+					error: {
+						code: "SEND_FAILED",
+						message: `Failed to send to plugin: ${err instanceof Error ? err.message : String(err)}`
+					}
+				});
+			}
+		});
+	}
+	/**
+	* Send an IPC request to ALL registered plugins.
+	* Returns responses keyed by plugin ID.
+	*/
+	async broadcastRequest(method, params, timeoutMs = 3e4) {
+		const results = /* @__PURE__ */ new Map();
+		const registered = this.getRegisteredPlugins();
+		await Promise.all(registered.map(async ([pluginId]) => {
+			const response = await this.sendRequest(pluginId, method, params, timeoutMs);
+			results.set(pluginId, response);
+		}));
+		return results;
+	}
+	/**
+	* Send an event to a specific plugin (fire-and-forget).
+	*/
+	sendEventToPlugin(pluginId, event, payload) {
+		const conn = this.connections.get(pluginId);
+		if (!conn) return false;
+		return this.sendEvent(conn, event, payload);
+	}
+	/**
+	* Broadcast an event to all connected plugins.
+	*/
+	broadcastEvent(event, payload) {
+		for (const conn of this.connections.values()) if (conn.info) this.sendEvent(conn, event, payload);
+	}
+	/**
+	* Get all registered plugins and their info.
+	*/
+	getRegisteredPlugins() {
+		const plugins = [];
+		for (const [id, conn] of this.connections) if (conn.info) plugins.push([id, conn.info]);
+		return plugins;
+	}
+	/**
+	* Get number of connected plugins (including unregistered).
+	*/
+	get connectionCount() {
+		return this.connections.size;
+	}
+	/**
+	* Get number of registered plugins.
+	*/
+	get registeredCount() {
+		let count = 0;
+		for (const conn of this.connections.values()) if (conn.info) count++;
+		return count;
+	}
+	handleConnection(socket) {
+		const connId = pluginConnectionId();
+		const conn = {
+			id: connId,
+			socket,
+			info: null,
 			buffer: "",
 			pending: /* @__PURE__ */ new Map()
 		};
@@ -6688,590 +7248,576 @@ var IPCServer = class {
 	sendResponse(conn, response) {
 		try {
 			conn.socket.write(JSON.stringify(response) + "\n");
-		} catch (err) {
-			logger$1.error({
-				connId: conn.id,
-				err
-			}, "IPC: failed to send response");
-		}
-	}
-	sendEvent(conn, event, payload) {
-		try {
-			const msg = createIPCEvent(event, payload);
-			conn.socket.write(JSON.stringify(msg) + "\n");
-			return true;
-		} catch {
-			return false;
-		}
-	}
-};
-//#endregion
-//#region src/command-queue.ts
-const DEFAULT_TTL_MS$1 = 300 * 1e3;
-var CommandQueue = class {
-	queues = /* @__PURE__ */ new Map();
-	ttlMs;
-	gcTimer = null;
-	constructor(ttlMs = DEFAULT_TTL_MS$1) {
-		this.ttlMs = ttlMs;
-	}
-	/**
-	* Start periodic garbage collection of expired commands.
-	*/
-	startGC(intervalMs = 3e4) {
-		this.stopGC();
-		this.gcTimer = setInterval(() => this.purgeExpired(), intervalMs);
-	}
-	/**
-	* Stop periodic garbage collection.
-	*/
-	stopGC() {
-		if (this.gcTimer) {
-			clearInterval(this.gcTimer);
-			this.gcTimer = null;
-		}
-	}
-	/**
-	* Enqueue a command for a specific service.
-	*/
-	enqueue(serviceId, request, commandId) {
-		let queue = this.queues.get(serviceId);
-		if (!queue) {
-			queue = [];
-			this.queues.set(serviceId, queue);
-		}
-		queue.push({
-			request,
-			queuedAt: Date.now(),
-			commandId
-		});
-	}
-	/**
-	* Drain all pending (non-expired) commands for a service.
-	* Returns them in order and removes them from the queue.
-	*/
-	drain(serviceId) {
-		const queue = this.queues.get(serviceId);
-		if (!queue || queue.length === 0) return [];
-		const now = Date.now();
-		const valid = queue.filter((cmd) => now - cmd.queuedAt < this.ttlMs);
-		this.queues.delete(serviceId);
-		return valid;
-	}
-	/**
-	* Get the number of pending commands for a service.
-	*/
-	pendingCount(serviceId) {
-		const queue = this.queues.get(serviceId);
-		if (!queue) return 0;
-		const now = Date.now();
-		return queue.filter((cmd) => now - cmd.queuedAt < this.ttlMs).length;
-	}
-	/**
-	* Get total pending commands across all services.
-	*/
-	totalPending() {
-		let total = 0;
-		for (const [serviceId] of this.queues) total += this.pendingCount(serviceId);
-		return total;
-	}
-	/**
-	* Remove expired commands from all queues.
-	*/
-	purgeExpired() {
-		const now = Date.now();
-		let purged = 0;
-		for (const [serviceId, queue] of this.queues) {
-			const before = queue.length;
-			const remaining = queue.filter((cmd) => now - cmd.queuedAt < this.ttlMs);
-			if (remaining.length === 0) this.queues.delete(serviceId);
-			else this.queues.set(serviceId, remaining);
-			purged += before - remaining.length;
-		}
-		return purged;
-	}
-	/**
-	* Clear all queues.
-	*/
-	clear() {
-		this.queues.clear();
+		} catch (err) {
+			logger$1.error({
+				connId: conn.id,
+				err
+			}, "IPC: failed to send response");
+		}
 	}
-	/**
-	* Get all service IDs that have pending commands.
-	*/
-	serviceIds() {
-		return Array.from(this.queues.keys());
+	sendEvent(conn, event, payload) {
+		try {
+			const msg = createIPCEvent(event, payload);
+			conn.socket.write(JSON.stringify(msg) + "\n");
+			return true;
+		} catch {
+			return false;
+		}
 	}
 };
 //#endregion
-//#region src/process-manager.ts
+//#region src/daemon-bootstrap.ts
 /**
-* Process management — launchd/systemd service installation.
+* Daemon bootstrap helpers — startup ordering, config/version resolution,
+* AI-proxy + IPC server wiring.
 *
-* Generates and installs user-space service units for auto-start on boot.
-* No root required — uses user agents (Mac) or user units (Linux).
-*/
-const LAUNCHD_LABEL = "ai.alfe.gateway";
-const SYSTEMD_SERVICE = "alfe-gateway";
-/**
-* On-disk path for the boot-time self-heal guard script (Linux only).
-* Written next to the systemd unit at setup time and invoked via
-* `ExecStartPre=` — see `writeGuardScript` and `generateSystemdUnit`.
-*/
-function getGuardScriptPath() {
-	return isRootUser() ? "/usr/local/lib/alfe/alfe-cli-guard.sh" : join(homedir(), ".alfe", "alfe-cli-guard.sh");
-}
-function isRootUser() {
-	return process.getuid?.() === 0;
-}
-function getSystemdSystemServicePath() {
-	return `/etc/systemd/system/${SYSTEMD_SERVICE}.service`;
-}
-function getLaunchdPlistPath() {
-	return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-}
-function getSystemdServicePath() {
-	return join(homedir(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
-}
-/**
-* Resolve the alfe CLI path. Globally installed via npm, always in PATH.
-*/
-function getAlfeBinPath() {
-	try {
-		return execSync("which alfe", { encoding: "utf-8" }).trim();
-	} catch {
-		return "alfe";
-	}
-}
-/**
-* Build the PATH for the launchd plist, ensuring the directory containing the
-* resolved alfe binary is included (e.g. /opt/homebrew/bin on Apple Silicon).
-*/
-function buildLaunchdPath(alfeBin) {
-	const basePaths = [
-		"/usr/local/bin",
-		"/usr/bin",
-		"/bin",
-		join(homedir(), ".local", "bin")
-	];
-	const binDir = dirname(alfeBin);
-	if (binDir && !basePaths.includes(binDir)) basePaths.unshift(binDir);
-	return basePaths.join(":");
-}
-/**
-* Generate a launchd plist for macOS.
+* Extracted from daemon.ts (which remains the orchestrator). These are the
+* standalone pieces of `startDaemon()`: version detection, the one-shot
+* persona-file migration, the AI proxy listener, and the IPC server start.
 */
-function generateLaunchdPlist() {
-	const alfeBin = getAlfeBinPath();
-	return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${LAUNCHD_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${alfeBin}</string>
-    <string>gateway</string>
-    <string>daemon</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>ThrottleInterval</key>
-  <integer>10</integer>
-  <key>StandardOutPath</key>
-  <string>${join(homedir(), ".alfe", "logs", "gateway.log")}</string>
-  <key>StandardErrorPath</key>
-  <string>${join(homedir(), ".alfe", "logs", "gateway.err.log")}</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>NODE_ENV</key>
-    <string>production</string>
-    <key>PATH</key>
-    <string>${buildLaunchdPath(alfeBin)}</string>
-  </dict>
-</dict>
-</plist>`;
-}
+const execFileAsync$2 = promisify(execFile);
 /**
-* Boot-time self-heal guard (Linux only).
-*
-* Runs as an `ExecStartPre=` BEFORE the daemon launches, OUTSIDE the
-* (possibly-broken) `alfe` binary. It exists for the case defense #1
-* (verify-before-exit in `upgrade.ts`) structurally cannot cover: the daemon
-* is KILLED during `npm install -g @alfe.ai/cli` (reboot / OOM), leaving the
-* package with deps but no `dist/` and a dangling `/usr/bin/alfe` symlink.
-* systemd then execs a dangling binary forever → 203/EXEC crash-loop, a
-* permanent brick with no automatic recovery (real prod incident,
-* ~13,570 restarts over 2 days).
-*
-* The guard:
-*   - checks the CLI is intact: the symlink target (`dist/index.js`) exists AND
-*     `alfe --version` exits 0;
-*   - if broken, reinstalls `@alfe.ai/cli@$ALFE_CLI_VERSION` (the exact version
-*     baked into the unit's `Environment=`; falls back to `@latest` when
-*     unset), so the daemon then execs a working binary;
-*   - is idempotent + fast (no-op when healthy) and NEVER wedges boot: any of
-*     its own failures log + `exit 0` so a human can still SSH in.
+* Resolve the installed @alfe.ai/cli version.
 *
-* POSIX sh (dash-safe): the box may not have bash. Keep the two intactness
-* checks in lockstep with `verifyCliInstall` in `verify-cli-install.ts`.
-*/
-/** @internal exported for unit tests; not re-exported from the barrel. */
-function generateGuardScript() {
-	const version = process.env.ALFE_CLI_VERSION;
-	return `#!/bin/sh
-# Alfe CLI boot-time self-heal guard. Auto-generated by 'alfe setup' — do not edit.
-# Repairs an interrupted 'npm install -g @alfe.ai/cli' before the daemon starts,
-# so a mid-install reboot can't brick the agent with a 203/EXEC crash-loop.
-# Must never wedge boot: every failure path logs and exits 0.
-set -u
-
-TARGET='${version && version.length > 0 ? `@alfe.ai/cli@${version}` : "@alfe.ai/cli@latest"}'
-log() { echo "[alfe-cli-guard] $*" >&2; }
-
-# Resolve the alfe bin and its real target (dist/index.js). readlink -f follows
-# the whole symlink chain; fall back to the bin path itself if unavailable.
-BIN="$(command -v alfe 2>/dev/null || true)"
-if [ -n "$BIN" ]; then
-  ENTRY="$(readlink -f "$BIN" 2>/dev/null || echo "$BIN")"
-else
-  ENTRY=""
-fi
-
-healthy=1
-if [ -z "$ENTRY" ] || [ ! -f "$ENTRY" ]; then
-  healthy=0
-  log "CLI entry missing (bin=\${BIN:-<none>} entry=\${ENTRY:-<none>})"
-elif ! alfe --version >/dev/null 2>&1; then
-  healthy=0
-  log "alfe --version failed"
-fi
-
-if [ "$healthy" -eq 1 ]; then
-  exit 0
-fi
-
-log "CLI install looks broken — reinstalling $TARGET"
-# Blow away a partial tree first so npm re-materialises dist/ cleanly. Best-effort.
-GLOBAL_ROOT="$(npm root -g 2>/dev/null || true)"
-if [ -n "$GLOBAL_ROOT" ] && [ -d "$GLOBAL_ROOT/@alfe.ai/cli" ]; then
-  rm -rf "$GLOBAL_ROOT/@alfe.ai/cli" 2>/dev/null || true
-fi
-
-# Bound the reinstall so a slow/unreachable registry at boot can't stall the
-# ExecStartPre up to systemd's DefaultTimeoutStartSec (~90s). Two layers:
-#   - npm --fetch-timeout/--fetch-retries cap per-request/hung-socket time;
-#   - a wall-clock 'timeout' wrapper caps the whole install when present
-#     ('timeout' isn't guaranteed, so fall back to a bare install).
-# stdout->stderr ('>&2') so npm's chatter lands in the journal, not on fd1.
-if command -v timeout >/dev/null 2>&1; then
-  timeout 120 npm install -g "$TARGET" --fetch-timeout=60000 --fetch-retries=2 >&2
-  rc=$?
-else
-  npm install -g "$TARGET" --fetch-timeout=60000 --fetch-retries=2 >&2
-  rc=$?
-fi
-if [ "$rc" -eq 0 ]; then
-  log "reinstall succeeded"
-else
-  log "reinstall FAILED (rc=$rc) — daemon start may still fail; a human can SSH in to repair"
-fi
-
-# Always exit 0: even a failed repair must not block the unit from attempting
-# ExecStart (which then fails visibly) rather than wedging silently in pre-start.
-exit 0
-`;
-}
-/**
-* Generate a systemd unit for Linux.
-* Root users get a system-level unit; non-root get a user-level unit.
+* Strategy (in order):
+*   1. ALFE_CLI_VERSION env var (set by CLI entry point when run directly)
+*   2. Walk up from this file to find @alfe.ai/cli/package.json
+*      (works when systemd runs the gateway binary directly, since
+*      the path is .../cli/node_modules/@alfe.ai/gateway/dist/...)
 */
-/** @internal exported for unit tests; not re-exported from the barrel. */
-function generateSystemdUnit() {
-	const alfeBin = getAlfeBinPath();
-	const root = isRootUser();
-	const envLines = [
-		"ALFE_MANAGED",
-		"ALFE_API_KEY",
-		"LOG_LEVEL",
-		"ALFE_CLI_VERSION"
-	].filter((key) => process.env[key]).map((key) => `Environment=${key}=${process.env[key] ?? ""}`).join("\n");
-	return `[Unit]
-Description=Alfe Gateway Daemon
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStartPre=-/bin/sh ${getGuardScriptPath()}
-ExecStart=${alfeBin} gateway daemon
-Restart=always
-RestartSec=10
-# SIGTERM only the daemon on stop/restart; it closes its MCP/runtime children
-# itself. The default (control-group) SIGTERMs the children simultaneously, so
-# they die before the daemon's orderly dispose reaches them and every planned
-# restart reports MCP "server-crash" noise to Sentry. Stragglers still get
-# SIGKILL when the stop timeout expires.
-KillMode=mixed
-Environment=NODE_ENV=production${root ? "\nEnvironment=HOME=/root\nWorkingDirectory=/root" : ""}
-${envLines}
-
-[Install]
-WantedBy=${root ? "multi-user.target" : "default.target"}`;
+async function getCliVersion() {
+	if (process.env.ALFE_CLI_VERSION) return process.env.ALFE_CLI_VERSION;
+	try {
+		const { fileURLToPath } = await import("node:url");
+		const { dirname } = await import("node:path");
+		let dir = dirname(fileURLToPath(import.meta.url));
+		for (let i = 0; i < 10; i++) {
+			const candidate = join(dir, "package.json");
+			try {
+				const raw = await readFile(candidate, "utf-8");
+				const pkg = JSON.parse(raw);
+				if (pkg.name === "@alfe.ai/cli") return pkg.version;
+			} catch {}
+			const parent = dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	} catch {}
+	logger$1.debug("Could not resolve @alfe.ai/cli version");
 }
 /**
-* Write the boot-time self-heal guard script to disk (Linux only) and make it
-* executable. Called from `installSystemd` before the unit is written.
+* Per-runtime "print installed version" commands. Local to the gateway — we do
+* NOT import the CLI's `detectRuntime` (`@alfe.ai/gateway` must not depend on
+* `@alfe.ai/cli`). Unknown runtimes resolve to `undefined` (never throw) so the
+* connection-status report degrades gracefully instead of crashing.
 */
-async function writeGuardScript() {
-	const guardPath = getGuardScriptPath();
-	await mkdir(dirname(guardPath), { recursive: true });
-	await writeFile(guardPath, generateGuardScript(), {
-		encoding: "utf-8",
-		mode: 493
-	});
-	logger$1.info({ path: guardPath }, "Wrote CLI self-heal guard script");
+const RUNTIME_VERSION_COMMANDS = {
+	openclaw: {
+		command: "openclaw",
+		args: ["--version"]
+	},
+	hermes: {
+		command: "hermes",
+		args: ["version"]
+	},
+	"claude-code": {
+		command: "alfe-claude-host",
+		args: ["--version"]
+	}
+};
+/**
+* Pure resolver (exported for tests) — the per-runtime version command, or
+* `undefined` for an unknown runtime.
+*/
+function resolveRuntimeVersionCommand(runtime) {
+	return RUNTIME_VERSION_COMMANDS[runtime];
 }
 /**
-* Install the service unit for the current platform.
+* Resolve the installed runtime version by running the per-runtime version
+* command and returning the trimmed stdout. An unknown runtime (no command in
+* the map) returns `undefined` without spawning — it must never throw.
 */
-async function installService() {
-	const platform = process.platform;
-	if (platform === "darwin") return installLaunchd();
-	if (platform === "linux") return installSystemd();
-	throw new Error(`Unsupported platform: ${platform}. Only macOS and Linux are supported.`);
+async function getRuntimeVersion(runtime) {
+	const cmd = resolveRuntimeVersionCommand(runtime);
+	if (!cmd) {
+		logger$1.debug({ runtime }, "No version command for runtime — skipping version detection");
+		return;
+	}
+	try {
+		const { stdout } = await execFileAsync$2(cmd.command, cmd.args);
+		return stdout.trim() || void 0;
+	} catch {
+		logger$1.debug({ runtime }, "Could not resolve runtime version");
+		return;
+	}
 }
 /**
-* Uninstall the service unit for the current platform.
+* Flush pino's async transport and exit.
+* process.exit() can drop buffered log lines — this ensures they're written first.
 */
-async function uninstallService() {
-	const platform = process.platform;
-	if (platform === "darwin") return uninstallLaunchd();
-	if (platform === "linux") return uninstallSystemd();
-	throw new Error(`Unsupported platform: ${platform}`);
+async function flushAndExit(code) {
+	await flushSentry();
+	await new Promise((resolve) => {
+		logger$1.flush();
+		setTimeout(resolve, 500);
+	});
+	process.exit(code);
 }
-function getLaunchdUid() {
-	return execSync("id -u", { encoding: "utf-8" }).trim();
+/**
+* One-shot migration for VMs provisioned before the persona-files-go-in-agent-workspace
+* fix landed. Old behavior wrote SOUL.md/IDENTITY.md/BOOTSTRAP.md/AGENTS.md at the
+* OpenClaw home (e.g. `~/.openclaw/`); the agent reads from the agent workspace
+* (e.g. `~/.openclaw/workspace/`). Move stale copies into place; skip if the
+* workspace already has the file. Idempotent and safe to run on every daemon start.
+*/
+const PERSONA_FILES = [
+	"SOUL.md",
+	"IDENTITY.md",
+	"BOOTSTRAP.md",
+	"AGENTS.md"
+];
+async function migrateLegacyPersonaFiles(home, agentWorkspace) {
+	if (home === agentWorkspace) return;
+	let moved = 0;
+	let skipped = 0;
+	for (const filename of PERSONA_FILES) {
+		const src = join(home, filename);
+		const dst = join(agentWorkspace, filename);
+		try {
+			await stat(src);
+		} catch {
+			continue;
+		}
+		try {
+			await stat(dst);
+			skipped++;
+			continue;
+		} catch {}
+		try {
+			await mkdir(agentWorkspace, { recursive: true });
+			await rename(src, dst);
+			moved++;
+		} catch (err) {
+			logger$1.warn({
+				src,
+				dst,
+				err: err instanceof Error ? err.message : String(err)
+			}, "Persona file migration: rename failed");
+		}
+	}
+	if (moved > 0 || skipped > 0) logger$1.info({
+		home,
+		agentWorkspace,
+		moved,
+		skipped
+	}, "Persona file backfill migration complete");
 }
-async function installLaunchd() {
-	const plistPath = getLaunchdPlistPath();
-	const dir = join(homedir(), "Library", "LaunchAgents");
-	const logsDir = join(homedir(), ".alfe", "logs");
-	await mkdir(dir, { recursive: true });
-	await mkdir(logsDir, { recursive: true });
-	await writeFile(plistPath, generateLaunchdPlist(), "utf-8");
-	logger$1.info({ path: plistPath }, "Wrote launchd plist");
-	const uid = getLaunchdUid();
-	try {
-		execSync(`launchctl bootout gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
-	} catch {}
+/**
+* Start the local AI proxy (before the runtime so LLM requests work
+* immediately). Failure is non-fatal — the daemon starts anyway and LLM
+* requests fail until the proxy is fixed.
+*/
+async function startAiProxy(apiKey) {
+	logger$1.debug("Starting AI proxy...");
+	const handle = {
+		server: null,
+		url: null,
+		running: false
+	};
 	try {
-		execSync(`launchctl bootstrap gui/${uid} ${plistPath}`, { stdio: "pipe" });
+		const { createProxyServer, DEFAULT_AI_PROXY_PORT } = await import("@alfe.ai/ai-proxy-local");
+		const { getAiServiceUrlFromToken } = await import("@alfe.ai/config");
+		const proxyUrl = getAiServiceUrlFromToken(apiKey);
+		const port = DEFAULT_AI_PROXY_PORT ?? 18193;
+		handle.server = createProxyServer({
+			port,
+			apiKey,
+			proxyUrl
+		});
+		const server = handle.server;
+		await new Promise((resolve, reject) => {
+			server.listen(port, "127.0.0.1", () => {
+				handle.running = true;
+				handle.url = `http://127.0.0.1:${String(port)}`;
+				logger$1.info({
+					port,
+					upstream: proxyUrl
+				}, "AI proxy started");
+				resolve();
+			});
+			server.on("error", reject);
+		});
 	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
+		const message = err instanceof Error ? err.message : String(err);
+		const stack = err instanceof Error ? err.stack : void 0;
 		logger$1.error({
-			err: msg,
-			plistPath
-		}, "launchctl bootstrap failed");
-		return `Installed plist at ${plistPath}, but failed to bootstrap service: ${msg}`;
+			err: message,
+			stack
+		}, "Failed to start AI proxy — LLM requests will fail");
 	}
-	return `Installed: ${plistPath}\nService will start on boot and restart on crash.`;
+	return handle;
 }
-async function uninstallLaunchd() {
-	const plistPath = getLaunchdPlistPath();
-	const uid = getLaunchdUid();
-	try {
-		execSync(`launchctl bootout gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
-	} catch {}
+/**
+* Start the IPC server (runtime plugins connect via this socket). A failure
+* here is fatal — plugins have no other path to the daemon — so this flushes
+* logs and exits instead of returning.
+*/
+async function startIpcServer(socketPath, requestHandler) {
+	logger$1.debug({ socketPath }, "Starting IPC server...");
+	const ipcServer = new IPCServer(socketPath);
+	ipcServer.setRequestHandler(requestHandler);
 	try {
-		await unlink(plistPath);
-	} catch {}
-	return `Uninstalled: ${plistPath}`;
+		await ipcServer.start();
+		logger$1.debug("IPC server started");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		const stack = err instanceof Error ? err.stack : void 0;
+		logger$1.error({
+			err: message,
+			stack
+		}, "Failed to start IPC server");
+		await flushAndExit(1);
+	}
+	return ipcServer;
 }
-async function installSystemd() {
-	const root = isRootUser();
-	const unitPath = root ? getSystemdSystemServicePath() : getSystemdServicePath();
-	const dir = root ? "/etc/systemd/system" : join(homedir(), ".config", "systemd", "user");
-	const ctl = root ? "systemctl" : "systemctl --user";
-	if (!root) await mkdir(dir, { recursive: true });
-	await writeGuardScript();
-	await writeFile(unitPath, generateSystemdUnit(), "utf-8");
-	logger$1.info({
-		path: unitPath,
-		root
-	}, "Wrote systemd unit");
-	try {
-		execSync(`${ctl} daemon-reload`, { stdio: "pipe" });
-		execSync(`${ctl} enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-	} catch {}
-	return `Installed: ${unitPath}\nService enabled${root ? " (system-level)" : " for user session"}.`;
+//#endregion
+//#region src/mcp-handlers.ts
+/**
+* Return the daemon-hosted MCP bundler's current namespaced tool catalog.
+* Called by the openclaw-mcp-bundler plugin on every tool-factory invocation;
+* cheap (in-memory snapshot, no I/O).
+*/
+function handleMcpListTools(bundler) {
+	if (!bundler) return {
+		ok: false,
+		error: {
+			code: "MCP_BUNDLER_UNAVAILABLE",
+			message: "MCP bundler not initialized"
+		}
+	};
+	return {
+		ok: true,
+		payload: { tools: bundler.listTools() }
+	};
 }
-async function uninstallSystemd() {
-	const root = isRootUser();
-	const unitPath = root ? getSystemdSystemServicePath() : getSystemdServicePath();
-	const ctl = root ? "systemctl" : "systemctl --user";
-	try {
-		execSync(`${ctl} disable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-		execSync(`${ctl} stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-	} catch {}
-	try {
-		await unlink(unitPath);
-	} catch {}
-	try {
-		await unlink(getGuardScriptPath());
-	} catch {}
-	try {
-		execSync(`${ctl} daemon-reload`, { stdio: "pipe" });
-	} catch {}
-	return `Uninstalled: ${unitPath}`;
+/**
+* Observability backstop for the INTEGRATION warm path. `applyForIntegration`
+* registers MCP servers into the store and the daemon warms them silently via
+* the store-change `onChange` hook — so a server that fails its connect (e.g.
+* an MCP server whose backing account/credential wasn't resolvable at warm
+* time, like ctrader-mcp `exit(1)`-ing on empty accounts) leaves NO trace,
+* making the black hole undiagnosable. After a warm, read `bundler.statuses()`
+* and warn once per still-failed server so the failure is visible. These
+* self-heal on the bundler's background retry sweep once the dependency
+* appears. Returns the servers it warned about (for tests / callers).
+*/
+function warnFailedMcpServers(bundler, log, reason) {
+	if (!bundler) return [];
+	const failed = bundler.statuses().filter((s) => !s.connected && s.lastError !== void 0);
+	for (const status of failed) log.warn({
+		server: status.name,
+		reason,
+		consecutiveFailures: status.consecutiveFailures,
+		lastError: status.lastError
+	}, `MCP server "${status.name}" failed to connect: ${status.lastError ?? ""}`);
+	return failed;
 }
 /**
-* Bootstrap (load) the launchd service from its plist if it isn't already
-* loaded. Already-loaded is an error we ignore. Needed so `start`/`restart`
-* work after `stopService()` boots the service OUT.
+* Route a tool call to the appropriate MCP child via the daemon-hosted
+* bundler. `name` is the prefixed (`mcp__<server>__<tool>`) name; args is
+* the raw JSON object the LLM produced.
 */
-function ensureLaunchdLoaded(uid) {
-	try {
-		execSync(`launchctl bootstrap gui/${uid} ${getLaunchdPlistPath()}`, { stdio: "pipe" });
-	} catch {}
-}
 /**
-* Start the installed service via systemctl/launchctl. Bootstraps the launchd
-* service first so this also works after `stopService()` booted it out.
+* List every server entry in the alfe bundler store. Lets agents inspect
+* what they've already registered before adding a new one.
 */
-function startService() {
-	const platform = process.platform;
-	if (platform === "darwin") {
-		const uid = getLaunchdUid();
-		ensureLaunchdLoaded(uid);
-		execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
-		logger$1.info("Started launchd service");
-		return;
-	}
-	if (platform === "linux") {
-		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} start ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-		logger$1.info("Started systemd service");
-		return;
-	}
-	throw new Error(`Unsupported platform: ${platform}`);
+function handleMcpListServers(manager) {
+	if (!manager) return {
+		ok: false,
+		error: {
+			code: "MCP_MANAGER_UNAVAILABLE",
+			message: "MCP manager not initialized"
+		}
+	};
+	const statuses = manager.serverStatuses ? manager.serverStatuses() : [];
+	const byName = new Map(statuses.map((s) => [s.name, s]));
+	return {
+		ok: true,
+		payload: { servers: manager.listServers().map(({ id, entry }) => ({
+			id,
+			entry,
+			status: byName.get(id) ?? {
+				name: id,
+				connected: false,
+				toolCount: 0,
+				consecutiveFailures: 0
+			}
+		})) }
+	};
 }
 /**
-* Restart the installed service via systemctl/launchctl. This is the
-* service-manager-native restart (`kickstart -k` / `systemctl restart`) — the
-* CLI uses it instead of killing the process inline, which would fight launchd
-* `KeepAlive` / systemd `Restart=always`.
+* How long the add-confirm probe waits for the freshly-added server to
+* connect before replying. This is effectively the whole budget for
+* `bundler.warmServer`: `Manager.addServer` now reconciles the bundler
+* BEFORE resolving, so the Connection object already exists and
+* `warmServer`'s pre-reconcile is a no-diff cheap pass. Kept well under the
+* plugin caller's 30s IPC timeout. A slower server still connects in the
+* background and surfaces on the next `alfe_mcp_list_tools` — the probe just
+* reports what it saw within the window; a missed connect is re-attempted by
+* the bundler's `retryNeverConnected` sweep.
 */
-function restartService() {
-	const platform = process.platform;
-	if (platform === "darwin") {
-		const uid = getLaunchdUid();
-		ensureLaunchdLoaded(uid);
-		execSync(`launchctl kickstart -k gui/${uid}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
-		logger$1.info("Restarted launchd service");
-		return;
-	}
-	if (platform === "linux") {
-		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} restart ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-		logger$1.info("Restarted systemd service");
-		return;
-	}
-	throw new Error(`Unsupported platform: ${platform}`);
-}
+const MCP_ADD_WARM_TIMEOUT_MS = 12e3;
 /**
-* Stop the installed service via systemctl/launchctl. On macOS this boots the
-* service OUT (unloads it) so launchd's `KeepAlive` does NOT respawn it;
-* `startService()` bootstraps it again. On Linux the unit stays enabled (starts
-* on next boot); `systemctl stop` just halts the current run.
+* Register a new MCP server in the alfe bundler store on behalf of the agent,
+* then CONFIRM the connect before replying so the agent learns whether the
+* server actually works. Owned as `'manual'` so the agent can later remove it
+* without an expectedOwner conflict — matches what `alfe mcp add` does from the
+* CLI. Registration is durable regardless of the probe outcome: a probe
+* failure (or a runtime with no daemon bundler, e.g. hermes) still returns
+* `ok` with `connected: false`; the store watcher / runtime picks the entry up.
 */
-function stopService() {
-	const platform = process.platform;
-	if (platform === "darwin") {
-		execSync(`launchctl bootout gui/${getLaunchdUid()}/${LAUNCHD_LABEL}`, { stdio: "pipe" });
-		logger$1.info("Stopped launchd service");
-		return;
+async function handleMcpAddServer(params, manager) {
+	if (!manager) return {
+		ok: false,
+		error: {
+			code: "MCP_MANAGER_UNAVAILABLE",
+			message: "MCP manager not initialized"
+		}
+	};
+	const p = params;
+	if (typeof p.id !== "string" || p.id.length === 0) return {
+		ok: false,
+		error: {
+			code: "INVALID_PARAMS",
+			message: "id is required (string)"
+		}
+	};
+	const config = buildServerConfig(p);
+	if (!config) return {
+		ok: false,
+		error: {
+			code: "INVALID_PARAMS",
+			message: "expected either { command, args?, env?, cwd? } for stdio or { url, transport, headers? } for remote"
+		}
+	};
+	try {
+		await manager.addServer(config, {
+			id: p.id,
+			owner: "manual"
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		logger$1.warn({
+			id: p.id,
+			err: message
+		}, "mcp.add_server failed");
+		return {
+			ok: false,
+			error: {
+				code: "MCP_ADD_FAILED",
+				message
+			}
+		};
 	}
-	if (platform === "linux") {
-		execSync(`${isRootUser() ? "systemctl" : "systemctl --user"} stop ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
-		logger$1.info("Stopped systemd service");
-		return;
+	let status = null;
+	if (manager.warmServer) try {
+		status = await manager.warmServer(p.id, MCP_ADD_WARM_TIMEOUT_MS);
+	} catch (err) {
+		logger$1.warn({
+			id: p.id,
+			err: err instanceof Error ? err.message : String(err)
+		}, "mcp.add_server warm probe threw");
 	}
-	throw new Error(`Unsupported platform: ${platform}`);
+	return {
+		ok: true,
+		payload: {
+			id: p.id,
+			connected: status?.connected ?? false,
+			toolCount: status?.toolCount ?? 0,
+			...status?.lastError !== void 0 ? { error: status.lastError } : {}
+		}
+	};
 }
-/**
-* True when the gateway is installed as a system service (launchd plist /
-* systemd unit present). Lets the CLI restart/stop/start THROUGH the service
-* manager instead of driving the daemon inline via the PID file.
-*/
-function isServiceInstalled() {
-	const platform = process.platform;
-	if (platform === "darwin") return existsSync(getLaunchdPlistPath());
-	if (platform === "linux") return existsSync(isRootUser() ? getSystemdSystemServicePath() : getSystemdServicePath());
-	return false;
+function buildServerConfig(p) {
+	if (typeof p.command === "string" && p.command.length > 0) {
+		const cfg = { command: p.command };
+		if (Array.isArray(p.args) && p.args.every((a) => typeof a === "string")) cfg.args = p.args;
+		if (p.env && typeof p.env === "object" && !Array.isArray(p.env)) {
+			const env = {};
+			for (const [k, v] of Object.entries(p.env)) if (typeof v === "string") env[k] = v;
+			cfg.env = env;
+		}
+		if (typeof p.cwd === "string") cfg.cwd = p.cwd;
+		return cfg;
+	}
+	if (typeof p.url === "string" && p.url.length > 0) {
+		const transport = p.transport === "streamable-http" ? "streamable-http" : "sse";
+		const cfg = {
+			url: p.url,
+			transport
+		};
+		if (p.headers && typeof p.headers === "object" && !Array.isArray(p.headers)) {
+			const headers = {};
+			for (const [k, v] of Object.entries(p.headers)) if (typeof v === "string") headers[k] = v;
+			cfg.headers = headers;
+		}
+		return cfg;
+	}
+	return null;
 }
 /**
-* Write the current process PID to the PID file.
+* Drop a server entry the agent previously registered. Restricted to
+* `manual`-owned entries so the agent can't accidentally clobber
+* integration-installed or CLI-installed servers (the daemon owns
+* those; the agent can ask the user to uninstall an integration via
+* the dashboard).
 */
-async function writePidFile() {
-	await writeFile(PID_PATH, String(process.pid), "utf-8");
+async function handleMcpRemoveServer(params, manager) {
+	if (!manager) return {
+		ok: false,
+		error: {
+			code: "MCP_MANAGER_UNAVAILABLE",
+			message: "MCP manager not initialized"
+		}
+	};
+	const { id } = params;
+	if (typeof id !== "string" || id.length === 0) return {
+		ok: false,
+		error: {
+			code: "INVALID_PARAMS",
+			message: "id is required (string)"
+		}
+	};
+	try {
+		return {
+			ok: true,
+			payload: { removed: await manager.removeServer(id, { expectedOwner: "manual" }) }
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (message.includes("owned by")) return {
+			ok: false,
+			error: {
+				code: "MCP_OWNER_MISMATCH",
+				message
+			}
+		};
+		logger$1.warn({
+			id,
+			err: message
+		}, "mcp.remove_server failed");
+		return {
+			ok: false,
+			error: {
+				code: "MCP_REMOVE_FAILED",
+				message
+			}
+		};
+	}
 }
-/**
-* Remove the PID file.
-*/
-async function removePidFile() {
+async function handleMcpCallTool(bundler, params) {
+	if (!bundler) return {
+		ok: false,
+		error: {
+			code: "MCP_BUNDLER_UNAVAILABLE",
+			message: "MCP bundler not initialized"
+		}
+	};
+	const { name, args } = params;
+	if (typeof name !== "string" || name.length === 0) return {
+		ok: false,
+		error: {
+			code: "INVALID_PARAMS",
+			message: "name is required (string)"
+		}
+	};
 	try {
-		await unlink(PID_PATH);
-	} catch {}
+		return {
+			ok: true,
+			payload: await bundler.callTool(name, args)
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		logger$1.warn({
+			tool: name,
+			err: message
+		}, "mcp.call_tool failed");
+		return {
+			ok: false,
+			error: {
+				code: "MCP_CALL_FAILED",
+				message
+			}
+		};
+	}
 }
+//#endregion
+//#region src/integration-bootstrap.ts
 /**
-* Check if a daemon is already running.
-* Returns the PID if alive, null if not running.
+* Adapter from `AgentApiClient`'s per-provider methods to the
+* `CredentialsResolver` shape the MCP applier expects. Returns
+* `undefined` for unknown providers and on 404/network error so the
+* applier can skip registration silently (its documented contract).
 */
-async function checkExistingDaemon() {
-	if (!existsSync(PID_PATH)) return null;
-	try {
-		const pidStr = await readFile(PID_PATH, "utf-8");
-		const pid = parseInt(pidStr.trim(), 10);
-		if (isNaN(pid)) {
-			await removePidFile();
-			return null;
+async function fetchProviderCredentials(agentApi, provider, connectionId) {
+	if (connectionId) try {
+		const raw = await agentApi.getConnectionCredentials(connectionId);
+		const fields = { ...raw.providerMetadata ?? {} };
+		if (typeof raw.accessToken === "string" && raw.accessToken.length > 0) try {
+			const bundle = JSON.parse(raw.accessToken);
+			if (bundle && typeof bundle === "object" && !Array.isArray(bundle)) Object.assign(fields, bundle);
+		} catch (err) {
+			logger$1.warn({
+				connectionId,
+				err: err instanceof Error ? err.message : String(err)
+			}, "Custom connection accessToken is not a JSON bundle — exposing as accessToken field");
+			fields.accessToken = raw.accessToken;
 		}
-		try {
-			process.kill(pid, 0);
-			return pid;
-		} catch {
-			await removePidFile();
-			return null;
+		return fields;
+	} catch (err) {
+		logger$1.warn({
+			connectionId,
+			err: err instanceof Error ? err.message : String(err)
+		}, "Failed to resolve connection-scoped credentials — MCP server will be skipped");
+		return;
+	}
+	const key = provider.toLowerCase();
+	try {
+		switch (key) {
+			case "atlassian": return await agentApi.getAtlassianCredentials();
+			case "github": return await agentApi.getGithubCredentials();
+			case "xero": return await agentApi.getXeroCredentials();
+			case "notion": return await agentApi.getNotionCredentials();
+			case "myob": return await agentApi.getMYOBCredentials();
+			case "google": return await agentApi.getGoogleCredentials();
+			default:
+				logger$1.warn({ provider }, "Unknown OAuth provider for requires_credentials — MCP server will be skipped");
+				return;
 		}
 	} catch {
-		return null;
+		return;
 	}
 }
 /**
-* Send SIGTERM to an existing daemon process.
+* Post-reconcile trigger: rebuild the command registry from the manager's
+* active integrations and report the available commands to the cloud
+* gateway. Wired by daemon.ts as the cloud client's
+* `onReconciliationComplete` callback.
 */
-async function stopExistingDaemon() {
-	const pid = await checkExistingDaemon();
-	if (!pid) return false;
+function reportAvailableCommands(deps) {
+	const { integrationManager, commandRegistry, cloudClient } = deps;
 	try {
-		process.kill(pid, "SIGTERM");
-		for (let i = 0; i < 50; i++) {
-			await new Promise((r) => setTimeout(r, 100));
-			try {
-				process.kill(pid, 0);
-			} catch {
-				await removePidFile();
-				return true;
-			}
-		}
-		process.kill(pid, "SIGKILL");
-		await removePidFile();
-		return true;
-	} catch {
-		await removePidFile();
-		return false;
+		const activeCommands = integrationManager.getActiveCommands();
+		commandRegistry.clear();
+		for (const { integrationId, commands } of activeCommands) for (const cmd of commands) commandRegistry.register(integrationId, cmd.name, cmd.resolvedPath, cmd.method, cmd.timeoutMs);
+		const commandsMsg = {
+			type: "COMMANDS_AVAILABLE",
+			commands: commandRegistry.listCommands()
+		};
+		cloudClient.sendMessage(commandsMsg);
+		logger$1.info({ commandCount: commandsMsg.commands.length }, "Reported available commands to cloud");
+	} catch (err) {
+		logger$1.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to rebuild command registry");
 	}
 }
 //#endregion
@@ -23151,7 +23697,7 @@ var CommandDedupe = class {
 *      the gateway when needed and uses `callerScopes: ["operator.admin"]`.
 *   3. Skip iteration if `pending.json` mtime hasn't changed (cheap fast path)
 */
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$1 = promisify(execFile);
 const APPROVE_TIMEOUT_MS = 1e4;
 function resolveStateDir(override) {
 	if (override) return override;
@@ -23250,7 +23796,7 @@ function startPairingApprovalPoller(opts) {
 	const intervalMs = opts.intervalMs ?? 3e4;
 	const cliLock = opts.cliLock ?? new NoopOpenClawCliLock();
 	const rawExec = opts.exec ?? (async (file, args, { timeout }) => {
-		const { stdout, stderr } = await execFileAsync$2(file, args, { timeout });
+		const { stdout, stderr } = await execFileAsync$1(file, args, { timeout });
 		return {
 			stdout,
 			stderr
@@ -23324,12 +23870,12 @@ function startPairingApprovalPoller(opts) {
 * Sentinel-gated at `~/.alfe/.openclaw-mirror-migrated` — runs exactly
 * once per agent.
 */
-const execFileAsync$1 = promisify(execFile);
+const execFileAsync = promisify(execFile);
 const DEFAULT_SENTINEL_PATH = join(homedir(), ".alfe", ".openclaw-mirror-migrated");
 const defaultOpenclaw = {
 	async listServers() {
 		try {
-			const { stdout } = await execFileAsync$1("openclaw", [
+			const { stdout } = await execFileAsync("openclaw", [
 				"config",
 				"get",
 				"mcp.servers"
@@ -23346,7 +23892,7 @@ const defaultOpenclaw = {
 		}
 	},
 	async unsetServer(key) {
-		await execFileAsync$1("openclaw", [
+		await execFileAsync("openclaw", [
 			"config",
 			"unset",
 			`mcp.servers.${key}`
@@ -23528,8 +24074,12 @@ function createMcpErrorHooks() {
 *   7. Start agent runtime (managed mode only — e.g. OpenClaw)
 *   8. Write PID file (non-managed only)
 *   9. Handle graceful shutdown
+*
+* Split along seams (this file stays the orchestrator):
+*   - daemon-bootstrap.ts     — version resolution, persona migration, AI-proxy + IPC start
+*   - mcp-handlers.ts         — `mcp.*` IPC request handlers
+*   - integration-bootstrap.ts — provider-credential fetch + post-reconcile command reporting
 */
-const execFileAsync = promisify(execFile);
 let config;
 let cloudClient;
 let ipcServer = null;
@@ -23561,202 +24111,21 @@ let cloudConnected = false;
 * Dedupe for at-least-once durable command delivery (Phase B). The cloud may
 * push a command over the live WS AND re-drain the same commandId on the next
 * SERVICE_REGISTER; both hit handleCloudCommand. This remembers recent outcomes
-* so a duplicate is ACKed with the prior result without re-executing.
-*/
-const commandDedupe = new CommandDedupe();
-let shuttingDown = false;
-let commandRegistry;
-let resolvedCliVersion;
-let resolvedRuntimeVersion;
-let upgradingRuntime = false;
-let stopPairingApprovalPoller = null;
-/**
-* Module-level handle on the runtime appliers built during start(), so the
-* module-scoped command handler can route `alfe.config_set` to the active
-* runtime's applier (mirrors `mcpManagerRef`). Null until start() builds it.
-*/
-let runtimeAppliersRef = null;
-/**
-* Resolve the installed @alfe.ai/cli version.
-*
-* Strategy (in order):
-*   1. ALFE_CLI_VERSION env var (set by CLI entry point when run directly)
-*   2. Walk up from this file to find @alfe.ai/cli/package.json
-*      (works when systemd runs the gateway binary directly, since
-*      the path is .../cli/node_modules/@alfe.ai/gateway/dist/...)
-*/
-/**
-* Adapter from `AgentApiClient`'s per-provider methods to the
-* `CredentialsResolver` shape the MCP applier expects. Returns
-* `undefined` for unknown providers and on 404/network error so the
-* applier can skip registration silently (its documented contract).
-*/
-async function fetchProviderCredentials(agentApi, provider, connectionId) {
-	if (connectionId) try {
-		const raw = await agentApi.getConnectionCredentials(connectionId);
-		const fields = { ...raw.providerMetadata ?? {} };
-		if (typeof raw.accessToken === "string" && raw.accessToken.length > 0) try {
-			const bundle = JSON.parse(raw.accessToken);
-			if (bundle && typeof bundle === "object" && !Array.isArray(bundle)) Object.assign(fields, bundle);
-		} catch (err) {
-			logger$1.warn({
-				connectionId,
-				err: err instanceof Error ? err.message : String(err)
-			}, "Custom connection accessToken is not a JSON bundle — exposing as accessToken field");
-			fields.accessToken = raw.accessToken;
-		}
-		return fields;
-	} catch (err) {
-		logger$1.warn({
-			connectionId,
-			err: err instanceof Error ? err.message : String(err)
-		}, "Failed to resolve connection-scoped credentials — MCP server will be skipped");
-		return;
-	}
-	const key = provider.toLowerCase();
-	try {
-		switch (key) {
-			case "atlassian": return await agentApi.getAtlassianCredentials();
-			case "github": return await agentApi.getGithubCredentials();
-			case "xero": return await agentApi.getXeroCredentials();
-			case "notion": return await agentApi.getNotionCredentials();
-			case "myob": return await agentApi.getMYOBCredentials();
-			case "google": return await agentApi.getGoogleCredentials();
-			default:
-				logger$1.warn({ provider }, "Unknown OAuth provider for requires_credentials — MCP server will be skipped");
-				return;
-		}
-	} catch {
-		return;
-	}
-}
-async function getCliVersion() {
-	if (process.env.ALFE_CLI_VERSION) return process.env.ALFE_CLI_VERSION;
-	try {
-		const { fileURLToPath } = await import("node:url");
-		const { dirname } = await import("node:path");
-		let dir = dirname(fileURLToPath(import.meta.url));
-		for (let i = 0; i < 10; i++) {
-			const candidate = join(dir, "package.json");
-			try {
-				const raw = await readFile(candidate, "utf-8");
-				const pkg = JSON.parse(raw);
-				if (pkg.name === "@alfe.ai/cli") return pkg.version;
-			} catch {}
-			const parent = dirname(dir);
-			if (parent === dir) break;
-			dir = parent;
-		}
-	} catch {}
-	logger$1.debug("Could not resolve @alfe.ai/cli version");
-}
-/**
-* Per-runtime "print installed version" commands. Local to the gateway — we do
-* NOT import the CLI's `detectRuntime` (`@alfe.ai/gateway` must not depend on
-* `@alfe.ai/cli`). Unknown runtimes resolve to `undefined` (never throw) so the
-* connection-status report degrades gracefully instead of crashing.
-*/
-const RUNTIME_VERSION_COMMANDS = {
-	openclaw: {
-		command: "openclaw",
-		args: ["--version"]
-	},
-	hermes: {
-		command: "hermes",
-		args: ["version"]
-	},
-	"claude-code": {
-		command: "alfe-claude-host",
-		args: ["--version"]
-	}
-};
-/**
-* Pure resolver (exported for tests) — the per-runtime version command, or
-* `undefined` for an unknown runtime.
-*/
-function resolveRuntimeVersionCommand(runtime) {
-	return RUNTIME_VERSION_COMMANDS[runtime];
-}
-/**
-* Resolve the installed runtime version by running the per-runtime version
-* command and returning the trimmed stdout. An unknown runtime (no command in
-* the map) returns `undefined` without spawning — it must never throw.
-*/
-async function getRuntimeVersion(runtime) {
-	const cmd = resolveRuntimeVersionCommand(runtime);
-	if (!cmd) {
-		logger$1.debug({ runtime }, "No version command for runtime — skipping version detection");
-		return;
-	}
-	try {
-		const { stdout } = await execFileAsync(cmd.command, cmd.args);
-		return stdout.trim() || void 0;
-	} catch {
-		logger$1.debug({ runtime }, "Could not resolve runtime version");
-		return;
-	}
-}
-/**
-* Flush pino's async transport and exit.
-* process.exit() can drop buffered log lines — this ensures they're written first.
+* so a duplicate is ACKed with the prior result without re-executing.
 */
-async function flushAndExit(code) {
-	await flushSentry();
-	await new Promise((resolve) => {
-		logger$1.flush();
-		setTimeout(resolve, 500);
-	});
-	process.exit(code);
-}
+const commandDedupe = new CommandDedupe();
+let shuttingDown = false;
+let commandRegistry;
+let resolvedCliVersion;
+let resolvedRuntimeVersion;
+let upgradingRuntime = false;
+let stopPairingApprovalPoller = null;
 /**
-* One-shot migration for VMs provisioned before the persona-files-go-in-agent-workspace
-* fix landed. Old behavior wrote SOUL.md/IDENTITY.md/BOOTSTRAP.md/AGENTS.md at the
-* OpenClaw home (e.g. `~/.openclaw/`); the agent reads from the agent workspace
-* (e.g. `~/.openclaw/workspace/`). Move stale copies into place; skip if the
-* workspace already has the file. Idempotent and safe to run on every daemon start.
+* Module-level handle on the runtime appliers built during start(), so the
+* module-scoped command handler can route `alfe.config_set` to the active
+* runtime's applier (mirrors `mcpManagerRef`). Null until start() builds it.
 */
-const PERSONA_FILES = [
-	"SOUL.md",
-	"IDENTITY.md",
-	"BOOTSTRAP.md",
-	"AGENTS.md"
-];
-async function migrateLegacyPersonaFiles(home, agentWorkspace) {
-	if (home === agentWorkspace) return;
-	let moved = 0;
-	let skipped = 0;
-	for (const filename of PERSONA_FILES) {
-		const src = join(home, filename);
-		const dst = join(agentWorkspace, filename);
-		try {
-			await stat(src);
-		} catch {
-			continue;
-		}
-		try {
-			await stat(dst);
-			skipped++;
-			continue;
-		} catch {}
-		try {
-			await mkdir(agentWorkspace, { recursive: true });
-			await rename(src, dst);
-			moved++;
-		} catch (err) {
-			logger$1.warn({
-				src,
-				dst,
-				err: err instanceof Error ? err.message : String(err)
-			}, "Persona file migration: rename failed");
-		}
-	}
-	if (moved > 0 || skipped > 0) logger$1.info({
-		home,
-		agentWorkspace,
-		moved,
-		skipped
-	}, "Persona file backfill migration complete");
-}
+let runtimeAppliersRef = null;
 async function startDaemon() {
 	startedAt = Date.now();
 	const managed = isManagedMode();
@@ -23816,54 +24185,12 @@ async function startDaemon() {
 	commandQueue = new CommandQueue();
 	commandQueue.startGC();
 	commandRegistry = new CommandRegistry();
-	logger$1.debug("Starting AI proxy...");
-	try {
-		const { createProxyServer, DEFAULT_AI_PROXY_PORT } = await import("@alfe.ai/ai-proxy-local");
-		const { getAiServiceUrlFromToken } = await import("@alfe.ai/config");
-		const proxyUrl = getAiServiceUrlFromToken(config.apiKey);
-		const port = DEFAULT_AI_PROXY_PORT ?? 18193;
-		aiProxyServer = createProxyServer({
-			port,
-			apiKey: config.apiKey,
-			proxyUrl
-		});
-		const server = aiProxyServer;
-		await new Promise((resolve, reject) => {
-			server.listen(port, "127.0.0.1", () => {
-				aiProxyRunning = true;
-				aiProxyUrl = `http://127.0.0.1:${String(port)}`;
-				logger$1.info({
-					port,
-					upstream: proxyUrl
-				}, "AI proxy started");
-				resolve();
-			});
-			server.on("error", reject);
-		});
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		const stack = err instanceof Error ? err.stack : void 0;
-		logger$1.error({
-			err: message,
-			stack
-		}, "Failed to start AI proxy — LLM requests will fail");
-	}
-	logger$1.debug({ socketPath: config.socketPath }, "Starting IPC server...");
-	ipcServer = new IPCServer(config.socketPath);
-	ipcServer.setRequestHandler(handlePluginRequest);
+	const aiProxy = await startAiProxy(config.apiKey);
+	aiProxyServer = aiProxy.server;
+	aiProxyUrl = aiProxy.url;
+	aiProxyRunning = aiProxy.running;
+	ipcServer = await startIpcServer(config.socketPath, handlePluginRequest);
 	turnActivityProbe = new IpcTurnActivityProbe(() => ipcServer);
-	try {
-		await ipcServer.start();
-		logger$1.debug("IPC server started");
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		const stack = err instanceof Error ? err.stack : void 0;
-		logger$1.error({
-			err: message,
-			stack
-		}, "Failed to start IPC server");
-		await flushAndExit(1);
-	}
 	resolvedCliVersion = await getCliVersion();
 	resolvedRuntimeVersion = await getRuntimeVersion(config.runtime);
 	logger$1.info({
@@ -24007,19 +24334,11 @@ async function startDaemon() {
 		}
 	}
 	cloudClient.setOnReconciliationComplete(() => {
-		try {
-			const activeCommands = integrationManager.getActiveCommands();
-			commandRegistry.clear();
-			for (const { integrationId, commands } of activeCommands) for (const cmd of commands) commandRegistry.register(integrationId, cmd.name, cmd.resolvedPath, cmd.method, cmd.timeoutMs);
-			const commandsMsg = {
-				type: "COMMANDS_AVAILABLE",
-				commands: commandRegistry.listCommands()
-			};
-			cloudClient.sendMessage(commandsMsg);
-			logger$1.info({ commandCount: commandsMsg.commands.length }, "Reported available commands to cloud");
-		} catch (err) {
-			logger$1.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to rebuild command registry");
-		}
+		reportAvailableCommands({
+			integrationManager,
+			commandRegistry,
+			cloudClient
+		});
 	});
 	cloudClient.start();
 	logger$1.debug("Cloud client started");
@@ -24311,513 +24630,244 @@ async function executeCloudCommand(command) {
 			}
 			const integrations = integrationManager.list();
 			return {
-				type: "COMMAND_ACK",
-				commandId: command.commandId,
-				status: "ok",
-				result: { integrations }
-			};
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			logger$1.error({ err: message }, "Integration status failed");
-			return {
-				type: "COMMAND_ACK",
-				commandId: command.commandId,
-				status: "error",
-				result: {
-					code: "STATUS_FAILED",
-					message
-				}
-			};
-		}
-	}
-	if (command.command === "alfe.config_set") {
-		const payload = command.payload;
-		const key = payload?.key;
-		const value = payload?.value;
-		if (!key || value === void 0) return {
-			type: "COMMAND_ACK",
-			commandId: command.commandId,
-			status: "error",
-			result: {
-				code: "INVALID_PAYLOAD",
-				message: "alfe.config_set requires key and value"
-			}
-		};
-		const runtime = config.runtime;
-		const applier = runtimeAppliersRef?.get(runtime);
-		if (!applier || typeof applier.setConfigRaw !== "function") {
-			const message = `No runtime applier supports config_set for runtime "${runtime}"`;
-			logger$1.warn({
-				runtime,
-				key
-			}, message);
-			return {
-				type: "COMMAND_ACK",
-				commandId: command.commandId,
-				status: "error",
-				result: {
-					code: "CONFIG_SET_UNSUPPORTED",
-					message
-				}
-			};
-		}
-		try {
-			await applier.setConfigRaw(key, value);
-			logger$1.info({
-				runtime,
-				key
-			}, "Applied config via runtime applier setConfigRaw");
-			return {
-				type: "COMMAND_ACK",
-				commandId: command.commandId,
-				status: "ok",
-				result: {
-					key,
-					value
-				}
-			};
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			logger$1.error({
-				err: message,
-				runtime,
-				key
-			}, "Failed to apply config via runtime applier");
-			return {
-				type: "COMMAND_ACK",
-				commandId: command.commandId,
-				status: "error",
-				result: {
-					code: "CONFIG_SET_FAILED",
-					message
-				}
-			};
-		}
-	}
-	if (commandRegistry.has(command.command)) try {
-		const ctx = buildCommandContext();
-		const result = await commandRegistry.execute(command.command, typeof command.payload === "object" && command.payload !== null ? command.payload : {}, ctx);
-		return {
-			type: "COMMAND_ACK",
-			commandId: command.commandId,
-			status: result.status,
-			result: result.result
-		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		logger$1.error({
-			err: message,
-			command: command.command
-		}, "Command registry execution failed");
-		return {
-			type: "COMMAND_ACK",
-			commandId: command.commandId,
-			status: "error",
-			result: {
-				code: "REGISTRY_ERROR",
-				message
-			}
-		};
-	}
-	const ipcRequest = cloudCommandToIPCRequest(command);
-	if (!ipcRequest) {
-		logger$1.warn({ command: command.command }, "Unrecognized cloud command");
-		return {
-			type: "COMMAND_ACK",
-			commandId: command.commandId,
-			status: "error",
-			result: {
-				code: "UNKNOWN_COMMAND",
-				message: `Unrecognized command: ${command.command}`
-			}
-		};
-	}
-	const plugins = ipcServer?.getRegisteredPlugins() ?? [];
-	if (plugins.length === 0) {
-		logger$1.info({
-			commandId: command.commandId,
-			command: command.command
-		}, "No plugins connected — queuing command");
-		commandQueue.enqueue("_default", ipcRequest, command.commandId);
-		return {
-			type: "COMMAND_ACK",
-			commandId: command.commandId,
-			status: "ok",
-			result: {
-				queued: true,
-				message: "Command queued — no plugins connected"
-			}
-		};
-	}
-	const [pluginId] = plugins[0];
-	if (!ipcServer) return {
-		type: "COMMAND_ACK",
-		commandId: command.commandId,
-		status: "error",
-		result: {
-			code: "NO_IPC",
-			message: "IPC server not available"
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "ok",
+				result: { integrations }
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger$1.error({ err: message }, "Integration status failed");
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "error",
+				result: {
+					code: "STATUS_FAILED",
+					message
+				}
+			};
 		}
-	};
-	try {
-		const response = await ipcServer.sendRequest(pluginId, ipcRequest.method, ipcRequest.params, 3e4);
-		return ipcResponseToCloudAck(command.commandId, response);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		return {
+	}
+	if (command.command === "alfe.config_set") {
+		const payload = command.payload;
+		const key = payload?.key;
+		const value = payload?.value;
+		if (!key || value === void 0) return {
 			type: "COMMAND_ACK",
 			commandId: command.commandId,
 			status: "error",
 			result: {
-				code: "PLUGIN_ERROR",
-				message
+				code: "INVALID_PAYLOAD",
+				message: "alfe.config_set requires key and value"
 			}
 		};
-	}
-}
-function buildCommandContext() {
-	const workspacePath = Object.values(config.runtimes)[0]?.workspace ?? "~/.openclaw";
-	return {
-		workspacePath,
-		aiProxyUrl: aiProxyUrl ?? void 0,
-		aiProxyRunning,
-		apiKey: config.apiKey,
-		async exec(cmd, opts) {
-			const { exec: execCb } = await import("child_process");
-			const { promisify } = await import("util");
-			const { stdout, stderr } = await promisify(execCb)(cmd, {
-				cwd: workspacePath,
-				timeout: opts?.timeoutMs ?? 25e3,
-				maxBuffer: opts?.maxBuffer ?? 512 * 1024
-			});
+		const runtime = config.runtime;
+		const applier = runtimeAppliersRef?.get(runtime);
+		if (!applier || typeof applier.setConfigRaw !== "function") {
+			const message = `No runtime applier supports config_set for runtime "${runtime}"`;
+			logger$1.warn({
+				runtime,
+				key
+			}, message);
 			return {
-				stdout: stdout.trim(),
-				stderr: stderr.trim()
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "error",
+				result: {
+					code: "CONFIG_SET_UNSUPPORTED",
+					message
+				}
 			};
 		}
-	};
-}
-function handlePluginRequest(method, params, pluginId) {
-	switch (method) {
-		case "status": return Promise.resolve(handleStatus());
-		case "integration.list": return Promise.resolve(handleIntegrationList());
-		case "integration.report": return Promise.resolve(handleIntegrationReport(params, pluginId));
-		case "mcp.list_tools": return Promise.resolve(handleMcpListTools(mcpBundler));
-		case "mcp.call_tool": return handleMcpCallTool(mcpBundler, params);
-		case "mcp.list_servers": return Promise.resolve(handleMcpListServers());
-		case "mcp.add_server": return handleMcpAddServer(params);
-		case "mcp.remove_server": return handleMcpRemoveServer(params);
-		default: return Promise.resolve({
-			ok: false,
-			error: {
-				code: "UNKNOWN_METHOD",
-				message: `Unknown method: ${method}`
-			}
-		});
-	}
-}
-function handleStatus() {
-	return {
-		ok: true,
-		payload: {
-			daemon: {
-				status: "running",
-				pid: process.pid,
-				uptime: (Date.now() - startedAt) / 1e3,
-				version: "0.1.0",
-				runtimeVersion: resolvedRuntimeVersion
-			},
-			cloud: {
-				status: cloudConnected ? "connected" : "disconnected",
-				latencyMs: cloudClient.getLatencyMs()
-			},
-			aiProxy: { status: aiProxyRunning ? "running" : "stopped" },
-			plugins: (ipcServer?.getRegisteredPlugins() ?? []).map(([, info]) => ({
-				name: info.name,
-				version: info.version,
-				capabilities: info.capabilities,
-				connectedAt: info.connectedAt,
-				lastSeen: info.lastSeen
-			})),
-			commandQueue: { totalPending: commandQueue.totalPending() }
-		}
-	};
-}
-function handleIntegrationList() {
-	return {
-		ok: true,
-		payload: { integrations: integrationManager.list() }
-	};
-}
-/**
-* Return the daemon-hosted MCP bundler's current namespaced tool catalog.
-* Called by the openclaw-mcp-bundler plugin on every tool-factory invocation;
-* cheap (in-memory snapshot, no I/O).
-*/
-function handleMcpListTools(bundler) {
-	if (!bundler) return {
-		ok: false,
-		error: {
-			code: "MCP_BUNDLER_UNAVAILABLE",
-			message: "MCP bundler not initialized"
-		}
-	};
-	return {
-		ok: true,
-		payload: { tools: bundler.listTools() }
-	};
-}
-/**
-* Observability backstop for the INTEGRATION warm path. `applyForIntegration`
-* registers MCP servers into the store and the daemon warms them silently via
-* the store-change `onChange` hook — so a server that fails its connect (e.g.
-* an MCP server whose backing account/credential wasn't resolvable at warm
-* time, like ctrader-mcp `exit(1)`-ing on empty accounts) leaves NO trace,
-* making the black hole undiagnosable. After a warm, read `bundler.statuses()`
-* and warn once per still-failed server so the failure is visible. These
-* self-heal on the bundler's background retry sweep once the dependency
-* appears. Returns the servers it warned about (for tests / callers).
-*/
-function warnFailedMcpServers(bundler, log, reason) {
-	if (!bundler) return [];
-	const failed = bundler.statuses().filter((s) => !s.connected && s.lastError !== void 0);
-	for (const status of failed) log.warn({
-		server: status.name,
-		reason,
-		consecutiveFailures: status.consecutiveFailures,
-		lastError: status.lastError
-	}, `MCP server "${status.name}" failed to connect: ${status.lastError ?? ""}`);
-	return failed;
-}
-/**
-* Route a tool call to the appropriate MCP child via the daemon-hosted
-* bundler. `name` is the prefixed (`mcp__<server>__<tool>`) name; args is
-* the raw JSON object the LLM produced.
-*/
-/**
-* List every server entry in the alfe bundler store. Lets agents inspect
-* what they've already registered before adding a new one.
-*/
-function handleMcpListServers(manager = mcpManagerRef) {
-	if (!manager) return {
-		ok: false,
-		error: {
-			code: "MCP_MANAGER_UNAVAILABLE",
-			message: "MCP manager not initialized"
-		}
-	};
-	const statuses = manager.serverStatuses ? manager.serverStatuses() : [];
-	const byName = new Map(statuses.map((s) => [s.name, s]));
-	return {
-		ok: true,
-		payload: { servers: manager.listServers().map(({ id, entry }) => ({
-			id,
-			entry,
-			status: byName.get(id) ?? {
-				name: id,
-				connected: false,
-				toolCount: 0,
-				consecutiveFailures: 0
-			}
-		})) }
-	};
-}
-/**
-* How long the add-confirm probe waits for the freshly-added server to
-* connect before replying. This is effectively the whole budget for
-* `bundler.warmServer`: `Manager.addServer` now reconciles the bundler
-* BEFORE resolving, so the Connection object already exists and
-* `warmServer`'s pre-reconcile is a no-diff cheap pass. Kept well under the
-* plugin caller's 30s IPC timeout. A slower server still connects in the
-* background and surfaces on the next `alfe_mcp_list_tools` — the probe just
-* reports what it saw within the window; a missed connect is re-attempted by
-* the bundler's `retryNeverConnected` sweep.
-*/
-const MCP_ADD_WARM_TIMEOUT_MS = 12e3;
-/**
-* Register a new MCP server in the alfe bundler store on behalf of the agent,
-* then CONFIRM the connect before replying so the agent learns whether the
-* server actually works. Owned as `'manual'` so the agent can later remove it
-* without an expectedOwner conflict — matches what `alfe mcp add` does from the
-* CLI. Registration is durable regardless of the probe outcome: a probe
-* failure (or a runtime with no daemon bundler, e.g. hermes) still returns
-* `ok` with `connected: false`; the store watcher / runtime picks the entry up.
-*/
-async function handleMcpAddServer(params, manager = mcpManagerRef) {
-	if (!manager) return {
-		ok: false,
-		error: {
-			code: "MCP_MANAGER_UNAVAILABLE",
-			message: "MCP manager not initialized"
-		}
-	};
-	const p = params;
-	if (typeof p.id !== "string" || p.id.length === 0) return {
-		ok: false,
-		error: {
-			code: "INVALID_PARAMS",
-			message: "id is required (string)"
-		}
-	};
-	const config = buildServerConfig(p);
-	if (!config) return {
-		ok: false,
-		error: {
-			code: "INVALID_PARAMS",
-			message: "expected either { command, args?, env?, cwd? } for stdio or { url, transport, headers? } for remote"
+		try {
+			await applier.setConfigRaw(key, value);
+			logger$1.info({
+				runtime,
+				key
+			}, "Applied config via runtime applier setConfigRaw");
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "ok",
+				result: {
+					key,
+					value
+				}
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger$1.error({
+				err: message,
+				runtime,
+				key
+			}, "Failed to apply config via runtime applier");
+			return {
+				type: "COMMAND_ACK",
+				commandId: command.commandId,
+				status: "error",
+				result: {
+					code: "CONFIG_SET_FAILED",
+					message
+				}
+			};
 		}
-	};
-	try {
-		await manager.addServer(config, {
-			id: p.id,
-			owner: "manual"
-		});
+	}
+	if (commandRegistry.has(command.command)) try {
+		const ctx = buildCommandContext();
+		const result = await commandRegistry.execute(command.command, typeof command.payload === "object" && command.payload !== null ? command.payload : {}, ctx);
+		return {
+			type: "COMMAND_ACK",
+			commandId: command.commandId,
+			status: result.status,
+			result: result.result
+		};
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		logger$1.warn({
-			id: p.id,
-			err: message
-		}, "mcp.add_server failed");
+		logger$1.error({
+			err: message,
+			command: command.command
+		}, "Command registry execution failed");
 		return {
-			ok: false,
-			error: {
-				code: "MCP_ADD_FAILED",
+			type: "COMMAND_ACK",
+			commandId: command.commandId,
+			status: "error",
+			result: {
+				code: "REGISTRY_ERROR",
 				message
 			}
 		};
 	}
-	let status = null;
-	if (manager.warmServer) try {
-		status = await manager.warmServer(p.id, MCP_ADD_WARM_TIMEOUT_MS);
-	} catch (err) {
-		logger$1.warn({
-			id: p.id,
-			err: err instanceof Error ? err.message : String(err)
-		}, "mcp.add_server warm probe threw");
-	}
-	return {
-		ok: true,
-		payload: {
-			id: p.id,
-			connected: status?.connected ?? false,
-			toolCount: status?.toolCount ?? 0,
-			...status?.lastError !== void 0 ? { error: status.lastError } : {}
-		}
-	};
-}
-function buildServerConfig(p) {
-	if (typeof p.command === "string" && p.command.length > 0) {
-		const cfg = { command: p.command };
-		if (Array.isArray(p.args) && p.args.every((a) => typeof a === "string")) cfg.args = p.args;
-		if (p.env && typeof p.env === "object" && !Array.isArray(p.env)) {
-			const env = {};
-			for (const [k, v] of Object.entries(p.env)) if (typeof v === "string") env[k] = v;
-			cfg.env = env;
-		}
-		if (typeof p.cwd === "string") cfg.cwd = p.cwd;
-		return cfg;
+	const ipcRequest = cloudCommandToIPCRequest(command);
+	if (!ipcRequest) {
+		logger$1.warn({ command: command.command }, "Unrecognized cloud command");
+		return {
+			type: "COMMAND_ACK",
+			commandId: command.commandId,
+			status: "error",
+			result: {
+				code: "UNKNOWN_COMMAND",
+				message: `Unrecognized command: ${command.command}`
+			}
+		};
 	}
-	if (typeof p.url === "string" && p.url.length > 0) {
-		const transport = p.transport === "streamable-http" ? "streamable-http" : "sse";
-		const cfg = {
-			url: p.url,
-			transport
+	const plugins = ipcServer?.getRegisteredPlugins() ?? [];
+	if (plugins.length === 0) {
+		logger$1.info({
+			commandId: command.commandId,
+			command: command.command
+		}, "No plugins connected — queuing command");
+		commandQueue.enqueue("_default", ipcRequest, command.commandId);
+		return {
+			type: "COMMAND_ACK",
+			commandId: command.commandId,
+			status: "ok",
+			result: {
+				queued: true,
+				message: "Command queued — no plugins connected"
+			}
 		};
-		if (p.headers && typeof p.headers === "object" && !Array.isArray(p.headers)) {
-			const headers = {};
-			for (const [k, v] of Object.entries(p.headers)) if (typeof v === "string") headers[k] = v;
-			cfg.headers = headers;
-		}
-		return cfg;
 	}
-	return null;
-}
-/**
-* Drop a server entry the agent previously registered. Restricted to
-* `manual`-owned entries so the agent can't accidentally clobber
-* integration-installed or CLI-installed servers (the daemon owns
-* those; the agent can ask the user to uninstall an integration via
-* the dashboard).
-*/
-async function handleMcpRemoveServer(params, manager = mcpManagerRef) {
-	if (!manager) return {
-		ok: false,
-		error: {
-			code: "MCP_MANAGER_UNAVAILABLE",
-			message: "MCP manager not initialized"
-		}
-	};
-	const { id } = params;
-	if (typeof id !== "string" || id.length === 0) return {
-		ok: false,
-		error: {
-			code: "INVALID_PARAMS",
-			message: "id is required (string)"
+	const [pluginId] = plugins[0];
+	if (!ipcServer) return {
+		type: "COMMAND_ACK",
+		commandId: command.commandId,
+		status: "error",
+		result: {
+			code: "NO_IPC",
+			message: "IPC server not available"
 		}
 	};
 	try {
-		return {
-			ok: true,
-			payload: { removed: await manager.removeServer(id, { expectedOwner: "manual" }) }
-		};
+		const response = await ipcServer.sendRequest(pluginId, ipcRequest.method, ipcRequest.params, 3e4);
+		return ipcResponseToCloudAck(command.commandId, response);
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		if (message.includes("owned by")) return {
-			ok: false,
-			error: {
-				code: "MCP_OWNER_MISMATCH",
-				message
-			}
-		};
-		logger$1.warn({
-			id,
-			err: message
-		}, "mcp.remove_server failed");
 		return {
-			ok: false,
-			error: {
-				code: "MCP_REMOVE_FAILED",
+			type: "COMMAND_ACK",
+			commandId: command.commandId,
+			status: "error",
+			result: {
+				code: "PLUGIN_ERROR",
 				message
 			}
 		};
 	}
 }
-async function handleMcpCallTool(bundler, params) {
-	if (!bundler) return {
-		ok: false,
-		error: {
-			code: "MCP_BUNDLER_UNAVAILABLE",
-			message: "MCP bundler not initialized"
-		}
-	};
-	const { name, args } = params;
-	if (typeof name !== "string" || name.length === 0) return {
-		ok: false,
-		error: {
-			code: "INVALID_PARAMS",
-			message: "name is required (string)"
+function buildCommandContext() {
+	const workspacePath = Object.values(config.runtimes)[0]?.workspace ?? "~/.openclaw";
+	return {
+		workspacePath,
+		aiProxyUrl: aiProxyUrl ?? void 0,
+		aiProxyRunning,
+		apiKey: config.apiKey,
+		async exec(cmd, opts) {
+			const { exec: execCb } = await import("child_process");
+			const { promisify } = await import("util");
+			const { stdout, stderr } = await promisify(execCb)(cmd, {
+				cwd: workspacePath,
+				timeout: opts?.timeoutMs ?? 25e3,
+				maxBuffer: opts?.maxBuffer ?? 512 * 1024
+			});
+			return {
+				stdout: stdout.trim(),
+				stderr: stderr.trim()
+			};
 		}
 	};
-	try {
-		return {
-			ok: true,
-			payload: await bundler.callTool(name, args)
-		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		logger$1.warn({
-			tool: name,
-			err: message
-		}, "mcp.call_tool failed");
-		return {
+}
+function handlePluginRequest(method, params, pluginId) {
+	switch (method) {
+		case "status": return Promise.resolve(handleStatus());
+		case "integration.list": return Promise.resolve(handleIntegrationList());
+		case "integration.report": return Promise.resolve(handleIntegrationReport(params, pluginId));
+		case "mcp.list_tools": return Promise.resolve(handleMcpListTools(mcpBundler));
+		case "mcp.call_tool": return handleMcpCallTool(mcpBundler, params);
+		case "mcp.list_servers": return Promise.resolve(handleMcpListServers(mcpManagerRef));
+		case "mcp.add_server": return handleMcpAddServer(params, mcpManagerRef);
+		case "mcp.remove_server": return handleMcpRemoveServer(params, mcpManagerRef);
+		default: return Promise.resolve({
 			ok: false,
 			error: {
-				code: "MCP_CALL_FAILED",
-				message
+				code: "UNKNOWN_METHOD",
+				message: `Unknown method: ${method}`
 			}
-		};
+		});
 	}
 }
+function handleStatus() {
+	return {
+		ok: true,
+		payload: {
+			daemon: {
+				status: "running",
+				pid: process.pid,
+				uptime: (Date.now() - startedAt) / 1e3,
+				version: "0.1.0",
+				runtimeVersion: resolvedRuntimeVersion
+			},
+			cloud: {
+				status: cloudConnected ? "connected" : "disconnected",
+				latencyMs: cloudClient.getLatencyMs()
+			},
+			aiProxy: { status: aiProxyRunning ? "running" : "stopped" },
+			plugins: (ipcServer?.getRegisteredPlugins() ?? []).map(([, info]) => ({
+				name: info.name,
+				version: info.version,
+				capabilities: info.capabilities,
+				connectedAt: info.connectedAt,
+				lastSeen: info.lastSeen
+			})),
+			commandQueue: { totalPending: commandQueue.totalPending() }
+		}
+	};
+}
+function handleIntegrationList() {
+	return {
+		ok: true,
+		payload: { integrations: integrationManager.list() }
+	};
+}
 function handleIntegrationReport(params, pluginId) {
 	const { name, status, detail } = params;
 	if (!name || !status) return {