@alfe.ai/integrations 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -314,9 +314,17 @@ declare class Installer {
 interface RuntimeApplier {
   /** The runtime identifier (e.g. 'openclaw', 'nanoclaw') */
   readonly runtime: string;
-  /** Install a plugin package into this runtime */
+  /**
+   * Install a plugin package into this runtime.
+   *
+   * `opts.integrationId` identifies the owning integration so the applier can
+   * distinguish a legitimate same-integration pin bump from a cross-integration
+   * pin conflict (two integrations pinning the same plugin at different
+   * versions). See `OpenClawApplier`'s first-writer-wins guard.
+   */
   applyPlugin(pkg: string, integrationInstallPath: string, opts?: {
     force?: boolean;
+    integrationId?: string;
   }): Promise<void>;
   /**
    * Optional: pre-trust an integration's full plugin set in one write before
@@ -689,6 +697,13 @@ declare class IntegrationManager {
   clear(): void;
   private checkHealth;
   private err;
+  /**
+   * Build a hook-failure message. A hook we SIGKILLed at its timeout is rendered
+   * as `(timed out after <ms>ms)` so it is visually distinguishable in Sentry
+   * from a genuine non-zero exit `(exit <code>)` — the two have very different
+   * root causes (Sentry AGENT-DAEMON-6).
+   */
+  private hookFailureMessage;
   /**
    * Compute the plugin (bare package) names and skill names still claimed by
    * SOME integration in the CURRENT lock state, keyed by runtime. Both
@@ -778,31 +793,16 @@ declare class StateManager {
 }
 //#endregion
 //#region src/hooks.d.ts
-/**
- * Hook Runner — executes integration lifecycle hook scripts.
- *
- * Hooks are scripts defined in the integration manifest. The runner
- * auto-detects the interpreter from the script's shebang line or file
- * extension (.js/.mjs → node, .py → python3, default → bash).
- *
- * Scripts run as child processes with a 30-second timeout.
- * stdout/stderr are captured and returned.
- *
- * The runner injects standard environment variables:
- * - ALFE_INTEGRATION_DIR — path to the integration install directory
- * - ALFE_STATE_DIR — path to the integration state directory (created if needed)
- * - ALFE_<NAME>_<KEY> — config values (non-secret AND secret, both injected as env vars)
- *
- * Secrets are acceptable as env vars because:
- * - Child process env is ephemeral (dies with the process)
- * - Same security model as Docker secrets / systemd credentials
- * - Never written to disk
- */
 interface HookResult {
   exitCode: number;
   stdout: string;
   stderr: string;
   timedOut: boolean;
+  /**
+   * When `timedOut` is true, the timeout ceiling (ms) that fired the SIGKILL.
+   * Lets callers render a timeout distinctly from a genuine non-zero exit.
+   */
+  timedOutAfterMs?: number;
 }
 interface HookEnvOptions {
   /** Integration name (e.g. "voice") */
@@ -849,9 +849,12 @@ declare function buildHookEnv(options: HookEnvOptions, additionalEnv?: Record<st
  * @param integrationPath - Base path of the integration (where alfe-integration.yaml lives)
  * @param hookScript - Relative path to the hook script (e.g. "scripts/activate.sh")
  * @param env - Additional environment variables to pass to the script
+ * @param timeoutMs - Timeout before the hook is SIGKILLed. Defaults to the fast
+ *   lifecycle ceiling ({@link HOOK_TIMEOUT_MS}); install-phase callers pass
+ *   {@link INSTALL_HOOK_TIMEOUT_MS}.
  * @returns Hook execution result
  */
-declare function runHook(integrationPath: string, hookScript: string, env?: Record<string, string>): Promise<HookResult>;
+declare function runHook(integrationPath: string, hookScript: string, env?: Record<string, string>, timeoutMs?: number): Promise<HookResult>;
 /**
  * Run a hook script with full integration context (config + secrets as env vars).
  *
@@ -862,9 +865,12 @@ declare function runHook(integrationPath: string, hookScript: string, env?: Reco
  * @param integrationPath - Base path of the integration
  * @param hookScript - Relative path to the hook script
  * @param options - Integration name, config, and secrets
+ * @param timeoutMs - Timeout before the hook is SIGKILLed. Defaults to the fast
+ *   lifecycle ceiling ({@link HOOK_TIMEOUT_MS}); install-phase callers pass
+ *   {@link INSTALL_HOOK_TIMEOUT_MS}.
  * @returns Hook execution result
  */
-declare function runHookWithContext(integrationPath: string, hookScript: string, options: HookEnvOptions): Promise<HookResult>;
+declare function runHookWithContext(integrationPath: string, hookScript: string, options: HookEnvOptions, timeoutMs?: number): Promise<HookResult>;
 //#endregion
 //#region src/openclaw-cli-lock.d.ts
 /**
@@ -995,6 +1001,24 @@ declare class OpenClawApplier implements RuntimeApplier {
    * this instance performed (0 = never). See HEAL_MIN_INTERVAL_MS.
    */
   private lastHealAt;
+  /**
+   * Cross-integration plugin-pin claims made during THIS process lifetime,
+   * keyed by bare package name. `applyPlugin` is now version-aware for both
+   * force and non-force callers — it actively reinstalls a plugin whose
+   * installed version differs from the pinned spec (previously the non-force
+   * path keyed only on bare-name presence and silently ignored a pin bump). If
+   * two integrations pin the SAME plugin at DIFFERENT versions, that
+   * version-aware reinstall would make them fight — each reconcile pass
+   * uninstall+reinstalls the other's version forever. This map records the
+   * first-applied pin per package so a later, divergent pin from a DIFFERENT
+   * integration is refused (first-writer-wins) with a WARN instead of thrashing.
+   * A later apply from the SAME integration (a legitimate pin bump across an
+   * upgrade) is NOT a conflict and proceeds. Cleared per-package on
+   * `removePlugin`, and wholesale on daemon restart. Convention is single-owner
+   * per plugin (see the `alfe` manifest note) — this only turns a convention
+   * violation into a stable warning.
+   */
+  private readonly appliedPluginPins;
   constructor(options: OpenClawApplierOptions);
   /**
    * Convenience: `openclaw config set <args>`, UNLOCKED + retried.
@@ -1080,8 +1104,16 @@ declare class OpenClawApplier implements RuntimeApplier {
   private healMalformedStateDb;
   applyPlugin(spec: string, _installPath?: string, opts?: {
     force?: boolean;
+    integrationId?: string;
   }): Promise<void>;
   private applyPluginLocked;
+  /**
+   * Record the pin a caller just applied for a package, keyed by bare name, so
+   * a later divergent pin from a DIFFERENT integration in this process can be
+   * refused (first-writer-wins). Bare (versionless) pins are untrackable and
+   * ignored — they can't conflict on version. See `appliedPluginPins`.
+   */
+  private recordPluginPin;
   /**
    * Ensure one or more plugins are in plugins.allow in openclaw.json, UNLOCKED.
    * Uses `openclaw config set` to avoid clobbering OpenClaw's own file format.

package/dist/index.js

@@ -746,7 +746,19 @@ var LockManager = class {
 * - Same security model as Docker secrets / systemd credentials
 * - Never written to disk
 */
+/**
+* Default timeout for lifecycle hooks (activate/health_check/uninstall). These
+* are expected to be fast; a long-running one is a bug and should be killed.
+*/
 const HOOK_TIMEOUT_MS = 3e4;
+/**
+* Timeout for install-phase hooks (pre_install/post_install). These legitimately
+* take minutes — they clone repos, run `npm install`, download binaries — so the
+* fast 30s ceiling would SIGKILL a healthy install mid-flight (Sentry
+* AGENT-DAEMON-6). Callers opt into this longer ceiling explicitly per hook type;
+* it is NOT the global default so lifecycle hooks stay fast.
+*/
+const INSTALL_HOOK_TIMEOUT_MS = 6e5;
 const INTEGRATIONS_BASE_DIR = join(homedir(), ".alfe", "integrations");
 const STATE_BASE_DIR = join(homedir(), ".alfe", "state");
 /**
@@ -848,9 +860,12 @@ function resolveInterpreter(scriptPath) {
 * @param integrationPath - Base path of the integration (where alfe-integration.yaml lives)
 * @param hookScript - Relative path to the hook script (e.g. "scripts/activate.sh")
 * @param env - Additional environment variables to pass to the script
+* @param timeoutMs - Timeout before the hook is SIGKILLed. Defaults to the fast
+*   lifecycle ceiling ({@link HOOK_TIMEOUT_MS}); install-phase callers pass
+*   {@link INSTALL_HOOK_TIMEOUT_MS}.
 * @returns Hook execution result
 */
-async function runHook(integrationPath, hookScript, env) {
+async function runHook(integrationPath, hookScript, env, timeoutMs = HOOK_TIMEOUT_MS) {
 	const scriptPath = join(integrationPath, hookScript);
 	if (!existsSync(scriptPath)) return {
 		exitCode: 0,
@@ -878,7 +893,7 @@ async function runHook(integrationPath, hookScript, env) {
 		const timer = setTimeout(() => {
 			timedOut = true;
 			proc.kill("SIGKILL");
-		}, HOOK_TIMEOUT_MS);
+		}, timeoutMs);
 		proc.stdout.on("data", (data) => {
 			stdout += data.toString();
 			if (stdout.length > 1e5) stdout = stdout.slice(0, 1e5) + "\n[truncated]";
@@ -893,7 +908,8 @@ async function runHook(integrationPath, hookScript, env) {
 				exitCode: code ?? 1,
 				stdout: stdout.trim(),
 				stderr: stderr.trim(),
-				timedOut
+				timedOut,
+				timedOutAfterMs: timedOut ? timeoutMs : void 0
 			});
 		});
 		proc.on("error", (err) => {
@@ -917,10 +933,13 @@ async function runHook(integrationPath, hookScript, env) {
 * @param integrationPath - Base path of the integration
 * @param hookScript - Relative path to the hook script
 * @param options - Integration name, config, and secrets
+* @param timeoutMs - Timeout before the hook is SIGKILLed. Defaults to the fast
+*   lifecycle ceiling ({@link HOOK_TIMEOUT_MS}); install-phase callers pass
+*   {@link INSTALL_HOOK_TIMEOUT_MS}.
 * @returns Hook execution result
 */
-async function runHookWithContext(integrationPath, hookScript, options) {
-	return runHook(integrationPath, hookScript, buildHookEnv(options));
+async function runHookWithContext(integrationPath, hookScript, options, timeoutMs = HOOK_TIMEOUT_MS) {
+	return runHook(integrationPath, hookScript, buildHookEnv(options), timeoutMs);
 }
 //#endregion
 //#region src/plugin-spec.ts
@@ -1127,8 +1146,8 @@ var IntegrationManager = class {
 			if (!installHooksSupported && (manifest.hooks.pre_install || manifest.hooks.post_install)) this.log.warn(`Integration "${name}" install hooks skipped — no registered runtime (${[...this.runtimeAppliers.keys()].join(", ")}) is in supported_agents (${(manifest.supported_agents ?? []).join(", ")})`);
 			if (installHooksSupported && manifest.hooks.pre_install) {
 				this.log.info(`Running pre_install hook: ${manifest.hooks.pre_install}`);
-				const hookResult = await runHook(installPath, manifest.hooks.pre_install);
-				if (hookResult.exitCode !== 0) throw new Error(`pre_install hook failed (exit ${String(hookResult.exitCode)}): ${hookResult.stderr || hookResult.stdout}`);
+				const hookResult = await runHook(installPath, manifest.hooks.pre_install, void 0, INSTALL_HOOK_TIMEOUT_MS);
+				if (hookResult.exitCode !== 0) throw new Error(this.hookFailureMessage("pre_install hook failed", hookResult));
 			}
 			if (installHooksSupported && manifest.hooks.post_install) {
 				this.log.info(`Running post_install hook: ${manifest.hooks.post_install}`);
@@ -1137,8 +1156,8 @@ var IntegrationManager = class {
 					config: config ?? {},
 					secrets: this.secrets.get(name),
 					runtimes: [...this.runtimeAppliers.keys()]
-				});
-				if (hookResult.exitCode !== 0) throw new Error(`post_install hook failed (exit ${String(hookResult.exitCode)}): ${hookResult.stderr || hookResult.stdout}`);
+				}, INSTALL_HOOK_TIMEOUT_MS);
+				if (hookResult.exitCode !== 0) throw new Error(this.hookFailureMessage("post_install hook failed", hookResult));
 			}
 			this.state.set(name, {
 				status: "installed",
@@ -1271,7 +1290,10 @@ var IntegrationManager = class {
 				for (const plugin of plugins) {
 					this.log.info(`Applying plugin ${plugin.package} to ${runtimeName}`);
 					try {
-						await applier.applyPlugin(plugin.package, installPath, { force: opts?.forcePlugins });
+						await applier.applyPlugin(plugin.package, installPath, {
+							force: opts?.forcePlugins,
+							integrationId
+						});
 					} catch (err) {
 						const msg = err instanceof Error ? err.message : String(err);
 						this.log.error(`Failed to apply plugin ${plugin.package}: ${msg}`);
@@ -1325,8 +1347,9 @@ var IntegrationManager = class {
 					runtimes: [...this.runtimeAppliers.keys()]
 				});
 				if (hookResult.exitCode !== 0) {
-					this.state.setStatus(integrationId, "error", `post_activate hook failed: ${hookResult.stderr || hookResult.stdout}`);
-					return this.err("POST_ACTIVATE_FAILED", `post_activate hook failed (exit ${String(hookResult.exitCode)}): ${hookResult.stderr || hookResult.stdout}`);
+					const message = this.hookFailureMessage("post_activate hook failed", hookResult);
+					this.state.setStatus(integrationId, "error", message);
+					return this.err("POST_ACTIVATE_FAILED", message);
 				}
 			}
 			if (manifest.hooks.health_check && !runtimeSupported) this.log.warn(`Integration "${integrationId}" health_check hook skipped — no registered runtime (${[...this.runtimeAppliers.keys()].join(", ")}) is in supported_agents (${(supportedAgents ?? []).join(", ")})`);
@@ -1339,8 +1362,9 @@ var IntegrationManager = class {
 					runtimes: [...this.runtimeAppliers.keys()]
 				});
 				if (hookResult.exitCode !== 0) {
-					this.state.setStatus(integrationId, "error", `Health check failed: ${hookResult.stderr || hookResult.stdout}`);
-					return this.err("HEALTH_CHECK_FAILED", `Health check failed (exit ${String(hookResult.exitCode)}): ${hookResult.stderr || hookResult.stdout}`);
+					const message = this.hookFailureMessage("Health check failed", hookResult);
+					this.state.setStatus(integrationId, "error", message);
+					return this.err("HEALTH_CHECK_FAILED", message);
 				}
 			}
 			this.log.info(`Integration "${integrationId}" activated`);
@@ -1482,8 +1506,8 @@ var IntegrationManager = class {
 					config: entry.config,
 					secrets: this.secrets.get(name),
 					runtimes: [...this.runtimeAppliers.keys()]
-				});
-				if (hookResult.exitCode !== 0) this.log.warn(`pre_uninstall hook failed (continuing): ${hookResult.stderr}`);
+				}, INSTALL_HOOK_TIMEOUT_MS);
+				if (hookResult.exitCode !== 0) this.log.warn(this.hookFailureMessage("pre_uninstall hook failed (continuing)", hookResult));
 			}
 			if (uninstallHooksSupported && manifest?.hooks.post_uninstall) {
 				this.log.info(`Running post_uninstall hook: ${manifest.hooks.post_uninstall}`);
@@ -1492,8 +1516,8 @@ var IntegrationManager = class {
 					config: entry.config,
 					secrets: this.secrets.get(name),
 					runtimes: [...this.runtimeAppliers.keys()]
-				});
-				if (hookResult.exitCode !== 0) this.log.warn(`post_uninstall hook failed (non-fatal): ${hookResult.stderr}`);
+				}, INSTALL_HOOK_TIMEOUT_MS);
+				if (hookResult.exitCode !== 0) this.log.warn(this.hookFailureMessage("post_uninstall hook failed (non-fatal)", hookResult));
 			}
 			if (this.installer.isInstalled(name)) {
 				await this.installer.remove(name);
@@ -1644,8 +1668,8 @@ var IntegrationManager = class {
 			if (!installHooksSupported && (newManifest.hooks.pre_install || newManifest.hooks.post_install)) this.log.warn(`Integration "${name}" upgrade install hooks skipped — no registered runtime (${[...this.runtimeAppliers.keys()].join(", ")}) is in supported_agents (${(newManifest.supported_agents ?? []).join(", ")})`);
 			if (installHooksSupported && newManifest.hooks.pre_install) {
 				this.log.info(`Running pre_install hook: ${newManifest.hooks.pre_install}`);
-				const hookResult = await runHook(this.installer.getInstallPath(name), newManifest.hooks.pre_install);
-				if (hookResult.exitCode !== 0) throw new Error(`pre_install hook failed (exit ${String(hookResult.exitCode)}): ${hookResult.stderr || hookResult.stdout}`);
+				const hookResult = await runHook(this.installer.getInstallPath(name), newManifest.hooks.pre_install, void 0, INSTALL_HOOK_TIMEOUT_MS);
+				if (hookResult.exitCode !== 0) throw new Error(this.hookFailureMessage("pre_install hook failed", hookResult));
 			}
 			if (installHooksSupported && newManifest.hooks.post_install) {
 				this.log.info(`Running post_install hook: ${newManifest.hooks.post_install}`);
@@ -1654,8 +1678,8 @@ var IntegrationManager = class {
 					config: config ?? existing.config,
 					secrets: this.secrets.get(name),
 					runtimes: [...this.runtimeAppliers.keys()]
-				});
-				if (hookResult.exitCode !== 0) throw new Error(`post_install hook failed (exit ${String(hookResult.exitCode)}): ${hookResult.stderr || hookResult.stdout}`);
+				}, INSTALL_HOOK_TIMEOUT_MS);
+				if (hookResult.exitCode !== 0) throw new Error(this.hookFailureMessage("post_install hook failed", hookResult));
 			}
 			await this.applyUpgradeDiffRemovals(name, oldManifest, newManifest);
 			return await this.activate(name, { forcePlugins: true });
@@ -1834,7 +1858,7 @@ var IntegrationManager = class {
 				healthy: hookResult.exitCode === 0,
 				status: entry.status,
 				version: manifest.version,
-				message: hookResult.exitCode === 0 ? "Healthy" : `Health check failed (exit ${String(hookResult.exitCode)})`,
+				message: hookResult.exitCode === 0 ? "Healthy" : hookResult.timedOut ? `Health check failed (timed out after ${String(hookResult.timedOutAfterMs ?? "?")}ms)` : `Health check failed (exit ${String(hookResult.exitCode)})`,
 				stdout: hookResult.stdout || void 0,
 				stderr: hookResult.stderr || void 0
 			};
@@ -1858,6 +1882,17 @@ var IntegrationManager = class {
 		};
 	}
 	/**
+	* Build a hook-failure message. A hook we SIGKILLed at its timeout is rendered
+	* as `(timed out after <ms>ms)` so it is visually distinguishable in Sentry
+	* from a genuine non-zero exit `(exit <code>)` — the two have very different
+	* root causes (Sentry AGENT-DAEMON-6).
+	*/
+	hookFailureMessage(label, hookResult) {
+		const reason = hookResult.timedOut ? `timed out after ${String(hookResult.timedOutAfterMs ?? "?")}ms` : `exit ${String(hookResult.exitCode)}`;
+		const output = hookResult.stderr || hookResult.stdout;
+		return output ? `${label} (${reason}): ${output}` : `${label} (${reason})`;
+	}
+	/**
 	* Compute the plugin (bare package) names and skill names still claimed by
 	* SOME integration in the CURRENT lock state, keyed by runtime. Both
 	* `deactivate` and `upgrade`'s diff-removal call this AFTER
@@ -2301,6 +2336,24 @@ var OpenClawApplier = class {
 	* this instance performed (0 = never). See HEAL_MIN_INTERVAL_MS.
 	*/
 	lastHealAt = 0;
+	/**
+	* Cross-integration plugin-pin claims made during THIS process lifetime,
+	* keyed by bare package name. `applyPlugin` is now version-aware for both
+	* force and non-force callers — it actively reinstalls a plugin whose
+	* installed version differs from the pinned spec (previously the non-force
+	* path keyed only on bare-name presence and silently ignored a pin bump). If
+	* two integrations pin the SAME plugin at DIFFERENT versions, that
+	* version-aware reinstall would make them fight — each reconcile pass
+	* uninstall+reinstalls the other's version forever. This map records the
+	* first-applied pin per package so a later, divergent pin from a DIFFERENT
+	* integration is refused (first-writer-wins) with a WARN instead of thrashing.
+	* A later apply from the SAME integration (a legitimate pin bump across an
+	* upgrade) is NOT a conflict and proceeds. Cleared per-package on
+	* `removePlugin`, and wholesale on daemon restart. Convention is single-owner
+	* per plugin (see the `alfe` manifest note) — this only turns a convention
+	* violation into a stable warning.
+	*/
+	appliedPluginPins = /* @__PURE__ */ new Map();
 	constructor(options) {
 		const home = options.home ?? options.workspace;
 		if (!home) throw new Error("OpenClawApplier requires `home` (or legacy `workspace`) option");
@@ -2484,25 +2537,43 @@ var OpenClawApplier = class {
 	}
 	async applyPluginLocked(spec, opts) {
 		const pkg = stripPluginVersion(spec);
+		const pinnedVersion = pluginSpecVersion(spec);
+		const claim = this.appliedPluginPins.get(pkg);
+		if (pinnedVersion !== void 0 && claim !== void 0 && claim.version !== pinnedVersion && claim.integrationId !== opts?.integrationId) {
+			log$3.warn({
+				pkg,
+				requestedVersion: pinnedVersion,
+				keptVersion: claim.version,
+				requestedBy: opts?.integrationId,
+				ownedBy: claim.integrationId
+			}, "Conflicting plugin pin across integrations — keeping the first-applied version (first-writer-wins)");
+			return;
+		}
 		await this.ensurePluginsAllowUnlocked(pkg);
 		this.cleanupUntrackedExtensionInstall(pkg);
-		if (opts?.force && this.isPluginInstalled(pkg)) {
-			const pinnedVersion = pluginSpecVersion(spec);
+		if (this.isPluginInstalled(pkg)) {
 			const installedVersion = this.installedPluginVersion(pkg);
-			if (pinnedVersion && installedVersion && installedVersion === pinnedVersion) {
-				log$3.info({
+			const versionsComparable = pinnedVersion !== void 0 && installedVersion !== void 0;
+			if (versionsComparable && installedVersion === pinnedVersion) {
+				if (opts?.force) log$3.info({
 					pkg,
 					spec,
 					version: installedVersion
 				}, "Force mode — installed version already matches pinned spec, skipping uninstall+reinstall");
+				this.recordPluginPin(pkg, pinnedVersion, opts?.integrationId);
+				return;
+			}
+			if (!(versionsComparable && installedVersion !== pinnedVersion) && !opts?.force) {
+				this.recordPluginPin(pkg, pinnedVersion, opts?.integrationId);
 				return;
 			}
 			log$3.info({
 				pkg,
 				spec,
 				installedVersion,
-				pinnedVersion
-			}, "Force mode — uninstalling plugin before reinstall");
+				pinnedVersion,
+				force: opts?.force ?? false
+			}, "Reinstalling plugin to converge on the pinned version");
 			try {
 				await this.removePluginUnlocked(pkg);
 			} catch (err) {
@@ -2510,7 +2581,7 @@ var OpenClawApplier = class {
 					pkg,
 					spec,
 					err: err instanceof Error ? err.message : String(err)
-				}, "Failed to uninstall plugin during force reinstall — proceeding");
+				}, "Failed to uninstall plugin before reinstall — proceeding");
 			}
 		}
 		if (!this.isPluginInstalled(pkg)) {
@@ -2547,6 +2618,20 @@ var OpenClawApplier = class {
 				setTimeout(r, 500);
 			});
 		}
+		this.recordPluginPin(pkg, pinnedVersion, opts?.integrationId);
+	}
+	/**
+	* Record the pin a caller just applied for a package, keyed by bare name, so
+	* a later divergent pin from a DIFFERENT integration in this process can be
+	* refused (first-writer-wins). Bare (versionless) pins are untrackable and
+	* ignored — they can't conflict on version. See `appliedPluginPins`.
+	*/
+	recordPluginPin(pkg, version, integrationId) {
+		if (version === void 0) return;
+		this.appliedPluginPins.set(pkg, {
+			version,
+			integrationId
+		});
 	}
 	/**
 	* Ensure one or more plugins are in plugins.allow in openclaw.json, UNLOCKED.
@@ -2692,6 +2777,7 @@ var OpenClawApplier = class {
 	*/
 	async removePluginUnlocked(spec) {
 		const pkg = stripPluginVersion(spec);
+		this.appliedPluginPins.delete(pkg);
 		await this.execOpenClawHealing([
 			"plugins",
 			"uninstall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",