@alfe.ai/openclaw-identity 0.0.19 → 0.1.1

package/dist/plugin2.cjs

@@ -147,6 +147,71 @@ function setCachedResolve(key, value) {
 		expiresAt: Date.now() + RESOLVE_CACHE_TTL_MS
 	});
 }
+function invalidateCachedResolve(key) {
+	resolveCache.delete(key);
+}
+function findMostRelevantCacheEntry(probeKeys) {
+	for (const k of probeKeys) {
+		if (!k) continue;
+		const hit = getCachedResolve(k);
+		if (hit) return hit;
+	}
+	let mostRecent = null;
+	const now = Date.now();
+	for (const entry of resolveCache.values()) {
+		if (entry.expiresAt < now) continue;
+		if (!mostRecent || entry.expiresAt > mostRecent.expiresAt) mostRecent = entry;
+	}
+	return mostRecent;
+}
+const UNCONDITIONAL_SELF_SERVICE_TOOLS = new Set(["request_identity_verification", "confirm_identity_verification"]);
+function isSelfScopedWhoIsThis(toolArgs, cacheKey) {
+	if (!cacheKey) return false;
+	const cached = getCachedResolve(cacheKey);
+	if (!cached) return false;
+	const argProvider = toolArgs?.provider;
+	const argPlatformId = toolArgs?.platformId;
+	if (typeof argProvider !== "string" || typeof argPlatformId !== "string") return false;
+	return argProvider === cached.senderProvider && argPlatformId === cached.senderPlatformId;
+}
+/**
+* Resolve the inbound session identity from `conversationId`. Returns
+* `{ error }` on cache miss / missing param — never falls back to LLM-
+* supplied identity (that's the security property — see header).
+*/
+function resolveSessionIdentity(params) {
+	const conversationId = params.conversationId;
+	if (!conversationId) return {
+		ok: false,
+		error: "missing_conversation_id: pass conversationId from the inbound message metadata. The verify tools auto-bind to the inbound sender's identity — there is no manual override."
+	};
+	const cached = getCachedResolve(conversationId);
+	if (cached?.identityId == null) return {
+		ok: false,
+		error: "session_identity_unavailable: inbound identity cache miss for this conversationId. The plugin populates the cache from the message_received hook on every inbound message; if this fires the inbound channel either hasn't sent a message recently (>60s) or the daemon failed to plumb the hook context."
+	};
+	return {
+		ok: true,
+		identityId: cached.identityId,
+		senderProvider: cached.senderProvider,
+		senderPlatformId: cached.senderPlatformId
+	};
+}
+function resolveRequesterContext(params) {
+	const session = resolveSessionIdentity(params);
+	if (!session.ok) return { error: session.error };
+	return {
+		claimedIdentityId: session.identityId,
+		requestingIdentityId: session.identityId,
+		requestingProvider: session.senderProvider,
+		requestingPlatformId: session.senderPlatformId
+	};
+}
+function resolveClaimedIdentity(params) {
+	const session = resolveSessionIdentity(params);
+	if (!session.ok) return { error: session.error };
+	return { claimedIdentityId: session.identityId };
+}
 function ok(data) {
 	return {
 		content: [{
@@ -190,6 +255,27 @@ function getClient() {
 	});
 	return cachedClient;
 }
+let cachedAgentContext = null;
+let inflightWhoami = null;
+async function getAgentContext(client) {
+	if (cachedAgentContext) return cachedAgentContext;
+	if (inflightWhoami) return inflightWhoami;
+	inflightWhoami = (async () => {
+		try {
+			const r = await client.whoami();
+			cachedAgentContext = {
+				agentId: r.agentId,
+				tenantId: r.tenantId
+			};
+			return cachedAgentContext;
+		} catch {
+			return null;
+		} finally {
+			inflightWhoami = null;
+		}
+	})();
+	return inflightWhoami;
+}
 const plugin = {
 	id: "@alfe.ai/openclaw-identity",
 	name: "Alfe Identity",
@@ -330,12 +416,9 @@ const plugin = {
 			}),
 			defineTool({
 				name: "request_identity_verification",
-				description: "Send a verification phrase to verify the user controls an email or mobile endpoint. Use this when the user has just told you their email or mobile number and you want them to confirm it. Pass exactly one of `contactEmail` or `contactMobile`. The person must relay the phrase back via `confirm_identity_verification`.",
+				description: "Send a verification phrase to the inbound user's email or mobile to prove they own that contact endpoint. Use when the inbound user has just told you their email or mobile number and you want them to confirm it. PASS conversationId from the inbound message metadata — the verification ALWAYS binds to the inbound sender's identity (the WhatsApp / SMS / Discord / Google Chat / chat-web user who just spoke). There is no way to verify a different identity via this tool — identity is server-authoritative, resolved at session-start by the chat service. If the contact you supply already lives on another existing identity (e.g. the user's Clerk web account), the merge happens automatically on confirm. To add a new contact to an already-verified canonical identity (e.g. add a new email to a Clerk account), the user must be talking from a session that already resolves to that canonical identity (post-merge, or chat-web logged in as Clerk).",
 				parameters: _sinclair_typebox.Type.Object({
-					claimedIdentityId: _sinclair_typebox.Type.String({ description: "Identity being claimed" }),
-					requestingIdentityId: _sinclair_typebox.Type.String({ description: "Identity of the person making the claim" }),
-					requestingProvider: _sinclair_typebox.Type.String({ description: "Provider the requester is on (discord, slack, chat, etc.)" }),
-					requestingPlatformId: _sinclair_typebox.Type.String({ description: "Requester's provider-specific user ID" }),
+					conversationId: _sinclair_typebox.Type.String({ description: "Conversation ID from the inbound message — the daemon attaches this to every message. REQUIRED — there is no manual override path." }),
 					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'" }))
@@ -351,11 +434,13 @@ const plugin = {
 						channel: "mobile",
 						value: contactMobile
 					} : void 0;
+					const resolved = resolveRequesterContext(params);
+					if ("error" in resolved) return Promise.resolve({ error: resolved.error });
 					return client.requestIdentityVerification({
-						claimedIdentityId: params.claimedIdentityId,
-						requestingIdentityId: params.requestingIdentityId,
-						requestingProvider: params.requestingProvider,
-						requestingPlatformId: params.requestingPlatformId,
+						claimedIdentityId: resolved.claimedIdentityId,
+						requestingIdentityId: resolved.requestingIdentityId,
+						requestingProvider: resolved.requestingProvider,
+						requestingPlatformId: resolved.requestingPlatformId,
 						preferredChannel: params.preferredChannel,
 						contact
 					});
@@ -363,17 +448,26 @@ const plugin = {
 			}),
 			defineTool({
 				name: "confirm_identity_verification",
-				description: "Confirm a verification by submitting the phrase the user received. Returns `{ verified, identityId, action }` where `action` is 'merged' (the verified contact already lived on another identity, which is now the survivor) or 'contact_verified' (the contact was attached to the claimed identity).",
+				description: "Confirm a verification by submitting the phrase the inbound user received. Returns `{ verified, identityId, action }` where `action` is 'merged' (the verified contact already lived on another identity, which is now the survivor — the inbound identity merged into it) or 'contact_verified' (the contact was attached to the inbound identity). PASS the same conversationId you used on request_identity_verification — identity is auto-derived from it, no override.",
 				parameters: _sinclair_typebox.Type.Object({
-					claimedIdentityId: _sinclair_typebox.Type.String({ description: "Identity being claimed (matches request)" }),
+					conversationId: _sinclair_typebox.Type.String({ description: "Conversation ID from the inbound message — same one passed to request_identity_verification. REQUIRED." }),
 					verificationId: _sinclair_typebox.Type.String({ description: "Verification ID returned from request_identity_verification" }),
-					phrase: _sinclair_typebox.Type.String({ description: "Three-word phrase the person received via mobile or email" })
+					phrase: _sinclair_typebox.Type.String({ description: "Three-word phrase the inbound user received via mobile or email" })
 				}),
-				handler: (params) => client.confirmIdentityVerification({
-					claimedIdentityId: params.claimedIdentityId,
-					verificationId: params.verificationId,
-					phrase: params.phrase
-				})
+				handler: async (params) => {
+					const resolved = resolveClaimedIdentity(params);
+					if ("error" in resolved) return { error: resolved.error };
+					const result = await client.confirmIdentityVerification({
+						claimedIdentityId: resolved.claimedIdentityId,
+						verificationId: params.verificationId,
+						phrase: params.phrase
+					});
+					if (result.verified === true) {
+						const conversationId = params.conversationId;
+						invalidateCachedResolve(conversationId);
+					}
+					return result;
+				}
 			})
 		];
 		for (const tool of tools) api.registerTool(tool);
@@ -384,13 +478,17 @@ const plugin = {
 			const provider = ctx.channelId ?? "unknown";
 			const senderId = event.metadata?.UserId ?? event.from;
 			if (!senderId) return;
-			const agentId = ctx.agentId;
+			let agentId = ctx.agentId;
 			if (!agentId) {
-				log.warn(`message_received without ctx.agentId — fail-closed`);
-				return {
-					block: true,
-					blockReason: "Identity: agentId missing on message context"
-				};
+				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}`;
@@ -414,7 +512,9 @@ const plugin = {
 				setCachedResolve(cacheKey, {
 					identityId: r.identityId,
 					status: r.status,
-					permissions: [...r.permissions, ...forwarded]
+					permissions: [...r.permissions, ...forwarded],
+					senderProvider: provider,
+					senderPlatformId: senderId
 				});
 				if (r.identityId == null) {
 					log.warn(`Identity not provisioned for ${provider}:${senderId} — blocking inbound message`);
@@ -437,40 +537,68 @@ const plugin = {
 				};
 			}
 		}, { priority: 100 });
-		const beforeToolCallStub = (event, ctx) => {
-			if (ctx.authMethod === "token" && ctx.tokenPermissions !== void 0) {
-				const blocked = applyGateMode(evaluateAgentExec(ctx.tokenPermissions, {
-					agentId: ctx.agentId,
-					toolName: event.toolName,
-					toolArgs: event.toolArgs
-				}), resolveToolGatingMode(), event.toolName);
-				return Promise.resolve(blocked);
+		const beforeToolCallStub = async (event, ctx) => {
+			if (UNCONDITIONAL_SELF_SERVICE_TOOLS.has(event.toolName)) return;
+			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;
 			}
+			let agentId = ctx.agentId;
+			if (!agentId) {
+				const fallback = await getAgentContext(client);
+				if (fallback) agentId = fallback.agentId;
+			}
+			if (ctx.authMethod === "token" && ctx.tokenPermissions !== void 0) return applyGateMode(evaluateAgentExec(ctx.tokenPermissions, {
+				agentId,
+				toolName: event.toolName,
+				toolArgs: event.toolArgs
+			}), resolveToolGatingMode(), event.toolName);
 			const cacheKey = ctx.conversationId ?? (ctx.channelId && ctx.actingIdentityId ? `${ctx.channelId}:${ctx.actingIdentityId}` : null);
 			if (cacheKey) {
 				const cached = getCachedResolve(cacheKey);
-				if (cached && cached.permissions.length > 0) {
-					const blocked = applyGateMode(evaluateAgentExec([...cached.permissions], {
-						agentId: ctx.agentId,
-						toolName: event.toolName,
-						toolArgs: event.toolArgs
-					}), resolveToolGatingMode(), event.toolName);
-					return Promise.resolve(blocked);
-				}
+				if (cached && cached.permissions.length > 0) return applyGateMode(evaluateAgentExec([...cached.permissions], {
+					agentId,
+					toolName: event.toolName,
+					toolArgs: event.toolArgs
+				}), resolveToolGatingMode(), event.toolName);
 			}
-			const fallback = evaluateAgentExec([], {
-				agentId: ctx.agentId,
+			return applyGateMode(evaluateAgentExec([], {
+				agentId,
 				toolName: event.toolName,
 				toolArgs: event.toolArgs
-			});
-			const mode = resolveToolGatingMode();
-			return Promise.resolve(applyGateMode(fallback, mode, event.toolName));
+			}), resolveToolGatingMode(), event.toolName);
 		};
 		api.on("before_tool_call", (...args) => beforeToolCallStub(args[0], args[1]), { priority: 100 });
+		api.on("before_agent_start", (...args) => {
+			const ctx = args[1];
+			const cached = findMostRelevantCacheEntry([
+				ctx.conversationId,
+				ctx.sessionKey,
+				ctx.sessionId,
+				ctx.channelId
+			]);
+			if (!cached) return Promise.resolve(void 0);
+			if (cached.status !== "anonymous" && cached.status !== "partial") return Promise.resolve(void 0);
+			return Promise.resolve({ prependSystemContext: [
+				"Identity status: the user has not yet verified their identity.",
+				"Tools available now: request_identity_verification,",
+				"confirm_identity_verification, who_is_this.",
+				"All other tools are restricted until the user verifies.",
+				"If the user asks for a capability you cannot perform, briefly",
+				"explain that they need to verify first and offer to start the",
+				"verification flow."
+			].join(" ") });
+		}, { 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");
+		});
 		log.info("Alfe Identity plugin activated");
 	},
 	deactivate(api) {
 		cachedClient = null;
+		cachedAgentContext = null;
+		inflightWhoami = null;
 		api.logger.info("Alfe Identity plugin deactivated");
 	}
 };

package/dist/plugin2.js

@@ -147,6 +147,71 @@ function setCachedResolve(key, value) {
 		expiresAt: Date.now() + RESOLVE_CACHE_TTL_MS
 	});
 }
+function invalidateCachedResolve(key) {
+	resolveCache.delete(key);
+}
+function findMostRelevantCacheEntry(probeKeys) {
+	for (const k of probeKeys) {
+		if (!k) continue;
+		const hit = getCachedResolve(k);
+		if (hit) return hit;
+	}
+	let mostRecent = null;
+	const now = Date.now();
+	for (const entry of resolveCache.values()) {
+		if (entry.expiresAt < now) continue;
+		if (!mostRecent || entry.expiresAt > mostRecent.expiresAt) mostRecent = entry;
+	}
+	return mostRecent;
+}
+const UNCONDITIONAL_SELF_SERVICE_TOOLS = new Set(["request_identity_verification", "confirm_identity_verification"]);
+function isSelfScopedWhoIsThis(toolArgs, cacheKey) {
+	if (!cacheKey) return false;
+	const cached = getCachedResolve(cacheKey);
+	if (!cached) return false;
+	const argProvider = toolArgs?.provider;
+	const argPlatformId = toolArgs?.platformId;
+	if (typeof argProvider !== "string" || typeof argPlatformId !== "string") return false;
+	return argProvider === cached.senderProvider && argPlatformId === cached.senderPlatformId;
+}
+/**
+* Resolve the inbound session identity from `conversationId`. Returns
+* `{ error }` on cache miss / missing param — never falls back to LLM-
+* supplied identity (that's the security property — see header).
+*/
+function resolveSessionIdentity(params) {
+	const conversationId = params.conversationId;
+	if (!conversationId) return {
+		ok: false,
+		error: "missing_conversation_id: pass conversationId from the inbound message metadata. The verify tools auto-bind to the inbound sender's identity — there is no manual override."
+	};
+	const cached = getCachedResolve(conversationId);
+	if (cached?.identityId == null) return {
+		ok: false,
+		error: "session_identity_unavailable: inbound identity cache miss for this conversationId. The plugin populates the cache from the message_received hook on every inbound message; if this fires the inbound channel either hasn't sent a message recently (>60s) or the daemon failed to plumb the hook context."
+	};
+	return {
+		ok: true,
+		identityId: cached.identityId,
+		senderProvider: cached.senderProvider,
+		senderPlatformId: cached.senderPlatformId
+	};
+}
+function resolveRequesterContext(params) {
+	const session = resolveSessionIdentity(params);
+	if (!session.ok) return { error: session.error };
+	return {
+		claimedIdentityId: session.identityId,
+		requestingIdentityId: session.identityId,
+		requestingProvider: session.senderProvider,
+		requestingPlatformId: session.senderPlatformId
+	};
+}
+function resolveClaimedIdentity(params) {
+	const session = resolveSessionIdentity(params);
+	if (!session.ok) return { error: session.error };
+	return { claimedIdentityId: session.identityId };
+}
 function ok(data) {
 	return {
 		content: [{
@@ -190,6 +255,27 @@ function getClient() {
 	});
 	return cachedClient;
 }
+let cachedAgentContext = null;
+let inflightWhoami = null;
+async function getAgentContext(client) {
+	if (cachedAgentContext) return cachedAgentContext;
+	if (inflightWhoami) return inflightWhoami;
+	inflightWhoami = (async () => {
+		try {
+			const r = await client.whoami();
+			cachedAgentContext = {
+				agentId: r.agentId,
+				tenantId: r.tenantId
+			};
+			return cachedAgentContext;
+		} catch {
+			return null;
+		} finally {
+			inflightWhoami = null;
+		}
+	})();
+	return inflightWhoami;
+}
 const plugin = {
 	id: "@alfe.ai/openclaw-identity",
 	name: "Alfe Identity",
@@ -330,12 +416,9 @@ const plugin = {
 			}),
 			defineTool({
 				name: "request_identity_verification",
-				description: "Send a verification phrase to verify the user controls an email or mobile endpoint. Use this when the user has just told you their email or mobile number and you want them to confirm it. Pass exactly one of `contactEmail` or `contactMobile`. The person must relay the phrase back via `confirm_identity_verification`.",
+				description: "Send a verification phrase to the inbound user's email or mobile to prove they own that contact endpoint. Use when the inbound user has just told you their email or mobile number and you want them to confirm it. PASS conversationId from the inbound message metadata — the verification ALWAYS binds to the inbound sender's identity (the WhatsApp / SMS / Discord / Google Chat / chat-web user who just spoke). There is no way to verify a different identity via this tool — identity is server-authoritative, resolved at session-start by the chat service. If the contact you supply already lives on another existing identity (e.g. the user's Clerk web account), the merge happens automatically on confirm. To add a new contact to an already-verified canonical identity (e.g. add a new email to a Clerk account), the user must be talking from a session that already resolves to that canonical identity (post-merge, or chat-web logged in as Clerk).",
 				parameters: Type.Object({
-					claimedIdentityId: Type.String({ description: "Identity being claimed" }),
-					requestingIdentityId: Type.String({ description: "Identity of the person making the claim" }),
-					requestingProvider: Type.String({ description: "Provider the requester is on (discord, slack, chat, etc.)" }),
-					requestingPlatformId: Type.String({ description: "Requester's provider-specific user ID" }),
+					conversationId: Type.String({ description: "Conversation ID from the inbound message — the daemon attaches this to every message. REQUIRED — there is no manual override path." }),
 					contactEmail: Type.Optional(Type.String({ description: "Email to verify (mutually exclusive with contactMobile)" })),
 					contactMobile: Type.Optional(Type.String({ description: "E.164 mobile to verify (mutually exclusive with contactEmail)" })),
 					preferredChannel: Type.Optional(Type.String({ description: "When neither contactEmail nor contactMobile is provided, pick which existing verified contact to deliver to: 'mobile' or 'email'" }))
@@ -351,11 +434,13 @@ const plugin = {
 						channel: "mobile",
 						value: contactMobile
 					} : void 0;
+					const resolved = resolveRequesterContext(params);
+					if ("error" in resolved) return Promise.resolve({ error: resolved.error });
 					return client.requestIdentityVerification({
-						claimedIdentityId: params.claimedIdentityId,
-						requestingIdentityId: params.requestingIdentityId,
-						requestingProvider: params.requestingProvider,
-						requestingPlatformId: params.requestingPlatformId,
+						claimedIdentityId: resolved.claimedIdentityId,
+						requestingIdentityId: resolved.requestingIdentityId,
+						requestingProvider: resolved.requestingProvider,
+						requestingPlatformId: resolved.requestingPlatformId,
 						preferredChannel: params.preferredChannel,
 						contact
 					});
@@ -363,17 +448,26 @@ const plugin = {
 			}),
 			defineTool({
 				name: "confirm_identity_verification",
-				description: "Confirm a verification by submitting the phrase the user received. Returns `{ verified, identityId, action }` where `action` is 'merged' (the verified contact already lived on another identity, which is now the survivor) or 'contact_verified' (the contact was attached to the claimed identity).",
+				description: "Confirm a verification by submitting the phrase the inbound user received. Returns `{ verified, identityId, action }` where `action` is 'merged' (the verified contact already lived on another identity, which is now the survivor — the inbound identity merged into it) or 'contact_verified' (the contact was attached to the inbound identity). PASS the same conversationId you used on request_identity_verification — identity is auto-derived from it, no override.",
 				parameters: Type.Object({
-					claimedIdentityId: Type.String({ description: "Identity being claimed (matches request)" }),
+					conversationId: Type.String({ description: "Conversation ID from the inbound message — same one passed to request_identity_verification. REQUIRED." }),
 					verificationId: Type.String({ description: "Verification ID returned from request_identity_verification" }),
-					phrase: Type.String({ description: "Three-word phrase the person received via mobile or email" })
+					phrase: Type.String({ description: "Three-word phrase the inbound user received via mobile or email" })
 				}),
-				handler: (params) => client.confirmIdentityVerification({
-					claimedIdentityId: params.claimedIdentityId,
-					verificationId: params.verificationId,
-					phrase: params.phrase
-				})
+				handler: async (params) => {
+					const resolved = resolveClaimedIdentity(params);
+					if ("error" in resolved) return { error: resolved.error };
+					const result = await client.confirmIdentityVerification({
+						claimedIdentityId: resolved.claimedIdentityId,
+						verificationId: params.verificationId,
+						phrase: params.phrase
+					});
+					if (result.verified === true) {
+						const conversationId = params.conversationId;
+						invalidateCachedResolve(conversationId);
+					}
+					return result;
+				}
 			})
 		];
 		for (const tool of tools) api.registerTool(tool);
@@ -384,13 +478,17 @@ const plugin = {
 			const provider = ctx.channelId ?? "unknown";
 			const senderId = event.metadata?.UserId ?? event.from;
 			if (!senderId) return;
-			const agentId = ctx.agentId;
+			let agentId = ctx.agentId;
 			if (!agentId) {
-				log.warn(`message_received without ctx.agentId — fail-closed`);
-				return {
-					block: true,
-					blockReason: "Identity: agentId missing on message context"
-				};
+				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}`;
@@ -414,7 +512,9 @@ const plugin = {
 				setCachedResolve(cacheKey, {
 					identityId: r.identityId,
 					status: r.status,
-					permissions: [...r.permissions, ...forwarded]
+					permissions: [...r.permissions, ...forwarded],
+					senderProvider: provider,
+					senderPlatformId: senderId
 				});
 				if (r.identityId == null) {
 					log.warn(`Identity not provisioned for ${provider}:${senderId} — blocking inbound message`);
@@ -437,40 +537,68 @@ const plugin = {
 				};
 			}
 		}, { priority: 100 });
-		const beforeToolCallStub = (event, ctx) => {
-			if (ctx.authMethod === "token" && ctx.tokenPermissions !== void 0) {
-				const blocked = applyGateMode(evaluateAgentExec(ctx.tokenPermissions, {
-					agentId: ctx.agentId,
-					toolName: event.toolName,
-					toolArgs: event.toolArgs
-				}), resolveToolGatingMode(), event.toolName);
-				return Promise.resolve(blocked);
+		const beforeToolCallStub = async (event, ctx) => {
+			if (UNCONDITIONAL_SELF_SERVICE_TOOLS.has(event.toolName)) return;
+			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;
 			}
+			let agentId = ctx.agentId;
+			if (!agentId) {
+				const fallback = await getAgentContext(client);
+				if (fallback) agentId = fallback.agentId;
+			}
+			if (ctx.authMethod === "token" && ctx.tokenPermissions !== void 0) return applyGateMode(evaluateAgentExec(ctx.tokenPermissions, {
+				agentId,
+				toolName: event.toolName,
+				toolArgs: event.toolArgs
+			}), resolveToolGatingMode(), event.toolName);
 			const cacheKey = ctx.conversationId ?? (ctx.channelId && ctx.actingIdentityId ? `${ctx.channelId}:${ctx.actingIdentityId}` : null);
 			if (cacheKey) {
 				const cached = getCachedResolve(cacheKey);
-				if (cached && cached.permissions.length > 0) {
-					const blocked = applyGateMode(evaluateAgentExec([...cached.permissions], {
-						agentId: ctx.agentId,
-						toolName: event.toolName,
-						toolArgs: event.toolArgs
-					}), resolveToolGatingMode(), event.toolName);
-					return Promise.resolve(blocked);
-				}
+				if (cached && cached.permissions.length > 0) return applyGateMode(evaluateAgentExec([...cached.permissions], {
+					agentId,
+					toolName: event.toolName,
+					toolArgs: event.toolArgs
+				}), resolveToolGatingMode(), event.toolName);
 			}
-			const fallback = evaluateAgentExec([], {
-				agentId: ctx.agentId,
+			return applyGateMode(evaluateAgentExec([], {
+				agentId,
 				toolName: event.toolName,
 				toolArgs: event.toolArgs
-			});
-			const mode = resolveToolGatingMode();
-			return Promise.resolve(applyGateMode(fallback, mode, event.toolName));
+			}), resolveToolGatingMode(), event.toolName);
 		};
 		api.on("before_tool_call", (...args) => beforeToolCallStub(args[0], args[1]), { priority: 100 });
+		api.on("before_agent_start", (...args) => {
+			const ctx = args[1];
+			const cached = findMostRelevantCacheEntry([
+				ctx.conversationId,
+				ctx.sessionKey,
+				ctx.sessionId,
+				ctx.channelId
+			]);
+			if (!cached) return Promise.resolve(void 0);
+			if (cached.status !== "anonymous" && cached.status !== "partial") return Promise.resolve(void 0);
+			return Promise.resolve({ prependSystemContext: [
+				"Identity status: the user has not yet verified their identity.",
+				"Tools available now: request_identity_verification,",
+				"confirm_identity_verification, who_is_this.",
+				"All other tools are restricted until the user verifies.",
+				"If the user asks for a capability you cannot perform, briefly",
+				"explain that they need to verify first and offer to start the",
+				"verification flow."
+			].join(" ") });
+		}, { 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");
+		});
 		log.info("Alfe Identity plugin activated");
 	},
 	deactivate(api) {
 		cachedClient = null;
+		cachedAgentContext = null;
+		inflightWhoami = null;
 		api.logger.info("Alfe Identity plugin deactivated");
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/openclaw-identity",
-  "version": "0.0.19",
+  "version": "0.1.1",
   "description": "OpenClaw identity plugin — identity resolution, access gating, permission enforcement",
   "type": "module",
   "main": "./dist/plugin.js",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@auriclabs/roles": "0.1.1",
     "@sinclair/typebox": "^0.34.48",
-    "@alfe.ai/agent-api-client": "0.1.2",
+    "@alfe.ai/agent-api-client": "0.1.3",
     "@alfe.ai/config": "0.0.8"
   },
   "license": "UNLICENSED",