@alfe.ai/openclaw-mcp-bundler 0.0.13 → 0.0.16

package/dist/plugin.d.cts

@@ -44,11 +44,6 @@ interface ToolFactoryContext {
   runtimeConfig?: ConfigSnapshot;
   getRuntimeConfig?: () => ConfigSnapshot | undefined;
 }
-interface OpenClawPluginService {
-  id: string;
-  start: (ctx?: unknown) => void | Promise<void>;
-  stop?: (ctx?: unknown) => void | Promise<void>;
-}
 interface OpenClawPluginApi {
   logger: Logger;
   config?: ConfigSnapshot;
@@ -66,7 +61,6 @@ interface OpenClawPluginApi {
     names?: string[];
     optional?: boolean;
   }) => void;
-  registerService?: (service: OpenClawPluginService) => void;
 }
 declare const plugin: {
   id: string;

package/dist/plugin.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.cts","names":[],"sources":["../src/ipc-client.ts","../src/plugin.ts"],"mappings":";UA0BiB;EAAA,EAAA,EAAA,MAAA;;YAGL;;ICqBF,IAAA,EAAM,MAAA;IAON,OAAA,EAAA,MAAc;EAAA,CAAA;;;;;UAPd,MAAA,CA2BI;EAGJ,KAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAkB,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA,IAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;MACjB,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;OACO,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;UAzBR,cAAA,CA0B+B;EAG/B,MAAA,CAAA,EAAA;IAAqB,QAAA,CAAA,EAAA;MAEI,KAAA,CAAA,EAAA,MAAA;MACA,WAAA,CAAA,EA/BqB,MA+BrB,CAAA,MAAA,EAAA,OAAA,CAAA;IAAO,CAAA;EAGhC,CAAA;EAAiB,GAAA,CAAA,EAAA;IACjB,OAAA,CAAA,EAlCU,MAkCV,CAAA,MAAA,EAAA,OAAA,CAAA;;;UA/BA,eAAA,CAqCA;SAAmB,EApClB,MAoCkB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA;SAAuB,CAAA,EAnCxC,MAmCwC,CAAA,MAAA,EAAA,OAAA,CAAA;;UAhC1C,SAAA,CAmCoB;EAAqB,IAAA,EAAA,MAAA;EA6V7C,KAAA,CAAA,EAAA,MAsQL;EAAA,WAAA,EAAA,MAAA;YAjMe,EAjcF,MAicE,CAAA,MAAA,EAAA,OAAA,CAAA;SA6LE,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EA1nBL,WA0nBK,EAAA,QAAA,CAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,GAAA,IAAA,EAAA,GAxnBX,OAwnBW,CAxnBH,eAwnBG,CAAA;;UArnBR,kBAAA;WACC;kBACO;2BACS;;UAGjB,qBAAA;;mCAEyB;mCACA;;UAGzB,iBAAA;UACA;WACC;;;;;;;sBAG8B;;;uBAE/B,mBAAmB,uBAAuB,YAAY;;;;;8BAGlC;;cA6VxB;;;;;;;;gBAqEU;kBA6LE"}
+{"version":3,"file":"plugin.d.cts","names":[],"sources":["../src/ipc-client.ts","../src/plugin.ts"],"mappings":";UA0BiB;EAAA,EAAA,EAAA,MAAA;;YAGL;;ICiEF,IAAA,EAAM,MAAA;IAON,OAAA,EAAA,MAAc;EAAA,CAAA;;;;;UAPd,MAAA;;;;;;UAOA,cAAA;;;;oBAC8C;;;;cACpC;;;UAGV,eAAA;WACC;YACC;;UAGF,SAAA;;;;cAII;0DAID,sDAEN,QAAQ;;UAGL,kBAAA;WACC;kBACO;2BACS;;UAGjB,iBAAA;UACA;WACC;;;;;;;sBAG8B;;;uBAE/B,mBAAmB,uBAAuB,YAAY;;;;;;cA8oB1D;;;;;;;;gBAwCU;kBAgGE"}

package/dist/plugin.d.ts

@@ -44,11 +44,6 @@ interface ToolFactoryContext {
   runtimeConfig?: ConfigSnapshot;
   getRuntimeConfig?: () => ConfigSnapshot | undefined;
 }
-interface OpenClawPluginService {
-  id: string;
-  start: (ctx?: unknown) => void | Promise<void>;
-  stop?: (ctx?: unknown) => void | Promise<void>;
-}
 interface OpenClawPluginApi {
   logger: Logger;
   config?: ConfigSnapshot;
@@ -66,7 +61,6 @@ interface OpenClawPluginApi {
     names?: string[];
     optional?: boolean;
   }) => void;
-  registerService?: (service: OpenClawPluginService) => void;
 }
 declare const plugin: {
   id: string;

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","names":[],"sources":["../src/ipc-client.ts","../src/plugin.ts"],"mappings":";UA0BiB;EAAA,EAAA,EAAA,MAAA;;YAGL;;ICqBF,IAAA,EAAM,MAAA;IAON,OAAA,EAAA,MAAc;EAAA,CAAA;;;;;UAPd,MAAA,CA2BI;EAGJ,KAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAkB,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA,IAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;MACjB,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;OACO,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;UAzBR,cAAA,CA0B+B;EAG/B,MAAA,CAAA,EAAA;IAAqB,QAAA,CAAA,EAAA;MAEI,KAAA,CAAA,EAAA,MAAA;MACA,WAAA,CAAA,EA/BqB,MA+BrB,CAAA,MAAA,EAAA,OAAA,CAAA;IAAO,CAAA;EAGhC,CAAA;EAAiB,GAAA,CAAA,EAAA;IACjB,OAAA,CAAA,EAlCU,MAkCV,CAAA,MAAA,EAAA,OAAA,CAAA;;;UA/BA,eAAA,CAqCA;SAAmB,EApClB,MAoCkB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA;SAAuB,CAAA,EAnCxC,MAmCwC,CAAA,MAAA,EAAA,OAAA,CAAA;;UAhC1C,SAAA,CAmCoB;EAAqB,IAAA,EAAA,MAAA;EA6V7C,KAAA,CAAA,EAAA,MAsQL;EAAA,WAAA,EAAA,MAAA;YAjMe,EAjcF,MAicE,CAAA,MAAA,EAAA,OAAA,CAAA;SA6LE,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EA1nBL,WA0nBK,EAAA,QAAA,CAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,GAAA,IAAA,EAAA,GAxnBX,OAwnBW,CAxnBH,eAwnBG,CAAA;;UArnBR,kBAAA;WACC;kBACO;2BACS;;UAGjB,qBAAA;;mCAEyB;mCACA;;UAGzB,iBAAA;UACA;WACC;;;;;;;sBAG8B;;;uBAE/B,mBAAmB,uBAAuB,YAAY;;;;;8BAGlC;;cA6VxB;;;;;;;;gBAqEU;kBA6LE"}
+{"version":3,"file":"plugin.d.ts","names":[],"sources":["../src/ipc-client.ts","../src/plugin.ts"],"mappings":";UA0BiB;EAAA,EAAA,EAAA,MAAA;;YAGL;;ICiEF,IAAA,EAAM,MAAA;IAON,OAAA,EAAA,MAAc;EAAA,CAAA;;;;;UAPd,MAAA;;;;;;UAOA,cAAA;;;;oBAC8C;;;;cACpC;;;UAGV,eAAA;WACC;YACC;;UAGF,SAAA;;;;cAII;0DAID,sDAEN,QAAQ;;UAGL,kBAAA;WACC;kBACO;2BACS;;UAGjB,iBAAA;UACA;WACC;;;;;;;sBAG8B;;;uBAE/B,mBAAmB,uBAAuB,YAAY;;;;;;cA8oB1D;;;;;;;;gBAwCU;kBAgGE"}

package/dist/plugin2.cjs

@@ -236,44 +236,20 @@ function isIpcResponse(value) {
 //#region src/plugin.ts
 const pkg = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
 const CACHE_FILE = (0, node_path.join)((0, node_os.homedir)(), ".alfe", "mcp", "openclaw-bundler-cache.json");
+const GATEWAY_SOCKET = (0, node_path.join)((0, node_os.homedir)(), ".alfe", "gateway.sock");
 let ipcClient;
 let cachedDescriptors = [];
 let refreshInFlight = null;
 let periodicRefreshTimer = null;
+let moduleApi;
+let moduleLog;
 const ACTIVATED_KEY = "__alfeMcpBundlerPluginActivated";
 const g = globalThis;
-const PREWARM_TIMEOUT_MS = 3e3;
+const IPC_CONNECT_TIMEOUT_MS = 2500;
 const PERIODIC_REFRESH_INTERVAL_MS = 1e4;
 function resolveLiveConfig(api, ctx) {
 	return ctx?.runtimeConfig ?? ctx?.getRuntimeConfig?.() ?? api.runtime?.config?.current?.() ?? ctx?.config ?? api.config;
 }
-function buildAgentTool(api, tool) {
-	return {
-		name: tool.prefixed,
-		label: tool.label,
-		description: tool.description || `MCP tool ${tool.original} from server ${tool.server}`,
-		parameters: tool.parameters,
-		async execute(_toolCallId, params) {
-			if (!ipcClient?.isConnected()) return errorResult(`mcp ${tool.prefixed}: bundler IPC not connected yet. Try again in a moment.`);
-			const response = await ipcClient.call("mcp.call_tool", {
-				name: tool.prefixed,
-				args: params
-			});
-			if (!response.ok || !response.payload) {
-				api.logger.warn("[mcp-bundler] tool call failed", {
-					tool: tool.prefixed,
-					err: response.error?.message ?? "unknown error"
-				});
-				return errorResult(response.error?.message ? `mcp ${tool.prefixed}: ${response.error.message}` : `mcp ${tool.prefixed}: call failed`);
-			}
-			const result = response.payload;
-			return {
-				content: result.content,
-				details: { isError: result.isError ?? false }
-			};
-		}
-	};
-}
 function errorResult(message) {
 	return {
 		content: [{
@@ -284,36 +260,93 @@ function errorResult(message) {
 	};
 }
 /**
+* Lazily construct + connect the IPC client on first use.
+*
+* THE LOAD-BEARING FIX (v0.0.16, 2026-06-14). The gateway daemon runs
+* the long-lived openclaw runtime in `registrationMode=tool-discovery`,
+* NOT `full`. Pre-v0.0.16 the client was only constructed in `activate()`
+* when `shouldStartIpcClient` returned true (full mode only) — so in the
+* runtime that actually serves the agent's turns, the client was NEVER
+* constructed. Verified on QA Tester: the 2.6-day-uptime runtime held
+* zero connections to `~/.alfe/gateway.sock`. Listing worked (disk cache)
+* but every tool EXECUTION returned NOT_CONNECTED → "bundler store isn't
+* initialized."
+*
+* The correct trigger for opening the socket is "a tool is actually being
+* invoked", not "we activated in full mode". Tool execution only ever
+* happens in a live runtime process, and the plugin module is process-
+* cached, so constructing here populates the module-scoped `ipcClient`
+* for every later call in the same process. Pure tool-discovery loads
+* that enumerate but never execute still never reach this path → no
+* socket opened, the discovery invariant is preserved.
+*
+* Returns `undefined` only when there's genuinely no daemon to talk to
+* (no socket file, or `activate()` never captured the module refs).
+*/
+function ensureIpcClient() {
+	if (ipcClient) return ipcClient;
+	if (!moduleLog) return void 0;
+	if (!(0, node_fs.existsSync)(GATEWAY_SOCKET)) {
+		moduleLog.debug(`[mcp-bundler] ${GATEWAY_SOCKET} not present — cannot open IPC for this call`);
+		return;
+	}
+	startIpcClient(moduleLog);
+	moduleLog.info("[mcp-bundler] IPC client constructed lazily on first tool call");
+	return ipcClient;
+}
+/**
+* Poll `isConnected()` until the socket is up or the budget expires.
+* `McpIpcClient.start()` connects asynchronously, so a freshly-
+* constructed client (or one mid-reconnect after a daemon bounce) needs
+* a moment before `.call()` will reach the wire.
+*/
+async function waitForIpcConnect(client, timeoutMs) {
+	if (client.isConnected()) return;
+	const deadline = Date.now() + timeoutMs;
+	while (!client.isConnected() && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 50));
+}
+/**
 * Async-aware shim around the module-scoped `ipcClient`. The management
 * tools and dynamic MCP tools registered in `activate()` execute LATER
-* (when the agent invokes them), but `ipcClient` is only set inside
-* `startService`. The `?.` chains return useful errors when the agent
-* tries to call a tool before the IPC is ready, instead of throwing.
+* (when the agent invokes them). `callIpc` constructs the client on
+* demand (`ensureIpcClient`) and waits for the socket to connect before
+* forwarding, so the very first tool call works even in the tool-
+* discovery runtime where the client was never eagerly started. Returns
+* a typed `NOT_CONNECTED` response — never throws — when there's no
+* daemon socket to reach.
 */
 async function callIpc(method, params = {}) {
-	if (!ipcClient) return {
+	const client = ensureIpcClient();
+	if (!client) return {
 		id: "",
 		ok: false,
 		error: {
 			code: "NOT_CONNECTED",
-			message: "Bundler IPC client not initialized yet"
+			message: "Bundler IPC unavailable — no alfe-gateway daemon socket"
 		}
 	};
-	return ipcClient.call(method, params);
+	if (!client.isConnected()) await waitForIpcConnect(client, IPC_CONNECT_TIMEOUT_MS);
+	return client.call(method, params);
 }
 /**
-* Load the last-known tool catalogue from disk. Used at `activate()`
-* time so the agent's tool list contains real tools even in tool-
-* discovery mode (where `service.start` — and therefore the IPC
-* connection — never runs). Silently falls back to an empty list on
-* any read/parse failure so a first-run agent (no cache file yet)
-* still loads cleanly.
+* Cheap shape check guarding against a corrupt or torn-write cache —
+* a half-written JSON array that parses but holds garbage entries
+* would otherwise surface through `alfe_mcp_list_tools` with undefined
+* names/schemas and mislead the agent. Catching the shape here keeps
+* the listed catalogue clean even after disk-level corruption.
 */
 function isValidDescriptor(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const v = value;
 	return typeof v.prefixed === "string" && typeof v.original === "string" && typeof v.server === "string" && typeof v.parameters === "object" && v.parameters !== null;
 }
+/**
+* Load the last-known tool catalogue from disk. Used at `activate()`
+* time so the agent's tool list contains real tools even in tool-
+* discovery mode (where the IPC client never opens). Silently falls
+* back to an empty list on any read/parse failure so a first-run agent
+* (no cache file yet) still loads cleanly.
+*/
 function loadCachedDescriptorsFromDisk(logger) {
 	try {
 		const raw = (0, node_fs.readFileSync)(CACHE_FILE, "utf-8");
@@ -453,11 +486,99 @@ function registerAgentMcpManagementTools(api) {
 			};
 		}
 	});
+	api.registerTool({
+		name: "alfe_mcp_list_tools",
+		label: "List available MCP tools",
+		description: "List every MCP tool currently available across all of this agent's connected integrations (Atlassian/Jira, Confluence, Notion, GitHub, etc.), with each tool's exact name, description, and input schema. ALWAYS call this first to discover what tools exist and how to call them, then invoke one with `alfe_mcp_call`. Optionally pass `server` to restrict the listing to a single MCP server (e.g. \"atlassian-atlassian\") when you already know which integration you need.",
+		parameters: {
+			type: "object",
+			properties: { server: {
+				type: "string",
+				description: "Optional. Restrict the listing to one MCP server id (e.g. \"atlassian-atlassian\", \"github-github\"). Omit to list every available tool."
+			} },
+			additionalProperties: false
+		},
+		async execute(_toolCallId, params) {
+			const response = await callIpc("mcp.list_tools", {});
+			let descriptors;
+			if (response.ok && response.payload?.tools && response.payload.tools.length > 0) {
+				descriptors = response.payload.tools;
+				cachedDescriptors = descriptors;
+				if (moduleLog) persistCachedDescriptorsToDisk(descriptors, moduleLog);
+			} else descriptors = cachedDescriptors;
+			const p = params ?? {};
+			const serverFilter = typeof p.server === "string" ? p.server : void 0;
+			const out = (serverFilter ? descriptors.filter((d) => d.server === serverFilter) : descriptors).map((d) => ({
+				tool: d.prefixed,
+				description: d.description || `MCP tool ${d.original} from server ${d.server}`,
+				inputSchema: d.parameters
+			}));
+			if (out.length === 0) return {
+				content: [{
+					type: "text",
+					text: serverFilter ? `No MCP tools available for server "${serverFilter}". Call alfe_mcp_list to see registered servers.` : "No MCP tools available yet. Connected integrations may still be initialising — try again in a moment, or call alfe_mcp_list to see registered servers."
+				}],
+				details: { isError: false }
+			};
+			return {
+				content: [{
+					type: "text",
+					text: `${String(out.length)} MCP tool(s) available. Call any of them with alfe_mcp_call({ tool, args }):\n\n${JSON.stringify(out, null, 2)}`
+				}],
+				details: { isError: false }
+			};
+		}
+	});
+	api.registerTool({
+		name: "alfe_mcp_call",
+		label: "Call an MCP tool",
+		description: "Execute one of the MCP tools returned by `alfe_mcp_list_tools`. Pass the exact `tool` name (e.g. \"atlassian-atlassian__jira_search\") and an `args` object matching that tool's input schema from the listing. This is how you actually use Jira, Confluence, Notion, GitHub, etc. — list the tools first, then call them here.",
+		parameters: {
+			type: "object",
+			properties: {
+				tool: {
+					type: "string",
+					description: "The exact prefixed tool name from alfe_mcp_list_tools (e.g. \"atlassian-atlassian__jira_get_issue\")."
+				},
+				args: {
+					type: "object",
+					description: "Arguments object matching the chosen tool's input schema (as shown by alfe_mcp_list_tools). Pass {} for tools that take no arguments.",
+					additionalProperties: true
+				}
+			},
+			required: ["tool"],
+			additionalProperties: false
+		},
+		async execute(_toolCallId, params) {
+			const p = params ?? {};
+			const tool = p.tool;
+			if (typeof tool !== "string" || !tool) return errorResult("alfe_mcp_call requires a `tool` name — call alfe_mcp_list_tools first to see the available tool names.");
+			const response = await callIpc("mcp.call_tool", {
+				name: tool,
+				args: p.args ?? {}
+			});
+			if (!response.ok || !response.payload) {
+				(moduleLog ?? api.logger).warn("[mcp-bundler] alfe_mcp_call failed", {
+					tool,
+					err: response.error?.message ?? "unknown error"
+				});
+				return errorResult(response.error?.message ? `mcp ${tool}: ${response.error.message}` : `mcp ${tool}: call failed (is the tool name exact? call alfe_mcp_list_tools to confirm)`);
+			}
+			const result = response.payload;
+			return {
+				content: result.content,
+				details: { isError: result.isError ?? false }
+			};
+		}
+	});
 }
 /**
-* Pull the latest tool catalog from the daemon-hosted bundler. Coalesces
-* concurrent calls so the LLM hitting the factory many times in a tight
-* loop only triggers one in-flight IPC request.
+* Pull the latest tool catalog from the daemon-hosted bundler into
+* `cachedDescriptors` + the disk cache. Driven by the periodic timer
+* and the `onConnect` hook so the disk-cache fallback that
+* `alfe_mcp_list_tools` reads stays warm even for tool-discovery loads
+* that never execute a tool. Coalesces concurrent calls so a burst only
+* triggers one in-flight IPC request.
 */
 function refreshCachedTools(api) {
 	if (!ipcClient) return Promise.resolve();
@@ -469,7 +590,12 @@ function refreshCachedTools(api) {
 				api.logger.debug("[mcp-bundler] list_tools failed", { err: response.error?.message ?? "unknown" });
 				return;
 			}
-			cachedDescriptors = response.payload.tools;
+			const fresh = Array.isArray(response.payload.tools) ? response.payload.tools : [];
+			if (fresh.length === 0 && cachedDescriptors.length > 0) {
+				api.logger.debug(`[mcp-bundler] list_tools returned 0 tools — keeping prior cache of ${String(cachedDescriptors.length)}`);
+				return;
+			}
+			cachedDescriptors = fresh;
 			persistCachedDescriptorsToDisk(cachedDescriptors, api.logger);
 		} finally {
 			refreshInFlight = null;
@@ -477,6 +603,88 @@ function refreshCachedTools(api) {
 	})();
 	return refreshInFlight;
 }
+/**
+* Should this `activate()` invocation also start the live IPC client?
+*
+* Decision rule: only in full agent-runtime mode. CLI invocations
+* (`openclaw config set`, `openclaw plugins inspect`, `openclaw upgrade`,
+* etc.) and tool-discovery loads (where OpenClaw builds the agent's
+* tool list without running plugin services) should NOT open the
+* gateway socket — they only need the disk cache and the static tool
+* registrations.
+*
+* `api.registrationMode` is the canonical signal. OpenClaw 2026.5
+* sets it to one of: `'full'`, `'discovery'`, `'tool-discovery'`,
+* `'setup-only'`, `'setup-runtime'`, `'cli-metadata'`. Only `'full'`
+* means "real agent runtime; everything is allowed to run".
+*
+* Defensive default: if `registrationMode` is unset (older OpenClaw,
+* non-bundled host, test harness), assume full mode so we don't
+* silently degrade. The IPC client itself handles a missing socket
+* gracefully via reconnect, so an over-eager start is cheap.
+*/
+function shouldStartIpcClient(api) {
+	const mode = api.registrationMode;
+	if (mode === void 0) return true;
+	return mode === "full";
+}
+/**
+* Construct the live IPC client and wire its `onConnect` to a cache
+* refresh. Module-scoped — the same client lifecycle outlasts a single
+* `activate()` call so reconnects from daemon restarts continue
+* automatically. Called from `activate()` ONLY in full agent-runtime
+* mode (see `shouldStartIpcClient`).
+*
+* IMPORTANT: this function is NOT awaited. The `onConnect` callback
+* fires asynchronously; `alfe_mcp_list_tools` returns whatever is in
+* `cachedDescriptors` when it's called with a closed socket (loaded
+* from disk in `activate()`, then refreshed on connect, then
+* periodically). A first-turn pre-warm is no longer needed — the disk
+* cache covers the cold window, and any new tools discovered during the
+* in-flight `onConnect` refresh land in `cachedDescriptors` shortly
+* after.
+*
+* Removed the v0.0.13 PREWARM_TIMEOUT_MS / blocking pre-warm because
+* v0.0.14 has no `service.start` await point to attach it to —
+* removing `api.registerService` was the whole point of the fix. Disk
+* cache + periodic refresh now carry the freshness contract.
+*/
+function startIpcClient(log) {
+	if (ipcClient) return;
+	if (!(0, node_fs.existsSync)(GATEWAY_SOCKET)) log.debug(`[mcp-bundler] ${GATEWAY_SOCKET} not present at activate — IPC client will refresh when the daemon comes online`);
+	ipcClient = new McpIpcClient({
+		logger: log,
+		plugin: {
+			name: "@alfe.ai/openclaw-mcp-bundler",
+			version: pkg.version
+		},
+		onConnect: () => {
+			if (moduleApi) refreshCachedTools(moduleApi);
+		}
+	});
+	ipcClient.start();
+	periodicRefreshTimer = setInterval(() => {
+		if (ipcClient?.isConnected() && moduleApi) refreshCachedTools(moduleApi);
+	}, PERIODIC_REFRESH_INTERVAL_MS);
+	periodicRefreshTimer.unref?.();
+}
+/**
+* Tear down the IPC client and periodic refresh timer. Called from
+* `deactivate()` (the only lifecycle exit point now that v0.0.14
+* dropped `api.registerService`). Safe to call multiple times — each
+* tear-down is idempotent.
+*/
+function stopIpcClient() {
+	if (periodicRefreshTimer !== null) {
+		clearInterval(periodicRefreshTimer);
+		periodicRefreshTimer = null;
+	}
+	if (ipcClient) {
+		ipcClient.stop();
+		ipcClient = void 0;
+	}
+	refreshInFlight = null;
+}
 const plugin = {
 	id: "@alfe.ai/openclaw-mcp-bundler",
 	name: "Alfe MCP Bundler",
@@ -486,38 +694,8 @@ const plugin = {
 		"alfe_mcp_list",
 		"alfe_mcp_add",
 		"alfe_mcp_remove",
-		"atlassian-atlassian__atlassian_list_accounts",
-		"atlassian-atlassian__atlassian_check_connection",
-		"atlassian-atlassian__atlassian_refresh_token",
-		"notion-notion__notion_list_accounts",
-		"notion-notion__notion_check_connection",
-		"notion-notion__notion_refresh_token",
-		"github-github__github_list_accounts",
-		"github-github__github_check_connection",
-		"github-github__github_refresh_token",
-		"microsoft-microsoft__microsoft_list_accounts",
-		"microsoft-microsoft__microsoft_check_connection",
-		"microsoft-microsoft__microsoft_refresh_token",
-		"google-google__google_list_accounts",
-		"google-google__google_check_connection",
-		"google-google__google_refresh_token",
-		"slack-slack__slack_list_accounts",
-		"slack-slack__slack_check_connection",
-		"slack-slack__slack_refresh_token",
-		"discord-discord__discord_list_accounts",
-		"discord-discord__discord_check_connection",
-		"discord-discord__discord_refresh_token",
-		"mobile-mobile__mobile_list_accounts",
-		"mobile-mobile__mobile_check_connection",
-		"mobile-mobile__mobile_refresh_token",
-		"myob-myob__myob_list_accounts",
-		"myob-myob__myob_check_connection",
-		"myob-myob__myob_refresh_token",
-		"xero-xero__xero_list_accounts",
-		"xero-xero__xero_check_connection",
-		"xero-xero__xero_refresh_token",
-		"alfe-platform__session_status",
-		"alfe-platform__gateway_status"
+		"alfe_mcp_list_tools",
+		"alfe_mcp_call"
 	] },
 	activate(api) {
 		const log = api.logger;
@@ -531,82 +709,19 @@ const plugin = {
 			log.info("[mcp-bundler] disabled via plugin config — no-op");
 			return;
 		}
-		if (!api.registerService) {
-			g[ACTIVATED_KEY] = false;
-			log.warn("[mcp-bundler] api.registerService unavailable — plugin is a no-op on this runtime");
-			return;
-		}
-		const deferToNative = hasNativeOpenclawMcpServers(resolveLiveConfig(api));
-		if (deferToNative) log.info("[mcp-bundler] openclaw.json#mcp.servers has entries — MCP-proxy factory will defer to native bundleMcp, but agent self-service tools (alfe_mcp_*) stay available");
+		const hasNativeServers = hasNativeOpenclawMcpServers(resolveLiveConfig(api));
+		if (hasNativeServers) log.info("[mcp-bundler] openclaw.json#mcp.servers has entries — those surface natively on claude-cli/codex; the alfe_mcp_* router tools remain available on every backend");
 		cachedDescriptors = loadCachedDescriptorsFromDisk(log);
 		registerAgentMcpManagementTools(api);
-		if (!deferToNative) api.registerTool((ctx) => {
-			if (hasNativeOpenclawMcpServers(resolveLiveConfig(api, ctx))) return null;
-			refreshCachedTools(api);
-			return cachedDescriptors.map((d) => buildAgentTool(api, d));
-		}, { optional: true });
-		const startService = async () => {
-			const prewarmTimer = { handle: null };
-			if (await new Promise((resolve) => {
-				prewarmTimer.handle = setTimeout(() => {
-					prewarmTimer.handle = null;
-					resolve("timeout");
-				}, PREWARM_TIMEOUT_MS);
-				ipcClient = new McpIpcClient({
-					logger: log,
-					plugin: {
-						name: plugin.id,
-						version: plugin.version
-					},
-					onConnect: () => {
-						refreshCachedTools(api).finally(() => {
-							if (prewarmTimer.handle !== null) {
-								clearTimeout(prewarmTimer.handle);
-								prewarmTimer.handle = null;
-							}
-							resolve("completed");
-						});
-					}
-				});
-				ipcClient.start();
-			}) === "timeout") log.warn(`[mcp-bundler] pre-warm timed out after ${String(PREWARM_TIMEOUT_MS)}ms — first chat turn may see a stale tool list (likely a slow or unreachable daemon at ~/.alfe/gateway.sock)`);
-			periodicRefreshTimer = setInterval(() => {
-				if (ipcClient?.isConnected()) refreshCachedTools(api);
-			}, PERIODIC_REFRESH_INTERVAL_MS);
-			periodicRefreshTimer.unref?.();
-			if (deferToNative) {
-				log.info(`[mcp-bundler] activated v${plugin.version} (management tools only — native bundleMcp owns runtime)`);
-				return;
-			}
-			log.info(`[mcp-bundler] activated v${plugin.version} (thin IPC client, tools registered in activate)`);
-		};
-		const stopService = () => {
-			log.info("[mcp-bundler] stopping");
-			if (periodicRefreshTimer !== null) {
-				clearInterval(periodicRefreshTimer);
-				periodicRefreshTimer = null;
-			}
-			if (ipcClient) {
-				ipcClient.stop();
-				ipcClient = void 0;
-			}
-			refreshInFlight = null;
-			g[ACTIVATED_KEY] = false;
-			return Promise.resolve();
-		};
-		api.registerService({
-			id: "alfe-mcp-bundler",
-			start: async () => {
-				await startService();
-			},
-			stop: async () => {
-				await stopService();
-			}
-		});
+		moduleApi = api;
+		moduleLog = log;
+		log.info(`[mcp-bundler] activated v${plugin.version} (registrationMode=${api.registrationMode ?? "unknown"}, nativeMcpServers=${String(hasNativeServers)}, cachedDescriptors=${String(cachedDescriptors.length)})`);
+		if (shouldStartIpcClient(api)) startIpcClient(log);
 	},
 	deactivate(api) {
 		g[ACTIVATED_KEY] = false;
 		api.logger.debug("[mcp-bundler] deactivating");
+		stopIpcClient();
 	}
 };
 //#endregion