@alfe.ai/gateway 0.10.6 → 0.10.8

package/dist/runtime-upgrade.js

@@ -1,4 +1,4 @@
-import { f as parseOpenClawVersion, n as OPENCLAW_EXTERNAL_SUPERVISOR_ENV, p as supportsOpenClawNode, u as OPENCLAW_NODE_REQUIREMENT } from "./runtime-process.js";
+import { S as parseOpenClawVersion, a as recoverInterruptedRuntimeUpgrade, c as wrapInUpgradeScope, d as OPENCLAW_EXTERNAL_SUPERVISOR_ENV, l as writeRuntimeUpgradeMarker, n as clearRuntimeUpgradeMarker, s as upgradeScopeUnitName, t as OPENCLAW_DOCTOR_FIX_ARGS, w as supportsOpenClawNode, x as openClawRequiresRegisterExport, y as OPENCLAW_NODE_REQUIREMENT } from "./runtime-upgrade-recovery.js";
 import { c as captureNodeRemediation, h as logger, i as captureCliFailure } from "./sentry.js";
 import { n as remediateManagedNode, t as NodeRemediationError } from "./node-remediation.js";
 import { mkdir } from "node:fs/promises";
@@ -6,6 +6,236 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+//#region src/openclaw-plugin-compat.ts
+/**
+* Pre-upgrade plugin-export compatibility check for OpenClaw ≥ 2026.8.
+*
+* OpenClaw 2026.8.1 dropped the 2026.6.x `register ?? activate` export alias.
+* An `@alfe.ai/*` plugin installed from an alfe manifest ≤ 1.1.49 only exports
+* `activate`, so after a runtime upgrade it fails to load and `doctor --fix`
+* exits non-zero AFTER migrating state — past the point where `upgradeRuntime`
+* can roll the package back (Sentry AGENT-DAEMON-P/Q/R; Designer Tester went
+* dark with its core plugins unloaded). This check runs BEFORE the gate
+* suspends and before the install, while refusing costs nothing.
+*
+* Mechanism:
+*   1. `openclaw plugins inspect --all --json` (the same structured read the
+*      applier batches; 2026.6.11/8.1/9.5 all print `plugin.{id, packageName,
+*      enabled, origin, source}`), filtered to enabled, non-bundled
+*      `@alfe.ai/*` plugins;
+*   2. ONE child `node` process imports each plugin's entry (`plugin.source`)
+*      and resolves its export the way OpenClaw 2026.8+'s
+*      `resolvePluginModuleExport` does (unwrap `default`, accept a function or
+*      an object with a `register` function, follow `default`/`module`).
+*
+* The child process isolates the daemon from whatever a plugin does at import
+* time (a throw, an open handle); it prints one sentinel-prefixed JSON line and
+* exits. The check never throws: an unreadable inventory or a failed probe is
+* `unknown` and the caller proceeds exactly as before (fail open — the guard
+* targets one proven failure mode and must not become a new way to wedge
+* upgrades). Only a DEFINITE "imported fine, no register" verdict blocks.
+*/
+const INSPECT_TIMEOUT_MS = 12e4;
+const INSPECT_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+const PROBE_TIMEOUT_MS = 6e4;
+const PROBE_MAX_BUFFER_BYTES = 4 * 1024 * 1024;
+const PLUGIN_EXPORT_PROBE_SENTINEL = "__ALFE_PLUGIN_EXPORT_PROBE__";
+/**
+* Runs as `node --input-type=module -e <script> <json-array-of-paths>`.
+* Mirrors OpenClaw 2026.8.1/9.5 `unwrapDefaultModuleExport` +
+* `resolvePluginModuleExport` (dist `loader-*.mjs`). Verdicts: `register`,
+* `missing`, or `error:<message>`.
+*/
+const PLUGIN_EXPORT_PROBE_SCRIPT = `
+import { pathToFileURL } from 'node:url';
+const unwrap = (value) => {
+  const seen = new Set();
+  while (value && typeof value === 'object' && 'default' in value && !seen.has(value)) {
+    seen.add(value);
+    value = value.default;
+  }
+  return value;
+};
+const hasRegister = (moduleExport) => {
+  const seen = new Set();
+  const candidates = [unwrap(moduleExport), moduleExport];
+  for (let i = 0; i < candidates.length && i < 12; i += 1) {
+    const resolved = candidates[i];
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    if (typeof resolved === 'function') return true;
+    if (resolved && typeof resolved === 'object') {
+      if (typeof resolved.register === 'function') return true;
+      for (const key of ['default', 'module']) if (key in resolved) candidates.push(resolved[key]);
+    }
+  }
+  return false;
+};
+const verdicts = {};
+for (const entry of JSON.parse(process.argv[1] ?? '[]')) {
+  try {
+    const mod = await import(pathToFileURL(entry).href);
+    verdicts[entry] = hasRegister(mod) ? 'register' : 'missing';
+  } catch (err) {
+    verdicts[entry] = 'error:' + String((err && err.message) || err).slice(0, 200);
+  }
+}
+process.stdout.write('\\n${PLUGIN_EXPORT_PROBE_SENTINEL}' + JSON.stringify(verdicts) + '\\n');
+process.exit(0);
+`;
+/** Enabled, non-bundled `@alfe.ai/*` plugins with a loadable entry path, or `undefined` for an unexpected payload. */
+function selectAlfePluginRecords(stdout) {
+	let parsed;
+	try {
+		parsed = JSON.parse(stdout.trim());
+	} catch {
+		return;
+	}
+	if (!Array.isArray(parsed)) return void 0;
+	const records = [];
+	for (const entry of parsed) {
+		const plugin = entry?.plugin;
+		if (!plugin || typeof plugin !== "object") return void 0;
+		const id = typeof plugin.id === "string" ? plugin.id : void 0;
+		const name = [typeof plugin.packageName === "string" ? plugin.packageName : void 0, id].find((value) => value?.startsWith("@alfe.ai/"));
+		if (!id || !name) continue;
+		if (plugin.enabled === false || plugin.origin === "bundled") continue;
+		if (typeof plugin.source !== "string" || !plugin.source.startsWith("/")) continue;
+		const install = entry.install;
+		const version = [
+			install?.resolvedVersion,
+			install?.version,
+			plugin.packageVersion,
+			plugin.version
+		].find((value) => typeof value === "string");
+		records.push({
+			id: name,
+			source: plugin.source,
+			...version ? { version } : {}
+		});
+	}
+	return records;
+}
+function parseProbeOutput(stdout) {
+	const line = stdout.split("\n").reverse().find((candidate) => candidate.startsWith(PLUGIN_EXPORT_PROBE_SENTINEL));
+	if (!line) return void 0;
+	try {
+		const parsed = JSON.parse(line.slice(28));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+		return parsed;
+	} catch {
+		return;
+	}
+}
+/**
+* Find enabled `@alfe.ai/*` plugins that OpenClaw ≥ 2026.8 cannot load because
+* they export `activate` without `register`. Never throws.
+*/
+async function findActivateOnlyAlfePlugins(runCommand, openclawEnv) {
+	let records;
+	try {
+		const { stdout } = await runCommand("openclaw", [
+			"plugins",
+			"inspect",
+			"--all",
+			"--json"
+		], {
+			timeout: INSPECT_TIMEOUT_MS,
+			env: openclawEnv,
+			maxBuffer: INSPECT_MAX_BUFFER_BYTES
+		});
+		records = selectAlfePluginRecords(stdout);
+	} catch (err) {
+		return {
+			status: "unknown",
+			reason: `plugin inventory unavailable: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	if (!records) return {
+		status: "unknown",
+		reason: "plugin inventory had an unexpected shape"
+	};
+	if (records.length === 0) return {
+		status: "checked",
+		activateOnly: []
+	};
+	let verdicts;
+	try {
+		const { stdout } = await runCommand("node", [
+			"--input-type=module",
+			"-e",
+			PLUGIN_EXPORT_PROBE_SCRIPT,
+			JSON.stringify(records.map((r) => r.source))
+		], {
+			timeout: PROBE_TIMEOUT_MS,
+			maxBuffer: PROBE_MAX_BUFFER_BYTES
+		});
+		verdicts = parseProbeOutput(stdout);
+	} catch (err) {
+		return {
+			status: "unknown",
+			reason: `plugin export probe failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	if (!verdicts) return {
+		status: "unknown",
+		reason: "plugin export probe printed no verdicts"
+	};
+	const activateOnly = [];
+	for (const record of records) {
+		const verdict = verdicts[record.source];
+		if (verdict === "missing") activateOnly.push({
+			id: record.id,
+			...record.version ? { version: record.version } : {}
+		});
+		else if (verdict !== "register") logger.warn({
+			plugin: record.id,
+			verdict
+		}, "Plugin export probe could not classify plugin — not blocking the upgrade");
+	}
+	return {
+		status: "checked",
+		activateOnly
+	};
+}
+function classifyActivateOnlyPlugins(activateOnly, ownership) {
+	if (activateOnly.length === 0) return {
+		blocked: [],
+		orphans: []
+	};
+	if (!ownership) return {
+		blocked: activateOnly,
+		orphans: []
+	};
+	let owned;
+	try {
+		owned = ownership.ownedPlugins();
+	} catch (err) {
+		return {
+			blocked: activateOnly,
+			orphans: [],
+			ownershipError: err instanceof Error ? err.message : String(err)
+		};
+	}
+	const blocked = [];
+	const orphans = [];
+	for (const plugin of activateOnly) {
+		const owner = owned.get(plugin.id);
+		if (owner) blocked.push({
+			...plugin,
+			owner
+		});
+		else orphans.push(plugin);
+	}
+	return {
+		blocked,
+		orphans
+	};
+}
+function activateOnlyPluginsMessage(targetVersion, decision) {
+	return `Refusing to upgrade OpenClaw to ${targetVersion}: OpenClaw 2026.8+ only loads plugins that export register(), and these enabled Alfe plugins are activate-only builds: ${decision.blocked.map((plugin) => `${plugin.id}${plugin.version ? `@${plugin.version}` : ""}${plugin.owner ? ` (integration "${plugin.owner}")` : ""}`).join(", ")}. Upgrade or reinstall the integration(s) that own them (usually "alfe") so they install current plugin builds, then retry the runtime upgrade. The runtime was not changed.` + (decision.ownershipError ? ` (Plugin ownership could not be read: ${decision.ownershipError}.)` : "");
+}
+//#endregion
 //#region src/runtime-upgrade.ts
 /**
 * Runtime upgrade — safely replace a runtime binary and cycle its child.
@@ -42,19 +272,6 @@ const OPENCLAW_DOCTOR_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 * runtime regardless of config contents.
 */
 const OPENCLAW_ADMISSION_PROBE_ARGS = ["config", "file"];
-/**
-* `doctor --fix` runs the state/config migration. On 2026.9.x `--json` puts
-* doctor into READ-ONLY lint mode and it refuses the combination outright
-* (exit 2: "doctor --json runs read-only lint checks and cannot be combined
-* with --repair, --fix, or --force"), so the migration must run without it.
-* The post-upgrade audit is read-only and keeps `--json`.
-*/
-const OPENCLAW_DOCTOR_FIX_ARGS = [
-	"doctor",
-	"--fix",
-	"--non-interactive",
-	"--yes"
-];
 const OPENCLAW_DOCTOR_AUDIT_ARGS = [
 	"doctor",
 	"--post-upgrade",
@@ -126,6 +343,36 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 			error: message
 		};
 	}
+	let orphanPlugins = [];
+	if (runtime === "openclaw" && version && openClawRequiresRegisterExport(version)) {
+		const found = await findActivateOnlyAlfePlugins(runCommand, openclawEnv);
+		if (found.status === "unknown") logger.warn({
+			runtime,
+			version,
+			reason: found.reason
+		}, "Plugin export preflight inconclusive — proceeding with the upgrade");
+		else if (found.activateOnly.length > 0) {
+			const decision = classifyActivateOnlyPlugins(found.activateOnly, options.pluginOwnership);
+			if (decision.blocked.length > 0) {
+				const message = activateOnlyPluginsMessage(version, decision);
+				logger.error({
+					runtime,
+					version,
+					blocked: decision.blocked,
+					orphans: decision.orphans
+				}, message);
+				captureCliFailure("openclaw-upgrade-preflight", new Error(message));
+				return {
+					success: false,
+					runtime,
+					version,
+					nodeUpgraded: false,
+					error: message
+				};
+			}
+			orphanPlugins = decision.orphans.map((plugin) => plugin.id);
+		}
+	}
 	let previousOpenClawVersion;
 	let nodeUpgraded = false;
 	if (runtime === "openclaw") try {
@@ -195,6 +442,32 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 			error: message
 		};
 	}
+	const markerPath = options.markerPath;
+	const scopeUnits = [];
+	/** Wrap a long, state-mutating command in its own scope (records the unit for boot recovery). */
+	const isolated = (command, args) => {
+		if (!options.isolation) return {
+			command,
+			args
+		};
+		const unit = upgradeScopeUnitName(Date.now() + scopeUnits.length);
+		scopeUnits.push(unit);
+		return wrapInUpgradeScope(options.isolation, unit, command, args);
+	};
+	const markerState = { keep: false };
+	const writeMarker = async (phase) => {
+		if (!markerPath || runtime !== "openclaw" || !version) return;
+		const marker = {
+			runtime: "openclaw",
+			phase,
+			targetVersion: version,
+			...previousOpenClawVersion ? { previousVersion: previousOpenClawVersion } : {},
+			startedAt: markerState.current?.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+			scopeUnits: [...scopeUnits]
+		};
+		await writeRuntimeUpgradeMarker(markerPath, marker);
+		markerState.current = marker;
+	};
 	logger.info({
 		runtime,
 		version
@@ -222,8 +495,10 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 				], commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
 				if (backup.stdout) logger.info({ backup: backup.stdout.trim() }, "Verified pre-upgrade OpenClaw backup created");
 			}
+			const install = runtime === "openclaw" ? isolated(cmd.command, cmd.args) : cmd;
+			await writeMarker("installing");
 			packageInstallAttempted = true;
-			const { stdout, stderr } = await runCommand(cmd.command, cmd.args, commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
+			const { stdout, stderr } = await runCommand(install.command, install.args, commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
 			if (stdout) logger.debug({ stdout: stdout.trim() }, "runtime upgrade stdout");
 			if (stderr) logger.debug({ stderr: stderr.trim() }, "runtime upgrade stderr");
 			if (runtime === "openclaw" && version) {
@@ -231,9 +506,11 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 				if (installedVersion !== version) throw new Error(`OpenClaw package verification failed: requested ${version}, resolved ${installedVersion ?? "unknown"}`);
 				runtimeChanged = installedVersion !== previousOpenClawVersion;
 				await runCommand("openclaw", [...OPENCLAW_ADMISSION_PROBE_ARGS], commandOptions(6e4));
+				const doctorCommand = isolated("openclaw", [...OPENCLAW_DOCTOR_FIX_ARGS]);
+				await writeMarker("migrating");
 				doctorStarted = true;
 				try {
-					const doctor = await runCommand("openclaw", [...OPENCLAW_DOCTOR_FIX_ARGS], {
+					const doctor = await runCommand(doctorCommand.command, doctorCommand.args, {
 						...commandOptions(OPENCLAW_DOCTOR_TIMEOUT_MS),
 						maxBuffer: OPENCLAW_DOCTOR_MAX_BUFFER_BYTES
 					});
@@ -256,14 +533,19 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 		} catch (err) {
 			if (runtime === "openclaw" && packageInstallAttempted && !doctorStarted && previousOpenClawVersion) try {
 				logger.warn({ previousOpenClawVersion }, "OpenClaw package replacement failed before state migration — restoring previous package");
-				await runCommand("npm", [
+				const restore = isolated("npm", [
 					"install",
 					"-g",
 					`openclaw@${previousOpenClawVersion}`
-				], commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
+				]);
+				await writeMarker("installing").catch((markerErr) => {
+					logger.warn({ err: markerErr instanceof Error ? markerErr.message : String(markerErr) }, "Could not update the runtime upgrade marker for the rollback");
+				});
+				await runCommand(restore.command, restore.args, commandOptions(OPENCLAW_UPGRADE_TIMEOUT_MS));
 				if (parseOpenClawVersion((await runCommand("openclaw", ["--version"], commandOptions(1e4))).stdout) !== previousOpenClawVersion) throw new Error("restored OpenClaw version did not verify");
 				runtimeChanged = false;
 			} catch (rollbackError) {
+				markerState.keep = true;
 				logger.error({ err: rollbackError instanceof Error ? rollbackError.message : String(rollbackError) }, "Failed to restore the previous OpenClaw package after upgrade failure");
 			}
 			throw err;
@@ -274,6 +556,17 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 			gateSuspended = true;
 			await options.gate.suspendExclusive();
 		} else if (runtimeProcess) await runtimeProcess.stopWhenIdle();
+		for (const pkg of orphanPlugins) {
+			logger.warn({
+				pkg,
+				version
+			}, "Uninstalling orphaned activate-only Alfe plugin before the OpenClaw upgrade");
+			try {
+				await options.pluginOwnership?.removePlugin(pkg);
+			} catch (err) {
+				throw new Error(`Could not uninstall orphaned plugin ${pkg} (activate-only, owned by no integration) before upgrading OpenClaw to ${version ?? "the pin"}: ` + (err instanceof Error ? err.message : String(err)), { cause: err });
+			}
+		}
 		if (runtime === "openclaw" && options.cliLock) await options.cliLock.run(performUpgrade);
 		else await performUpgrade();
 		logger.info({
@@ -304,6 +597,22 @@ async function upgradeRuntime(runtime, version, runtimeProcess, options = {}) {
 			error: message
 		};
 	} finally {
+		if (markerPath && markerState.keep) {
+			const repair = () => recoverInterruptedRuntimeUpgrade({
+				markerPath,
+				...options.isolation ? { isolation: options.isolation } : {},
+				...options.runCommand ? { runCommand: options.runCommand } : {}
+			});
+			try {
+				const outcome = options.cliLock ? await options.cliLock.run(repair) : await repair();
+				logger.warn({ outcome }, "In-process repair after a failed pre-doctor rollback");
+			} catch (repairErr) {
+				logger.error({ err: repairErr instanceof Error ? repairErr.message : String(repairErr) }, "In-process repair after a failed pre-doctor rollback threw — marker kept for the next daemon start");
+			}
+		}
+		if (markerPath && markerState.current && !markerState.keep) await clearRuntimeUpgradeMarker(markerPath).catch((err) => {
+			logger.warn({ err: err instanceof Error ? err.message : String(err) }, "Failed to clear the runtime upgrade marker");
+		});
 		try {
 			if (gateSuspended && options.gate) await options.gate.resume();
 			else if (!options.gate && runtimeProcess) await runtimeProcess.restart();

package/dist/sentry.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { homedir } from "node:os";
-import pino from "pino";
 import { mkdirSync } from "node:fs";
+import pino from "pino";
 import { readConfig, resolveConfig } from "@alfe.ai/config";
 //#region src/logger.ts
 /**
@@ -273,22 +273,29 @@ function setAgentContext(context) {
 /**
 * Capture an integration lifecycle failure (install/activate/reinstall/remove)
 * with `{ integration, phase }` tags. Accepts an `Error` (captured with stack)
-* or a plain message string (captured as an error-level message). No-op when
-* Sentry is not initialised.
+* or a plain message string (captured as an error-level message). Pass
+* `opts.fingerprint` when the message carries variable text that must not
+* split one problem across many Sentry issues. No-op when Sentry is not
+* initialised.
 */
-function captureIntegrationFailure(integration, phase, cause) {
+function captureIntegrationFailure(integration, phase, cause, opts) {
 	if (!sentry) return;
 	try {
-		if (cause instanceof Error) sentry.captureException(cause, { tags: {
-			integration,
-			phase
-		} });
+		const fingerprint = opts?.fingerprint ? { fingerprint: opts.fingerprint } : {};
+		if (cause instanceof Error) sentry.captureException(cause, {
+			tags: {
+				integration,
+				phase
+			},
+			...fingerprint
+		});
 		else sentry.captureMessage(String(cause), {
 			level: "error",
 			tags: {
 				integration,
 				phase
-			}
+			},
+			...fingerprint
 		});
 	} catch {}
 }

package/dist/src/index.d.ts

@@ -46,6 +46,9 @@ declare function startDaemon(): Promise<void>;
  *   - the daemon `runtime.update` default (this package)
  *   - managed provisioning (`services/compute/src/lib/provisioner.ts` installs the
  *     Node.js 24 channel before the CLI consumes this pin)
+ *   - the dashboard/fleet upgrade ceiling: `services/agents` mirrors this literal
+ *     as `PINNED_OPENCLAW_VERSION` in `version-catalog.service.ts` (its test fails
+ *     on drift) — bump both in the same change
  *
  * Pinning (rather than floating `npm install -g openclaw` → `latest`) is deliberate:
  * OpenClaw runs on every managed agent, so a `latest` that changes runtime semantics —
@@ -216,10 +219,14 @@ declare function setAgentContext(context: {
 /**
  * Capture an integration lifecycle failure (install/activate/reinstall/remove)
  * with `{ integration, phase }` tags. Accepts an `Error` (captured with stack)
- * or a plain message string (captured as an error-level message). No-op when
- * Sentry is not initialised.
+ * or a plain message string (captured as an error-level message). Pass
+ * `opts.fingerprint` when the message carries variable text that must not
+ * split one problem across many Sentry issues. No-op when Sentry is not
+ * initialised.
  */
-declare function captureIntegrationFailure(integration: string, phase: string, cause: unknown): void;
+declare function captureIntegrationFailure(integration: string, phase: string, cause: unknown, opts?: {
+  fingerprint?: string[];
+}): void;
 /**
  * Capture a generic CLI failure with a `{ context }` tag. The CLI counterpart
  * to `captureIntegrationFailure` — used by `exitWithError` at the handled-error

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import { d as PINNED_OPENCLAW_VERSION, l as OPENCLAW_MANAGED_NODE_MAJOR, p as supportsOpenClawNode, u as OPENCLAW_NODE_REQUIREMENT } from "../runtime-process.js";
+import { b as PINNED_OPENCLAW_VERSION, v as OPENCLAW_MANAGED_NODE_MAJOR, w as supportsOpenClawNode, y as OPENCLAW_NODE_REQUIREMENT } from "../runtime-upgrade-recovery.js";
 import { _ as loadDaemonConfig, a as installService, c as startService, d as uninstallService, f as PROTOCOL_VERSION, g as fetchAgentConfig, h as SOCKET_PATH, i as checkExistingDaemon, l as stopExistingDaemon, m as PID_PATH, n as queryDaemonHealth, o as isServiceInstalled, p as ALFE_DIR, r as startDaemon, s as restartService, t as formatHealthReport, u as stopService, v as resolveAgentIdentity, y as PINNED_CLAUDE_CODE_HOST_VERSION } from "../health.js";
 import { a as captureFatal, d as flushSentry, f as initAgentSentry, h as logger, i as captureCliFailure, l as captureRuntimeCrash, n as AGENT_MCP_SENTRY_DSN, o as captureIntegrationFailure, p as setAgentContext, r as AGENT_RUNTIME_SENTRY_DSN, s as captureMcpFailure, t as AGENT_DAEMON_SENTRY_DSN, u as captureRuntimeErrorOutput } from "../sentry.js";
 import { n as remediateManagedNode } from "../node-remediation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/gateway",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "description": "Alfe local gateway daemon — persistent control plane for agent integrations",
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "@alfe.ai/ai-proxy-local": "^0.0.17",
     "@alfe.ai/config": "^0.4.1",
     "@alfe.ai/integration-manifest": "^0.4.2",
-    "@alfe.ai/integrations": "^0.6.12",
-    "@alfe.ai/mcp-bundler": "^0.4.2"
+    "@alfe.ai/integrations": "^0.6.15",
+    "@alfe.ai/mcp-bundler": "^0.4.3"
   },
   "license": "UNLICENSED",
   "homepage": "https://alfe.ai",