@alfe.ai/openclaw-identity 0.1.27 → 0.1.28

package/dist/plugin2.cjs

@@ -13,7 +13,7 @@ let _auriclabs_roles = require("@auriclabs/roles");
 * Permissions narrow which tools an identity may exec via sift
 * conditions on the `tool` field. `args` is its own field — never
 * spread — so a tool whose args legitimately include a `tool` key
-* can't override the gate's value (closes the round-5 toolArgs.tool
+* can't override the gate's value (closes the round-5 parameter-name
 * collision).
 *
 * The function is a thin wrapper around `createAbility(...).has(...)`
@@ -23,12 +23,10 @@ let _auriclabs_roles = require("@auriclabs/roles");
 * silently loses `cannot` semantics — the wrapper makes the contract
 * explicit and testable.
 *
-* Today this function is wired into `before_tool_call` only for the
-* TOKEN path (B.0.7 atomic flip carries the token's `Permission[]` in
-* `ctx.tokenPermissions`). The JWT path still falls back to permissive
-* because the agent runtime can't yet fetch the resolved permission
-* set for `ctx.actingIdentityId` (needs an AgentApiClient endpoint
-* that doesn't exist yet — landing alongside Stage D's full rollout).
+* The live `before_tool_call` hook uses this evaluator for both an optional
+* Alfe-augmented token-permissions path and the resolved permission set cached
+* from `message_received`. Stock OpenClaw does not expose auth-method or token
+* permissions in its tool context, so the cache path is the production path.
 */
 /**
 * Evaluate the round-6 strict-namespacing gate. Single
@@ -74,51 +72,28 @@ function applyGateMode(decision, mode, toolName) {
 	};
 }
 /**
-* Resolve the kill-switch from process.env. Defaults to "fail-closed"
-* in production and "fail-open" elsewhere — Stage H flips production
-* to fail-closed once metrics confirm a stable deny rate.
+* Resolve the kill-switch from process.env. It currently defaults to
+* "fail-open" in every environment; rollout wiring must set "fail-closed"
+* explicitly once metrics confirm a stable deny rate.
 */
 function resolveToolGatingMode() {
 	const raw = process.env.OPENCLAW_TOOL_GATING;
 	if (raw === "fail-open" || raw === "fail-closed") return raw;
 	return "fail-open";
 }
-/**
-* Evaluate `agent:chat` — the inbound conversational gate (Layer 2 of the
-* default-deny chat path). Mirrors `evaluateAgentExec` but with no
-* tool/args context — chat admission only depends on whether the
-* resolved identity holds `agent:chat` at the agent's scope.
-*
-* Layer 1 (`services/chat`) already gates this for chat WS + channel
-* adapter inject. The OpenClaw plugin's `message_received` hook is
-* defense-in-depth — it catches any path that reaches the agent
-* runtime without going through Layer 1.
-*/
-function evaluateAgentChat(permissions, args) {
-	if (!args.agentId) return { allowed: false };
-	const ability = (0, _auriclabs_roles.createAbility)(permissions);
-	const gatePermission = {
-		subject: "agent",
-		action: "chat",
-		scope: `agent:${args.agentId}`
-	};
-	return { allowed: ability.has(gatePermission, {}) };
-}
 //#endregion
 //#region src/plugin.ts
 /**
 * @alfe.ai/openclaw-identity — OpenClaw native plugin
 *
-* HTTP-based identity resolution + role-based admission gate. Installed as
+* HTTP-based identity resolution + role-based tool gate. Installed as
 * part of the core alfe integration on every agent.
 *
 * Hooks:
-*   - message_received  → resolves the sender via the agent API and gates
-*                         on `agent:chat` at the agent's scope using the
-*                         resolved identity's permission set
-*                         (`evaluateAgentChat`). Blocks unknown senders
-*                         and any identity without the permission. Layer 2
-*                         of the default-deny chat path.
+*   - message_received  → resolves and caches the sender via the agent API.
+*                         OpenClaw runs this hook fire-and-forget and ignores
+*                         return values, so it is context preparation, not an
+*                         admission boundary.
 *   - before_tool_call  → typed `(event: ToolCallEvent, ctx: ToolCallContext)`
 *                         hook (Phase 1 Stage A.0). Gates `agent:exec`
 *                         via `evaluateAgentExec` against the token's
@@ -132,18 +107,26 @@ function evaluateAgentChat(permissions, args) {
 */
 const pkg = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
 const RESOLVE_CACHE_TTL_MS = 6e4;
+const MAX_RESOLVE_CACHE_ENTRIES = 1e3;
 const resolveCache = /* @__PURE__ */ new Map();
 let lastInboundConversationId;
 function getCachedResolve(key) {
 	const entry = resolveCache.get(key);
 	if (!entry) return null;
-	if (Date.now() > entry.expiresAt) {
+	if (Date.now() >= entry.expiresAt) {
 		resolveCache.delete(key);
 		return null;
 	}
 	return entry;
 }
 function setCachedResolve(key, value) {
+	const now = Date.now();
+	for (const [cachedKey, entry] of resolveCache) if (entry.expiresAt <= now) resolveCache.delete(cachedKey);
+	while (resolveCache.size >= MAX_RESOLVE_CACHE_ENTRIES) {
+		const oldest = resolveCache.keys().next();
+		if (oldest.done) break;
+		resolveCache.delete(oldest.value);
+	}
 	resolveCache.set(key, {
 		...value,
 		expiresAt: Date.now() + RESOLVE_CACHE_TTL_MS
@@ -160,8 +143,11 @@ function findMostRelevantCacheEntry(probeKeys) {
 	}
 	let mostRecent = null;
 	const now = Date.now();
-	for (const entry of resolveCache.values()) {
-		if (entry.expiresAt < now) continue;
+	for (const [key, entry] of resolveCache) {
+		if (entry.expiresAt <= now) {
+			resolveCache.delete(key);
+			continue;
+		}
 		if (!mostRecent || entry.expiresAt > mostRecent.expiresAt) mostRecent = entry;
 	}
 	return mostRecent;
@@ -177,17 +163,14 @@ function isSelfScopedWhoIsThis(toolArgs, cacheKey) {
 	return argProvider === cached.senderProvider && argPlatformId === cached.senderPlatformId;
 }
 /**
-* Resolve the inbound session identity. Reads from `lastInboundConversationId`
-* (set by `message_received`) — the LLM-supplied `params.conversationId` is
-* ignored because in practice the LLM copies the visible-metadata
-* `conversationId` field, which is currently the WS request envelope id
-* (`req_…`), not the real session key the cache is keyed on. Falls back to
-* `params.conversationId` only when no inbound message has been observed
-* this process (autonomous / scheduled triggers).
+* Resolve the inbound session identity from the conversation value overwritten
+* by `before_tool_call`. The hook replaces model-controlled input with the
+* message-to-run bridge before execution. Autonomous and scheduled triggers
+* receive an empty value and therefore have no fallback to a prior sender.
 */
 function resolveSessionIdentity(params) {
-	const conversationId = lastInboundConversationId ?? params.conversationId;
-	if (!conversationId) return {
+	const conversationId = params.conversationId;
+	if (typeof conversationId !== "string" || conversationId.length === 0) return {
 		ok: false,
 		error: "no_inbound_session: identity verification can only be initiated from a user-message turn. The verify tools auto-bind to the inbound sender's session and cannot be called from autonomous / scheduled / tool-chain triggers."
 	};
@@ -230,29 +213,54 @@ function getClient() {
 }
 let cachedAgentContext = null;
 let inflightWhoami = null;
+let lifecycleGeneration = 0;
+let whoamiRetryAfter = 0;
+const WHOAMI_RETRY_COOLDOWN_MS = 5e3;
+const conversationByRunId = /* @__PURE__ */ new Map();
 async function getAgentContext(client) {
 	if (cachedAgentContext) return cachedAgentContext;
 	if (inflightWhoami) return inflightWhoami;
-	inflightWhoami = (async () => {
+	if (Date.now() < whoamiRetryAfter) return null;
+	const generation = lifecycleGeneration;
+	const request = (async () => {
 		try {
 			const r = await client.whoami();
+			if (generation !== lifecycleGeneration) return null;
+			whoamiRetryAfter = 0;
 			cachedAgentContext = {
 				agentId: r.agentId,
 				tenantId: r.tenantId
 			};
 			return cachedAgentContext;
 		} catch {
+			if (generation === lifecycleGeneration) whoamiRetryAfter = Date.now() + WHOAMI_RETRY_COOLDOWN_MS;
 			return null;
-		} finally {
-			inflightWhoami = null;
 		}
 	})();
-	return inflightWhoami;
+	inflightWhoami = request;
+	request.finally(() => {
+		if (inflightWhoami === request) inflightWhoami = null;
+	});
+	return request;
+}
+function resolveToolConversation(ctx) {
+	if (ctx.runId) {
+		const runConversation = conversationByRunId.get(ctx.runId);
+		if (runConversation) return runConversation;
+	}
+	return lastInboundConversationId ?? ctx.conversationId ?? ctx.sessionKey ?? null;
+}
+function resolveInboundConversation(ctx) {
+	if (ctx.runId) {
+		const runConversation = conversationByRunId.get(ctx.runId);
+		if (runConversation) return runConversation;
+	}
+	return lastInboundConversationId ?? null;
 }
 const plugin = {
 	id: "@alfe.ai/openclaw-identity",
 	name: "Alfe Identity",
-	description: "Identity resolution and access gating for inbound messages",
+	description: "Identity resolution and role-based tool gating",
 	version: pkg.version,
 	activate(api) {
 		(0, _alfe_ai_agent_api_client.installToolErrorCapture)(api, { plugin: "openclaw-identity" });
@@ -283,8 +291,16 @@ const plugin = {
 				name: "lookup_identity",
 				description: "Search identities by name. Returns multiple matches.",
 				parameters: _sinclair_typebox.Type.Object({
-					query: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Text search query" })),
-					status: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
+					query: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({
+						description: "Text search query",
+						maxLength: 256
+					})),
+					status: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Union([
+						_sinclair_typebox.Type.Literal("anonymous"),
+						_sinclair_typebox.Type.Literal("partial"),
+						_sinclair_typebox.Type.Literal("identified"),
+						_sinclair_typebox.Type.Literal("verified")
+					]))
 				}),
 				handler: (params) => client.searchIdentities({
 					q: params.query,
@@ -298,22 +314,13 @@ const plugin = {
 					survivorId: _sinclair_typebox.Type.String({ description: "Identity to keep" }),
 					mergedId: _sinclair_typebox.Type.String({ description: "Identity to merge into survivor" })
 				}),
-				handler: (params) => client.mergeIdentities(params.survivorId, {
-					mergedId: params.mergedId,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
-				})
+				handler: (params) => client.mergeIdentities(params.survivorId, { mergedId: params.mergedId })
 			}),
 			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "unmerge_identities",
 				description: "Reverse a merge — restore previously merged identity.",
 				parameters: _sinclair_typebox.Type.Object({ mergedId: _sinclair_typebox.Type.String({ description: "Identity that was merged (has mergedInto pointer)" }) }),
-				handler: (params) => client.unmergeIdentity(params.mergedId, { changedBy: {
-					type: "agent",
-					id: "plugin"
-				} })
+				handler: (params) => client.unmergeIdentity(params.mergedId)
 			}),
 			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "add_identity_note",
@@ -321,15 +328,17 @@ const plugin = {
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
 					content: _sinclair_typebox.Type.String(),
-					category: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "observation, preference, relationship, context, or warning" }))
+					category: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Union([
+						_sinclair_typebox.Type.Literal("observation"),
+						_sinclair_typebox.Type.Literal("preference"),
+						_sinclair_typebox.Type.Literal("relationship"),
+						_sinclair_typebox.Type.Literal("context"),
+						_sinclair_typebox.Type.Literal("warning")
+					]))
 				}),
 				handler: (params) => client.addIdentityNote(params.identityId, {
 					content: params.content,
-					category: params.category,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
+					category: params.category
 				})
 			}),
 			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
@@ -337,16 +346,15 @@ const plugin = {
 				description: "Add or remove a tag on an identity.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
-					tag: _sinclair_typebox.Type.String(),
-					action: _sinclair_typebox.Type.String({ description: "'add' or 'remove'" })
+					tag: _sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: 128
+					}),
+					action: _sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("add"), _sinclair_typebox.Type.Literal("remove")])
 				}),
 				handler: (params) => client.tagIdentity(params.identityId, {
 					tag: params.tag,
-					action: params.action,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
+					action: params.action
 				})
 			}),
 			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
@@ -354,7 +362,10 @@ const plugin = {
 				description: "Get the changelog for an identity — versions, diffs, who changed what.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
-					limit: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Number())
+					limit: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Integer({
+						minimum: 1,
+						maximum: 200
+					}))
 				}),
 				handler: (params) => client.getIdentityChangelog(params.identityId, { limit: params.limit })
 			}),
@@ -363,15 +374,9 @@ const plugin = {
 				description: "Revert an identity to a previous version.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
-					targetVersion: _sinclair_typebox.Type.Number()
+					targetVersion: _sinclair_typebox.Type.Integer({ minimum: 0 })
 				}),
-				handler: (params) => client.rollbackIdentity(params.identityId, {
-					targetVersion: params.targetVersion,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
-				})
+				handler: (params) => client.rollbackIdentity(params.identityId, { targetVersion: params.targetVersion })
 			}),
 			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "update_identity",
@@ -385,7 +390,7 @@ const plugin = {
 				}),
 				handler: (params) => {
 					const { identityId, ...rest } = params;
-					if (!identityId.startsWith("idn_")) throw new Error(`"${identityId}" is not a contact identity (those start with "idn_"). update_identity edits OTHER people you know — NOT your own agent profile. To set YOUR OWN profile picture, call generate_avatar (from a prompt) or set_avatar (with the image url you already generated). To change your own voice, call set_voice.`);
+					if (!identityId.startsWith("idn_")) throw (0, _alfe_ai_openclaw_plugin_kit.publicToolError)(`"${identityId}" is not a contact identity (those start with "idn_"). update_identity edits OTHER people you know — NOT your own agent profile. To set YOUR OWN profile picture, call generate_avatar (from a prompt) or set_avatar (with the image url you already generated). To change your own voice, call set_voice.`);
 					return client.updateIdentity(identityId, rest);
 				}
 			}),
@@ -396,12 +401,15 @@ const plugin = {
 					conversationId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Deprecated and ignored — the tool auto-binds to the current inbound session. Retained as optional for back-compat with older agent prompts." })),
 					contactEmail: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Email to verify (mutually exclusive with contactMobile)" })),
 					contactMobile: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "E.164 mobile to verify (mutually exclusive with contactEmail)" })),
-					preferredChannel: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "When neither contactEmail nor contactMobile is provided, pick which existing verified contact to deliver to: 'mobile' or 'email'" }))
+					preferredChannel: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("mobile"), _sinclair_typebox.Type.Literal("email")], { description: "When neither contactEmail nor contactMobile is provided, pick which existing verified contact to deliver to" }))
 				}),
 				handler: (params) => {
 					const contactEmail = params.contactEmail;
 					const contactMobile = params.contactMobile;
-					if (contactEmail && contactMobile) return Promise.resolve({ error: "Specify exactly one of contactEmail or contactMobile, not both" });
+					if (contactEmail && contactMobile) return Promise.resolve({
+						status: "error",
+						error: "Specify exactly one of contactEmail or contactMobile, not both"
+					});
 					const contact = contactEmail ? {
 						channel: "email",
 						value: contactEmail
@@ -410,7 +418,10 @@ const plugin = {
 						value: contactMobile
 					} : void 0;
 					const resolved = resolveRequesterContext(params);
-					if ("error" in resolved) return Promise.resolve({ error: resolved.error });
+					if ("error" in resolved) return Promise.resolve({
+						status: "error",
+						error: resolved.error
+					});
 					return client.requestIdentityVerification({
 						claimedIdentityId: resolved.claimedIdentityId,
 						requestingIdentityId: resolved.requestingIdentityId,
@@ -431,15 +442,18 @@ const plugin = {
 				}),
 				handler: async (params) => {
 					const resolved = resolveClaimedIdentity(params);
-					if ("error" in resolved) return { error: resolved.error };
+					if ("error" in resolved) return {
+						status: "error",
+						error: resolved.error
+					};
 					const result = await client.confirmIdentityVerification({
 						claimedIdentityId: resolved.claimedIdentityId,
 						verificationId: params.verificationId,
 						phrase: params.phrase
 					});
 					if (result.verified === true) {
-						const conversationId = lastInboundConversationId ?? params.conversationId;
-						if (conversationId) invalidateCachedResolve(conversationId);
+						const conversationId = params.conversationId;
+						if (typeof conversationId === "string" && conversationId.length > 0) invalidateCachedResolve(conversationId);
 					}
 					return result;
 				}
@@ -450,34 +464,18 @@ const plugin = {
 		api.on("message_received", async (...args) => {
 			const event = args[0];
 			const ctx = args[1];
-			const provider = ctx.channelId ?? "unknown";
-			const senderId = event.metadata?.UserId ?? event.from;
+			const provider = event.metadata?.provider ?? ctx.channelId ?? "unknown";
+			const senderId = event.metadata?.senderId ?? event.metadata?.UserId ?? event.from;
 			if (!senderId) return;
 			if (ctx.conversationId) lastInboundConversationId = ctx.conversationId;
-			let agentId = ctx.agentId;
-			if (!agentId) {
-				const fallback = await getAgentContext(client);
-				if (fallback) agentId = fallback.agentId;
-				else {
-					log.warn("message_received without ctx.agentId AND whoami unavailable — fail-closed");
-					return {
-						block: true,
-						blockReason: "Identity: agentId missing on message context and whoami fallback unavailable"
-					};
-				}
-			}
 			const forwarded = Array.isArray(event.metadata?.SenderPermissions) ? event.metadata.SenderPermissions.filter((p) => typeof p === "string") : [];
 			const cacheKey = ctx.conversationId ?? `${provider}:${senderId}`;
 			const cached = getCachedResolve(cacheKey);
 			if (cached) {
-				if (cached.identityId == null) return {
-					block: true,
-					blockReason: "Identity: identity not provisioned for this channel"
-				};
-				if (!evaluateAgentChat([...cached.permissions, ...forwarded], { agentId }).allowed) return {
-					block: true,
-					blockReason: "Identity: chat not permitted for this sender"
-				};
+				if (forwarded.length > 0) setCachedResolve(cacheKey, {
+					...cached,
+					permissions: [...new Set([...cached.permissions, ...forwarded])]
+				});
 				return;
 			}
 			try {
@@ -492,32 +490,19 @@ const plugin = {
 					senderProvider: provider,
 					senderPlatformId: senderId
 				});
-				if (r.identityId == null) {
-					log.warn(`Identity not provisioned for ${provider}:${senderId} — blocking inbound message`);
-					return {
-						block: true,
-						blockReason: "Identity: identity not provisioned for this channel"
-					};
-				}
-				const cachedAfterFill = getCachedResolve(cacheKey);
-				if (!evaluateAgentChat(cachedAfterFill ? [...cachedAfterFill.permissions] : [...r.permissions, ...forwarded], { agentId }).allowed) return {
-					block: true,
-					blockReason: "Identity: chat not permitted for this sender"
-				};
-				log.info(`Identity resolved: ${senderId} → ${r.identityId} (${r.status})`);
+				log.debug(`Identity context cached for ${provider} (${r.status})`);
 			} catch (e) {
-				log.error(`Identity resolution failed for ${senderId}: ${e.message}`);
-				return {
-					block: true,
-					blockReason: "Identity: identity service unavailable — access denied (fail-closed)"
-				};
+				log.error(`Identity context resolution failed: ${e.message}`);
 			}
 		}, { priority: 100 });
-		const beforeToolCallStub = async (event, ctx) => {
-			if (UNCONDITIONAL_SELF_SERVICE_TOOLS.has(event.toolName)) return;
+		const beforeToolCall = async (event, ctx) => {
+			if (UNCONDITIONAL_SELF_SERVICE_TOOLS.has(event.toolName)) return { params: {
+				...event.params,
+				conversationId: resolveInboundConversation(ctx) ?? ""
+			} };
 			if (event.toolName === "who_is_this") {
-				const cacheKey = ctx.conversationId ?? (ctx.channelId && ctx.actingIdentityId ? `${ctx.channelId}:${ctx.actingIdentityId}` : null);
-				if (isSelfScopedWhoIsThis(event.toolArgs, cacheKey)) return;
+				const cacheKey = resolveToolConversation(ctx);
+				if (isSelfScopedWhoIsThis(event.params, cacheKey)) return;
 			}
 			let agentId = ctx.agentId;
 			if (!agentId) {
@@ -525,28 +510,32 @@ const plugin = {
 				if (fallback) agentId = fallback.agentId;
 			}
 			if (ctx.authMethod === "token" && ctx.tokenPermissions !== void 0) return applyGateMode(evaluateAgentExec(ctx.tokenPermissions, {
-				agentId,
+				agentId: agentId ?? "",
 				toolName: event.toolName,
-				toolArgs: event.toolArgs
+				toolArgs: event.params
 			}), resolveToolGatingMode(), event.toolName);
-			const cacheKey = ctx.conversationId ?? (ctx.channelId && ctx.actingIdentityId ? `${ctx.channelId}:${ctx.actingIdentityId}` : null);
+			const cacheKey = resolveToolConversation(ctx);
 			if (cacheKey) {
 				const cached = getCachedResolve(cacheKey);
 				if (cached && cached.permissions.length > 0) return applyGateMode(evaluateAgentExec([...cached.permissions], {
-					agentId,
+					agentId: agentId ?? "",
 					toolName: event.toolName,
-					toolArgs: event.toolArgs
+					toolArgs: event.params
 				}), resolveToolGatingMode(), event.toolName);
 			}
 			return applyGateMode(evaluateAgentExec([], {
-				agentId,
+				agentId: agentId ?? "",
 				toolName: event.toolName,
-				toolArgs: event.toolArgs
+				toolArgs: event.params
 			}), resolveToolGatingMode(), event.toolName);
 		};
-		api.on("before_tool_call", (...args) => beforeToolCallStub(args[0], args[1]), { priority: 100 });
+		api.on("before_tool_call", (...args) => beforeToolCall(args[0], args[1]), { priority: 100 });
 		api.on("before_agent_start", (...args) => {
 			const ctx = args[1];
+			if (ctx.trigger && ctx.trigger !== "user") {
+				lastInboundConversationId = void 0;
+				return Promise.resolve(void 0);
+			} else if (ctx.runId && lastInboundConversationId) conversationByRunId.set(ctx.runId, lastInboundConversationId);
 			const cached = findMostRelevantCacheEntry([
 				ctx.conversationId,
 				ctx.sessionKey,
@@ -565,6 +554,12 @@ const plugin = {
 				"verification flow."
 			].join(" ") });
 		}, { priority: 100 });
+		api.on("agent_end", (...args) => {
+			const ctx = args[1];
+			if (ctx.runId) conversationByRunId.delete(ctx.runId);
+			lastInboundConversationId = void 0;
+			return Promise.resolve();
+		}, { priority: 100 });
 		if (!cachedAgentContext) getAgentContext(client).then((c) => {
 			if (c) log.info(`Plugin context warmed: agent=${c.agentId} tenant=${c.tenantId}`);
 			else log.warn("Plugin context warm failed; will retry on next hook fire");
@@ -572,9 +567,14 @@ const plugin = {
 		log.info("Alfe Identity plugin activated");
 	},
 	deactivate(api) {
+		lifecycleGeneration += 1;
 		cachedClient = null;
 		cachedAgentContext = null;
 		inflightWhoami = null;
+		whoamiRetryAfter = 0;
+		resolveCache.clear();
+		conversationByRunId.clear();
+		lastInboundConversationId = void 0;
 		api.logger.info("Alfe Identity plugin deactivated");
 	}
 };