@alfe.ai/openclaw-identity 0.1.26 → 0.1.28

package/dist/plugin2.cjs

@@ -1,5 +1,6 @@
 let _alfe_ai_config = require("@alfe.ai/config");
 let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
+let _alfe_ai_openclaw_plugin_kit = require("@alfe.ai/openclaw-plugin-kit");
 let _sinclair_typebox = require("@sinclair/typebox");
 let node_module = require("node:module");
 let _auriclabs_roles = require("@auriclabs/roles");
@@ -12,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(...)`
@@ -22,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
@@ -73,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
@@ -131,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
@@ -159,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;
@@ -176,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."
 	};
@@ -217,39 +201,6 @@ function resolveClaimedIdentity(params) {
 	if (!session.ok) return { error: session.error };
 	return { claimedIdentityId: session.identityId };
 }
-function ok(data) {
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify(data)
-		}],
-		details: data
-	};
-}
-function errResult(message) {
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify({ error: message })
-		}],
-		details: { error: message }
-	};
-}
-function defineTool(def) {
-	return {
-		name: def.name,
-		description: def.description,
-		label: def.name,
-		parameters: def.parameters,
-		execute: async (_toolCallId, params) => {
-			try {
-				return ok(await def.handler(params));
-			} catch (e) {
-				return errResult(e.message);
-			}
-		}
-	};
-}
 let cachedClient = null;
 function getClient() {
 	if (cachedClient) return cachedClient;
@@ -262,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" });
@@ -295,7 +271,7 @@ const plugin = {
 			return typeof v === "function" ? v.bind(c) : v;
 		} });
 		const tools = [
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "who_is_this",
 				description: "Look up an identity by provider + platformId — returns full identity context (profile, contacts, platforms, notes, tags, recent changelog). Returns `{found:false}` for unknown senders. This tool DOES NOT create new identities.",
 				parameters: _sinclair_typebox.Type.Object({
@@ -311,101 +287,98 @@ const plugin = {
 					return client.getIdentityContext(result.identityId);
 				}
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				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,
 					status: params.status
 				})
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "merge_identities",
 				description: "Merge two identity records — transfers contacts, platforms, notes, tags, aliases to the survivor. Hard-move, transactional.",
 				parameters: _sinclair_typebox.Type.Object({
 					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 })
 			}),
-			defineTool({
+			(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)
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "add_identity_note",
 				description: "Add an observation or note about an identity. Use category 'context' for unverified affiliation claims (self-reported title/company) — those do NOT belong on the identity row directly.",
 				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
 				})
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "tag_identity",
 				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
 				})
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "get_identity_changelog",
 				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 })
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "rollback_identity",
 				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 })
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "update_identity",
 				description: "Update display-shape fields on a CONTACT/person you know (an identity): name / avatarUrl / timezone / locale. NOT for your own agent profile — to set YOUR OWN profile picture use `set_avatar` or `generate_avatar`, never this tool with identityId:'agent'. Contact mutations go through the verify flow — this tool will NOT accept email or mobile. Title and company live on org membership rows, not here.",
 				parameters: _sinclair_typebox.Type.Object({
@@ -417,23 +390,26 @@ 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);
 				}
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "request_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. The verification ALWAYS binds to the inbound sender's identity (the WhatsApp / SMS / Discord / Google Chat / chat-web user who just spoke) — identity is server-authoritative, auto-derived from the current inbound session. There is no way to verify a different identity via this tool. 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({
 					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
@@ -442,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,
@@ -453,7 +432,7 @@ const plugin = {
 					});
 				}
 			}),
-			defineTool({
+			(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
 				name: "confirm_identity_verification",
 				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). Identity is server-authoritative, auto-derived from the current inbound session — no override available.",
 				parameters: _sinclair_typebox.Type.Object({
@@ -463,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;
 				}
@@ -482,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 {
@@ -524,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) {
@@ -557,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,
@@ -597,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");
@@ -604,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");
 	}
 };

package/dist/plugin2.d.cts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.cjs";
+export { plugin as default };

package/dist/plugin2.d.ts

@@ -0,0 +1,2 @@
+import { t as plugin } from "./plugin.js";
+export { plugin as default };