@alfe.ai/openclaw-identity 0.0.9 → 0.0.11

package/dist/index.cjs

@@ -1,2 +1,27 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
 const require_plugin = require("./plugin.cjs");
-module.exports = require_plugin;
+//#region src/runtime-contract.ts
+/**
+* Build the gate context object used by sift evaluation. This is the
+* round-6 "strict namespacing" shape — `args` is a top-level field, not
+* spread, so an attacker-controlled `tool` field inside `toolArgs` cannot
+* override the gate's `tool` value.
+*
+* Stage E's gate calls:
+*   ability.has(
+*     { subject: "agent", action: "exec", scope: `agent:${ctx.agentId}` },
+*     buildGateContext(event),
+*   );
+*/
+function buildGateContext(event) {
+	return {
+		tool: event.toolName,
+		args: event.toolArgs
+	};
+}
+//#endregion
+exports.buildGateContext = buildGateContext;
+exports.default = require_plugin;

package/dist/index.d.cts

@@ -1,2 +1,147 @@
 import plugin from "./plugin.cjs";
-export { plugin as default };
+
+//#region src/policy-cache.d.ts
+
+type IdentityFailureMode = "open" | "closed" | "permissive";
+/**
+ * Evaluate whether a tool call should be blocked based on the cached policy
+ * and failure mode.
+ */
+
+//#endregion
+//#region src/runtime-contract.d.ts
+
+/**
+ * The tool the agent is about to call.
+ *
+ * `toolName` SHOULD be namespaced (e.g., `gmail:send_email`, `calendar:create_event`)
+ * so sift `$glob: "gmail:*"` conditions work and namespace collisions are
+ * impossible. Plugins that don't yet namespace their tools will be migrated
+ * during Stage I rollout.
+ */
+interface ToolCallEvent {
+  /** Namespaced tool name, e.g. "gmail:send_email". */
+  readonly toolName: string;
+  /** Arbitrary argument bag passed to the tool's `execute` function. */
+  readonly toolArgs: Record<string, unknown>;
+}
+/**
+ * What initiated the tool call. Three buckets:
+ *   - "user_message"  — a human (or another agent) sent a message that the
+ *                       agent is now responding to. `actingIdentityId` is the
+ *                       identity of the message sender.
+ *   - "scheduled"     — autonomous run (cron/trigger). `actingIdentityId` is
+ *                       the agent's own identity (`idn_agt_*`).
+ *   - "tool_chain"    — a follow-up tool call from a previous tool's result
+ *                       within the same agent invocation. `actingIdentityId`
+ *                       is whatever resolved at the start of the chain.
+ *   - "api"           — a tool call invoked via the agent's REST API by an
+ *                       external caller authenticated with an `alfe_*` token.
+ *                       `actingIdentityId` may be undefined; `tokenPermissions`
+ *                       carries the gate-relevant `Permission[]`.
+ */
+type ToolCallTrigger = "user_message" | "scheduled" | "tool_chain" | "api";
+/**
+ * How the caller authenticated.
+ *   - "jwt"   — Clerk JWT path (human user). `actingIdentityId` resolved from
+ *               the JWT's `sub` via the identity service.
+ *   - "agent" — autonomous agent (no external caller). `actingIdentityId` is
+ *               the agent's own `idn_agt_*`.
+ *   - "token" — `alfe_*` API token. `tokenPermissions` is set; the gate uses
+ *               the token's permissions directly without an identity lookup.
+ *   - "none"  — no auth context (fail-closed in prod via IdentityFailureMode).
+ */
+type ToolCallAuthMethod = "jwt" | "agent" | "token" | "none";
+/**
+ * Permission shape the gate consumes. This is a structural duplicate of
+ * `Permission` from `@auriclabs/roles@0.1.1` so the openclaw plugin doesn't
+ * have to depend on the library directly (the library is consumed inside the
+ * gate itself in Stage E). Keep the two shapes in lockstep.
+ */
+interface RuntimePermission {
+  readonly subject: string;
+  readonly action: string;
+  readonly scope?: string;
+  /**
+   * Round 7 storage shape: sift conditions stored per-permission. The runtime
+   * gate evaluates the condition against `{ tool, args }` (round 6 strict
+   * namespacing). Glob source travels under `$glob`; the compiled regex
+   * travels under `_glob_re` with a `_glob_v` version marker (round 7 audit
+   * 3.6 storage shape).
+   */
+  readonly conditions?: Record<string, unknown>;
+  readonly type?: "can" | "cannot";
+}
+/**
+ * Calling context for the tool call. Populated by the OpenClaw daemon at
+ * dispatch time.
+ */
+interface ToolCallContext {
+  /** Required: the tenant (`org_*`) that owns the agent. */
+  readonly tenantId: string;
+  /** Required: the agent (`agt_*`) that is about to call the tool. */
+  readonly agentId: string;
+  /** Required: how the caller authenticated. */
+  readonly authMethod: ToolCallAuthMethod;
+  /** Required: what initiated the call. */
+  readonly trigger: ToolCallTrigger;
+  /**
+   * The identity (`idn_*`) the agent is acting on behalf of. Resolution
+   * order:
+   *   1. If `trigger === "user_message"`: the chat-context identity (sender).
+   *   2. If `trigger === "scheduled"` or `trigger === "tool_chain"`: the
+   *      agent's own `idn_agt_*` (autonomous default).
+   *   3. If `authMethod === "token"`: optional; the token-path gate uses
+   *      `tokenPermissions` and may skip identity resolution entirely.
+   *   4. Otherwise: undefined; the per-agent `IdentityFailureMode` decides
+   *      whether to allow / deny / log-and-continue.
+   */
+  readonly actingIdentityId?: string;
+  /**
+   * Round 5 / Round 7: `alfe_*` tokens carry their own flat `Permission[]`
+   * directly. When `authMethod === "token"`, the daemon populates this with
+   * `TokenEntity.permissions` (post Stage B.0.7 atomic flip — pre-flip the
+   * authorizer derives this from `record.scopes` via `scopesToPermissions`).
+   * The Stage E gate evaluates these permissions directly at scope
+   * `agent:<agentId>` without an identity lookup.
+   */
+  readonly tokenPermissions?: readonly RuntimePermission[];
+  /** Optional: chat conversation id (when trigger is `user_message`). */
+  readonly conversationId?: string;
+  /** Optional: channel id (when trigger is `user_message`). */
+  readonly channelId?: string;
+}
+/**
+ * Return value of the `before_tool_call` hook.
+ *   - `undefined` — allow.
+ *   - `{ block: true, blockReason: string }` — deny with reason surfaced to
+ *     the agent's response (Stage E behaviour).
+ */
+type ToolCallHookResult = undefined | {
+  block: true;
+  blockReason: string;
+};
+/**
+ * Strongly-typed `before_tool_call` hook signature. The plugin's stub uses
+ * this signature today; Stage E swaps the stub for the real `agent:exec` +
+ * sift gate against `@auriclabs/roles`.
+ */
+type BeforeToolCallHook = (event: ToolCallEvent, ctx: ToolCallContext) => Promise<ToolCallHookResult>;
+/**
+ * Build the gate context object used by sift evaluation. This is the
+ * round-6 "strict namespacing" shape — `args` is a top-level field, not
+ * spread, so an attacker-controlled `tool` field inside `toolArgs` cannot
+ * override the gate's `tool` value.
+ *
+ * Stage E's gate calls:
+ *   ability.has(
+ *     { subject: "agent", action: "exec", scope: `agent:${ctx.agentId}` },
+ *     buildGateContext(event),
+ *   );
+ */
+declare function buildGateContext(event: ToolCallEvent): {
+  tool: string;
+  args: Record<string, unknown>;
+};
+//#endregion
+export { type BeforeToolCallHook, type IdentityFailureMode, type RuntimePermission, type ToolCallAuthMethod, type ToolCallContext, type ToolCallEvent, type ToolCallHookResult, type ToolCallTrigger, buildGateContext, plugin as default };

package/dist/index.d.ts

@@ -1,2 +1,147 @@
 import plugin from "./plugin.js";
-export { plugin as default };
+
+//#region src/policy-cache.d.ts
+
+type IdentityFailureMode = "open" | "closed" | "permissive";
+/**
+ * Evaluate whether a tool call should be blocked based on the cached policy
+ * and failure mode.
+ */
+
+//#endregion
+//#region src/runtime-contract.d.ts
+
+/**
+ * The tool the agent is about to call.
+ *
+ * `toolName` SHOULD be namespaced (e.g., `gmail:send_email`, `calendar:create_event`)
+ * so sift `$glob: "gmail:*"` conditions work and namespace collisions are
+ * impossible. Plugins that don't yet namespace their tools will be migrated
+ * during Stage I rollout.
+ */
+interface ToolCallEvent {
+  /** Namespaced tool name, e.g. "gmail:send_email". */
+  readonly toolName: string;
+  /** Arbitrary argument bag passed to the tool's `execute` function. */
+  readonly toolArgs: Record<string, unknown>;
+}
+/**
+ * What initiated the tool call. Three buckets:
+ *   - "user_message"  — a human (or another agent) sent a message that the
+ *                       agent is now responding to. `actingIdentityId` is the
+ *                       identity of the message sender.
+ *   - "scheduled"     — autonomous run (cron/trigger). `actingIdentityId` is
+ *                       the agent's own identity (`idn_agt_*`).
+ *   - "tool_chain"    — a follow-up tool call from a previous tool's result
+ *                       within the same agent invocation. `actingIdentityId`
+ *                       is whatever resolved at the start of the chain.
+ *   - "api"           — a tool call invoked via the agent's REST API by an
+ *                       external caller authenticated with an `alfe_*` token.
+ *                       `actingIdentityId` may be undefined; `tokenPermissions`
+ *                       carries the gate-relevant `Permission[]`.
+ */
+type ToolCallTrigger = "user_message" | "scheduled" | "tool_chain" | "api";
+/**
+ * How the caller authenticated.
+ *   - "jwt"   — Clerk JWT path (human user). `actingIdentityId` resolved from
+ *               the JWT's `sub` via the identity service.
+ *   - "agent" — autonomous agent (no external caller). `actingIdentityId` is
+ *               the agent's own `idn_agt_*`.
+ *   - "token" — `alfe_*` API token. `tokenPermissions` is set; the gate uses
+ *               the token's permissions directly without an identity lookup.
+ *   - "none"  — no auth context (fail-closed in prod via IdentityFailureMode).
+ */
+type ToolCallAuthMethod = "jwt" | "agent" | "token" | "none";
+/**
+ * Permission shape the gate consumes. This is a structural duplicate of
+ * `Permission` from `@auriclabs/roles@0.1.1` so the openclaw plugin doesn't
+ * have to depend on the library directly (the library is consumed inside the
+ * gate itself in Stage E). Keep the two shapes in lockstep.
+ */
+interface RuntimePermission {
+  readonly subject: string;
+  readonly action: string;
+  readonly scope?: string;
+  /**
+   * Round 7 storage shape: sift conditions stored per-permission. The runtime
+   * gate evaluates the condition against `{ tool, args }` (round 6 strict
+   * namespacing). Glob source travels under `$glob`; the compiled regex
+   * travels under `_glob_re` with a `_glob_v` version marker (round 7 audit
+   * 3.6 storage shape).
+   */
+  readonly conditions?: Record<string, unknown>;
+  readonly type?: "can" | "cannot";
+}
+/**
+ * Calling context for the tool call. Populated by the OpenClaw daemon at
+ * dispatch time.
+ */
+interface ToolCallContext {
+  /** Required: the tenant (`org_*`) that owns the agent. */
+  readonly tenantId: string;
+  /** Required: the agent (`agt_*`) that is about to call the tool. */
+  readonly agentId: string;
+  /** Required: how the caller authenticated. */
+  readonly authMethod: ToolCallAuthMethod;
+  /** Required: what initiated the call. */
+  readonly trigger: ToolCallTrigger;
+  /**
+   * The identity (`idn_*`) the agent is acting on behalf of. Resolution
+   * order:
+   *   1. If `trigger === "user_message"`: the chat-context identity (sender).
+   *   2. If `trigger === "scheduled"` or `trigger === "tool_chain"`: the
+   *      agent's own `idn_agt_*` (autonomous default).
+   *   3. If `authMethod === "token"`: optional; the token-path gate uses
+   *      `tokenPermissions` and may skip identity resolution entirely.
+   *   4. Otherwise: undefined; the per-agent `IdentityFailureMode` decides
+   *      whether to allow / deny / log-and-continue.
+   */
+  readonly actingIdentityId?: string;
+  /**
+   * Round 5 / Round 7: `alfe_*` tokens carry their own flat `Permission[]`
+   * directly. When `authMethod === "token"`, the daemon populates this with
+   * `TokenEntity.permissions` (post Stage B.0.7 atomic flip — pre-flip the
+   * authorizer derives this from `record.scopes` via `scopesToPermissions`).
+   * The Stage E gate evaluates these permissions directly at scope
+   * `agent:<agentId>` without an identity lookup.
+   */
+  readonly tokenPermissions?: readonly RuntimePermission[];
+  /** Optional: chat conversation id (when trigger is `user_message`). */
+  readonly conversationId?: string;
+  /** Optional: channel id (when trigger is `user_message`). */
+  readonly channelId?: string;
+}
+/**
+ * Return value of the `before_tool_call` hook.
+ *   - `undefined` — allow.
+ *   - `{ block: true, blockReason: string }` — deny with reason surfaced to
+ *     the agent's response (Stage E behaviour).
+ */
+type ToolCallHookResult = undefined | {
+  block: true;
+  blockReason: string;
+};
+/**
+ * Strongly-typed `before_tool_call` hook signature. The plugin's stub uses
+ * this signature today; Stage E swaps the stub for the real `agent:exec` +
+ * sift gate against `@auriclabs/roles`.
+ */
+type BeforeToolCallHook = (event: ToolCallEvent, ctx: ToolCallContext) => Promise<ToolCallHookResult>;
+/**
+ * Build the gate context object used by sift evaluation. This is the
+ * round-6 "strict namespacing" shape — `args` is a top-level field, not
+ * spread, so an attacker-controlled `tool` field inside `toolArgs` cannot
+ * override the gate's `tool` value.
+ *
+ * Stage E's gate calls:
+ *   ability.has(
+ *     { subject: "agent", action: "exec", scope: `agent:${ctx.agentId}` },
+ *     buildGateContext(event),
+ *   );
+ */
+declare function buildGateContext(event: ToolCallEvent): {
+  tool: string;
+  args: Record<string, unknown>;
+};
+//#endregion
+export { type BeforeToolCallHook, type IdentityFailureMode, type RuntimePermission, type ToolCallAuthMethod, type ToolCallContext, type ToolCallEvent, type ToolCallHookResult, type ToolCallTrigger, buildGateContext, plugin as default };

package/dist/index.js

@@ -1,2 +1,22 @@
 import plugin from "./plugin.js";
-export { plugin as default };
+//#region src/runtime-contract.ts
+/**
+* Build the gate context object used by sift evaluation. This is the
+* round-6 "strict namespacing" shape — `args` is a top-level field, not
+* spread, so an attacker-controlled `tool` field inside `toolArgs` cannot
+* override the gate's `tool` value.
+*
+* Stage E's gate calls:
+*   ability.has(
+*     { subject: "agent", action: "exec", scope: `agent:${ctx.agentId}` },
+*     buildGateContext(event),
+*   );
+*/
+function buildGateContext(event) {
+	return {
+		tool: event.toolName,
+		args: event.toolArgs
+	};
+}
+//#endregion
+export { buildGateContext, plugin as default };

package/dist/plugin.cjs

@@ -5,33 +5,36 @@ let _sinclair_typebox = require("@sinclair/typebox");
 /**
 * @alfe.ai/openclaw-identity — OpenClaw native plugin
 *
-* HTTP-based identity resolution, permission enforcement, and CRM tools.
-* Installed as part of the core alfe integration on every agent.
+* HTTP-based identity resolution + AccessConfig admission gate. Installed as
+* part of the core alfe integration on every agent.
 *
 * Hooks:
-*   - message_received  → resolve sender identity via HTTP, cache, gate access
-*   - before_tool_call  → enforce permissions from cached policy
-*   - after_tool_call   → log tool execution audit
+*   - message_received  → always resolves the sender, gates on accessAllowed,
+*                         blocks unknown senders (read-only resolve).
+*   - before_tool_call  → typed `(event: ToolCallEvent, ctx: ToolCallContext)`
+*                         hook (Phase 1 Stage A.0). Today: permissive no-op
+*                         stub. Phase 1 Stage E swaps the stub for the
+*                         `agent:exec` + sift gate (Decision 17).
 *
-* All data access via AgentApiClient (/agent/identity/* routes).
-* Uses the agent's own API key (from ~/.alfe/config.toml) for authentication.
+* `after_tool_call` is intentionally absent — tool-call audit lives in a
+* future dedicated audit service, not in identity.
 */
 const pkg = (0, require("node:module").createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
-const CACHE_TTL_MS = 6e4;
-const sessionCache = /* @__PURE__ */ new Map();
-function getCached(key) {
-	const entry = sessionCache.get(key);
+const RESOLVE_CACHE_TTL_MS = 6e4;
+const resolveCache = /* @__PURE__ */ new Map();
+function getCachedResolve(key) {
+	const entry = resolveCache.get(key);
 	if (!entry) return null;
 	if (Date.now() > entry.expiresAt) {
-		sessionCache.delete(key);
+		resolveCache.delete(key);
 		return null;
 	}
-	return entry.value;
+	return entry;
 }
-function setCached(key, value) {
-	sessionCache.set(key, {
-		value,
-		expiresAt: Date.now() + CACHE_TTL_MS
+function setCachedResolve(key, value) {
+	resolveCache.set(key, {
+		...value,
+		expiresAt: Date.now() + RESOLVE_CACHE_TTL_MS
 	});
 }
 function ok(data) {
@@ -70,7 +73,7 @@ function defineTool(def) {
 const plugin = {
 	id: "@alfe.ai/openclaw-identity",
 	name: "Alfe Identity",
-	description: "Identity resolution, access gating, and permission enforcement",
+	description: "Identity resolution and access gating for inbound messages",
 	version: pkg.version,
 	activate(api) {
 		const log = api.logger;
@@ -86,26 +89,17 @@ const plugin = {
 			log.error(`Identity plugin: failed to resolve config — ${err instanceof Error ? err.message : String(err)}`);
 			return;
 		}
-		let failureMode = "open";
-		client.getIntegrationConfig("alfe").then((alfeConfig) => {
-			const mode = alfeConfig.config.identity_failure_mode;
-			if (mode === "open" || mode === "closed" || mode === "permissive") failureMode = mode;
-			log.info(`Identity failure mode: ${failureMode}`);
-		}).catch(() => {
-			log.info(`Identity failure mode: ${failureMode} (default — config fetch failed)`);
-		});
-		const identityToolNames = /* @__PURE__ */ new Set();
 		const tools = [
 			defineTool({
 				name: "who_is_this",
-				description: "Look up full identity context by platform and ID — returns profile, notes, tags, platforms, and recent changelog",
+				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({
-					platform: _sinclair_typebox.Type.String({ description: "Platform name (discord, slack, chat, sms, whatsapp, etc.)" }),
-					platformId: _sinclair_typebox.Type.String({ description: "Platform-specific user identifier" })
+					provider: _sinclair_typebox.Type.String({ description: "Provider name (discord, slack, chat, google-chat, clerk, etc.)" }),
+					platformId: _sinclair_typebox.Type.String({ description: "Provider-specific user identifier" })
 				}),
 				handler: async (params) => {
 					const result = await client.resolveIdentity({
-						platform: params.platform,
+						provider: params.provider,
 						platformId: params.platformId
 					});
 					if (!result.identityId) return { found: false };
@@ -114,37 +108,19 @@ const plugin = {
 			}),
 			defineTool({
 				name: "lookup_identity",
-				description: "Search identities by name, email, phone, tag, or platform. Returns multiple matches.",
+				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()),
-					tag: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
-					platform: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
+					status: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
 				}),
 				handler: (params) => client.searchIdentities({
 					q: params.query,
-					status: params.status,
-					tag: params.tag,
-					platform: params.platform
-				})
-			}),
-			defineTool({
-				name: "create_identity",
-				description: "Create a new identity record with profile fields",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					platformId: _sinclair_typebox.Type.String(),
-					displayName: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId,
-					displayName: params.displayName
+					status: params.status
 				})
 			}),
 			defineTool({
 				name: "merge_identities",
-				description: "Merge two identity records — transfers notes, tags, aliases, platforms to survivor",
+				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" })
@@ -159,29 +135,16 @@ const plugin = {
 			}),
 			defineTool({
 				name: "unmerge_identities",
-				description: "Reverse a merge — restore previously merged identity",
+				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"
 				} })
 			}),
-			defineTool({
-				name: "link_platform",
-				description: "Link a platform identity to an existing identity record",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					platform: _sinclair_typebox.Type.String(),
-					platformId: _sinclair_typebox.Type.String()
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId
-				})
-			}),
 			defineTool({
 				name: "add_identity_note",
-				description: "Add an observation or note about a contact",
+				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(),
@@ -198,7 +161,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "tag_identity",
-				description: "Add or remove a tag on an 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(),
@@ -215,7 +178,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "get_identity_changelog",
-				description: "Get full changelog for an identity — all versions, diffs, who changed what",
+				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())
@@ -224,7 +187,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "rollback_identity",
-				description: "Revert an identity to a previous version",
+				description: "Revert an identity to a previous version.",
 				parameters: _sinclair_typebox.Type.Object({
 					identityId: _sinclair_typebox.Type.String(),
 					targetVersion: _sinclair_typebox.Type.Number()
@@ -238,78 +201,83 @@ const plugin = {
 				})
 			}),
 			defineTool({
-				name: "enforce_policy",
-				description: "Resolve sender identity and return their tool policy",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					senderId: _sinclair_typebox.Type.String(),
-					channelId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.enforcePolicy({
-					platform: params.platform,
-					senderId: params.senderId,
-					channelId: params.channelId
-				})
-			}),
-			defineTool({
-				name: "check_permission",
-				description: "Check if a specific tool call is allowed for a sender",
+				name: "update_identity",
+				description: "Update display-shape fields on an identity: name / avatarUrl / timezone / locale. 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({
-					platform: _sinclair_typebox.Type.String(),
-					senderId: _sinclair_typebox.Type.String(),
-					toolName: _sinclair_typebox.Type.String()
+					identityId: _sinclair_typebox.Type.String(),
+					name: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
+					avatarUrl: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
+					timezone: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
+					locale: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
 				}),
-				handler: (params) => client.checkToolPermission({
-					platform: params.platform,
-					senderId: params.senderId,
-					toolName: params.toolName
-				})
+				handler: (params) => {
+					const { identityId, ...rest } = params;
+					return client.updateIdentity(identityId, rest);
+				}
 			}),
 			defineTool({
 				name: "request_identity_verification",
-				description: "Send a verification phrase to the claimed identity's phone (SMS) or email. The person must relay the phrase back to confirm they own that identity.",
+				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`.",
 				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" }),
-					requestingPlatform: _sinclair_typebox.Type.String({ description: "Platform the requester is on (discord, slack, chat, etc.)" }),
-					requestingPlatformId: _sinclair_typebox.Type.String({ description: "Requester's platform-specific user ID" }),
-					preferredChannel: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "'sms' or 'email'" }))
+					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" }),
+					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'" }))
 				}),
-				handler: (params) => client.requestIdentityVerification({
-					claimedIdentityId: params.claimedIdentityId,
-					requestingIdentityId: params.requestingIdentityId,
-					requestingPlatform: params.requestingPlatform,
-					requestingPlatformId: params.requestingPlatformId,
-					preferredChannel: params.preferredChannel
-				})
+				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" });
+					const contact = contactEmail ? {
+						channel: "email",
+						value: contactEmail
+					} : contactMobile ? {
+						channel: "mobile",
+						value: contactMobile
+					} : void 0;
+					return client.requestIdentityVerification({
+						claimedIdentityId: params.claimedIdentityId,
+						requestingIdentityId: params.requestingIdentityId,
+						requestingProvider: params.requestingProvider,
+						requestingPlatformId: params.requestingPlatformId,
+						preferredChannel: params.preferredChannel,
+						contact
+					});
+				}
 			}),
 			defineTool({
 				name: "confirm_identity_verification",
-				description: "Confirm a verification by providing the three-word phrase. On success, the requesting identity is merged into the claimed identity.",
+				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).",
 				parameters: _sinclair_typebox.Type.Object({
+					claimedIdentityId: _sinclair_typebox.Type.String({ description: "Identity being claimed (matches request)" }),
 					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 SMS or email" })
+					phrase: _sinclair_typebox.Type.String({ description: "Three-word phrase the person received via mobile or email" })
 				}),
 				handler: (params) => client.confirmIdentityVerification({
+					claimedIdentityId: params.claimedIdentityId,
 					verificationId: params.verificationId,
 					phrase: params.phrase
 				})
 			})
 		];
-		for (const tool of tools) {
-			api.registerTool(tool);
-			identityToolNames.add(tool.name);
-		}
+		for (const tool of tools) api.registerTool(tool);
 		log.info(`Registered ${String(tools.length)} identity tools`);
 		api.on("message_received", async (...args) => {
 			const event = args[0];
 			const ctx = args[1];
-			const platform = ctx.channelId ?? "unknown";
-			const senderId = event.from;
+			const provider = ctx.channelId ?? "unknown";
+			const senderId = event.metadata?.UserId ?? event.from;
 			if (!senderId) return;
-			const cacheKey = ctx.conversationId ?? `${platform}:${senderId}`;
-			const cached = getCached(cacheKey);
+			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 (!cached.accessAllowed) return {
 					block: true,
 					blockReason: "Identity: access denied for this sender"
@@ -317,76 +285,39 @@ const plugin = {
 				return;
 			}
 			try {
-				const resolveResult = await client.resolveIdentity({
-					platform,
+				const r = await client.resolveIdentity({
+					provider,
 					platformId: senderId
 				});
-				setCached(cacheKey, {
-					...await client.enforcePolicy({
-						platform,
-						senderId
-					}),
-					accessAllowed: resolveResult.accessAllowed
+				setCachedResolve(cacheKey, {
+					identityId: r.identityId,
+					accessAllowed: r.accessAllowed,
+					status: r.status
 				});
-				if (!resolveResult.accessAllowed) return {
+				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"
+					};
+				}
+				if (!r.accessAllowed) return {
 					block: true,
 					blockReason: "Identity: access denied for this sender"
 				};
-				log.info(`Identity resolved: ${senderId} → ${resolveResult.identityId ?? "unknown"} (${resolveResult.status})`);
+				log.info(`Identity resolved: ${senderId} → ${r.identityId} (${r.status})`);
 			} catch (e) {
 				log.error(`Identity resolution failed for ${senderId}: ${e.message}`);
-				if (failureMode === "closed") return {
-					block: true,
-					blockReason: "Identity: identity service unavailable — access denied (closed mode)"
-				};
-			}
-		}, { priority: 100 });
-		api.on("before_tool_call", async (...args) => {
-			const event = args[0];
-			const ctx = args[1];
-			if (identityToolNames.has(event.toolName)) return;
-			const sessionKey = ctx.sessionKey;
-			if (!sessionKey) return;
-			const perms = getCached(sessionKey);
-			if (!perms) {
-				if (failureMode === "permissive") return;
-				return {
-					block: true,
-					blockReason: "Identity: no identity context established — tool access denied"
-				};
-			}
-			if (!perms.identified) {
-				if (failureMode === "permissive") return;
 				return {
 					block: true,
-					blockReason: "Identity: unknown sender identity — tool access denied"
+					blockReason: "Identity: identity service unavailable — access denied (fail-closed)"
 				};
 			}
-			if (perms.deniedTools.includes("*") || perms.deniedTools.includes(event.toolName)) return {
-				block: true,
-				blockReason: `Identity: tool '${event.toolName}' is denied for your role`
-			};
-			if (perms.allowedTools.length > 0 && !perms.allowedTools.includes(event.toolName)) return {
-				block: true,
-				blockReason: `Identity: tool '${event.toolName}' is not in your allowed tools`
-			};
 		}, { priority: 100 });
-		api.on("after_tool_call", async (...args) => {
-			const event = args[0];
-			const sessionKey = args[1].sessionKey;
-			if (!sessionKey) return;
-			const perms = getCached(sessionKey);
-			if (!perms?.identityId) return;
-			try {
-				await client.checkToolPermission({
-					platform: "tool_audit",
-					senderId: perms.identityId,
-					toolName: event.toolName
-				});
-			} catch (e) {
-				log.error(`Audit logging failed: ${e.message}`);
-			}
-		});
+		const beforeToolCallStub = (event, ctx) => {
+			return Promise.resolve(void 0);
+		};
+		api.on("before_tool_call", (...args) => beforeToolCallStub(args[0], args[1]), { priority: 100 });
 		log.info("Alfe Identity plugin activated");
 	}
 };

package/dist/plugin.js

@@ -6,33 +6,36 @@ import { Type } from "@sinclair/typebox";
 /**
 * @alfe.ai/openclaw-identity — OpenClaw native plugin
 *
-* HTTP-based identity resolution, permission enforcement, and CRM tools.
-* Installed as part of the core alfe integration on every agent.
+* HTTP-based identity resolution + AccessConfig admission gate. Installed as
+* part of the core alfe integration on every agent.
 *
 * Hooks:
-*   - message_received  → resolve sender identity via HTTP, cache, gate access
-*   - before_tool_call  → enforce permissions from cached policy
-*   - after_tool_call   → log tool execution audit
+*   - message_received  → always resolves the sender, gates on accessAllowed,
+*                         blocks unknown senders (read-only resolve).
+*   - before_tool_call  → typed `(event: ToolCallEvent, ctx: ToolCallContext)`
+*                         hook (Phase 1 Stage A.0). Today: permissive no-op
+*                         stub. Phase 1 Stage E swaps the stub for the
+*                         `agent:exec` + sift gate (Decision 17).
 *
-* All data access via AgentApiClient (/agent/identity/* routes).
-* Uses the agent's own API key (from ~/.alfe/config.toml) for authentication.
+* `after_tool_call` is intentionally absent — tool-call audit lives in a
+* future dedicated audit service, not in identity.
 */
 const pkg = createRequire(import.meta.url)("../package.json");
-const CACHE_TTL_MS = 6e4;
-const sessionCache = /* @__PURE__ */ new Map();
-function getCached(key) {
-	const entry = sessionCache.get(key);
+const RESOLVE_CACHE_TTL_MS = 6e4;
+const resolveCache = /* @__PURE__ */ new Map();
+function getCachedResolve(key) {
+	const entry = resolveCache.get(key);
 	if (!entry) return null;
 	if (Date.now() > entry.expiresAt) {
-		sessionCache.delete(key);
+		resolveCache.delete(key);
 		return null;
 	}
-	return entry.value;
+	return entry;
 }
-function setCached(key, value) {
-	sessionCache.set(key, {
-		value,
-		expiresAt: Date.now() + CACHE_TTL_MS
+function setCachedResolve(key, value) {
+	resolveCache.set(key, {
+		...value,
+		expiresAt: Date.now() + RESOLVE_CACHE_TTL_MS
 	});
 }
 function ok(data) {
@@ -71,7 +74,7 @@ function defineTool(def) {
 const plugin = {
 	id: "@alfe.ai/openclaw-identity",
 	name: "Alfe Identity",
-	description: "Identity resolution, access gating, and permission enforcement",
+	description: "Identity resolution and access gating for inbound messages",
 	version: pkg.version,
 	activate(api) {
 		const log = api.logger;
@@ -87,26 +90,17 @@ const plugin = {
 			log.error(`Identity plugin: failed to resolve config — ${err instanceof Error ? err.message : String(err)}`);
 			return;
 		}
-		let failureMode = "open";
-		client.getIntegrationConfig("alfe").then((alfeConfig) => {
-			const mode = alfeConfig.config.identity_failure_mode;
-			if (mode === "open" || mode === "closed" || mode === "permissive") failureMode = mode;
-			log.info(`Identity failure mode: ${failureMode}`);
-		}).catch(() => {
-			log.info(`Identity failure mode: ${failureMode} (default — config fetch failed)`);
-		});
-		const identityToolNames = /* @__PURE__ */ new Set();
 		const tools = [
 			defineTool({
 				name: "who_is_this",
-				description: "Look up full identity context by platform and ID — returns profile, notes, tags, platforms, and recent changelog",
+				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: Type.Object({
-					platform: Type.String({ description: "Platform name (discord, slack, chat, sms, whatsapp, etc.)" }),
-					platformId: Type.String({ description: "Platform-specific user identifier" })
+					provider: Type.String({ description: "Provider name (discord, slack, chat, google-chat, clerk, etc.)" }),
+					platformId: Type.String({ description: "Provider-specific user identifier" })
 				}),
 				handler: async (params) => {
 					const result = await client.resolveIdentity({
-						platform: params.platform,
+						provider: params.provider,
 						platformId: params.platformId
 					});
 					if (!result.identityId) return { found: false };
@@ -115,37 +109,19 @@ const plugin = {
 			}),
 			defineTool({
 				name: "lookup_identity",
-				description: "Search identities by name, email, phone, tag, or platform. Returns multiple matches.",
+				description: "Search identities by name. Returns multiple matches.",
 				parameters: Type.Object({
 					query: Type.Optional(Type.String({ description: "Text search query" })),
-					status: Type.Optional(Type.String()),
-					tag: Type.Optional(Type.String()),
-					platform: Type.Optional(Type.String())
+					status: Type.Optional(Type.String())
 				}),
 				handler: (params) => client.searchIdentities({
 					q: params.query,
-					status: params.status,
-					tag: params.tag,
-					platform: params.platform
-				})
-			}),
-			defineTool({
-				name: "create_identity",
-				description: "Create a new identity record with profile fields",
-				parameters: Type.Object({
-					platform: Type.String(),
-					platformId: Type.String(),
-					displayName: Type.Optional(Type.String())
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId,
-					displayName: params.displayName
+					status: params.status
 				})
 			}),
 			defineTool({
 				name: "merge_identities",
-				description: "Merge two identity records — transfers notes, tags, aliases, platforms to survivor",
+				description: "Merge two identity records — transfers contacts, platforms, notes, tags, aliases to the survivor. Hard-move, transactional.",
 				parameters: Type.Object({
 					survivorId: Type.String({ description: "Identity to keep" }),
 					mergedId: Type.String({ description: "Identity to merge into survivor" })
@@ -160,29 +136,16 @@ const plugin = {
 			}),
 			defineTool({
 				name: "unmerge_identities",
-				description: "Reverse a merge — restore previously merged identity",
+				description: "Reverse a merge — restore previously merged identity.",
 				parameters: Type.Object({ mergedId: Type.String({ description: "Identity that was merged (has mergedInto pointer)" }) }),
 				handler: (params) => client.unmergeIdentity(params.mergedId, { changedBy: {
 					type: "agent",
 					id: "plugin"
 				} })
 			}),
-			defineTool({
-				name: "link_platform",
-				description: "Link a platform identity to an existing identity record",
-				parameters: Type.Object({
-					identityId: Type.String(),
-					platform: Type.String(),
-					platformId: Type.String()
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId
-				})
-			}),
 			defineTool({
 				name: "add_identity_note",
-				description: "Add an observation or note about a contact",
+				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: Type.Object({
 					identityId: Type.String(),
 					content: Type.String(),
@@ -199,7 +162,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "tag_identity",
-				description: "Add or remove a tag on an identity",
+				description: "Add or remove a tag on an identity.",
 				parameters: Type.Object({
 					identityId: Type.String(),
 					tag: Type.String(),
@@ -216,7 +179,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "get_identity_changelog",
-				description: "Get full changelog for an identity — all versions, diffs, who changed what",
+				description: "Get the changelog for an identity — versions, diffs, who changed what.",
 				parameters: Type.Object({
 					identityId: Type.String(),
 					limit: Type.Optional(Type.Number())
@@ -225,7 +188,7 @@ const plugin = {
 			}),
 			defineTool({
 				name: "rollback_identity",
-				description: "Revert an identity to a previous version",
+				description: "Revert an identity to a previous version.",
 				parameters: Type.Object({
 					identityId: Type.String(),
 					targetVersion: Type.Number()
@@ -239,78 +202,83 @@ const plugin = {
 				})
 			}),
 			defineTool({
-				name: "enforce_policy",
-				description: "Resolve sender identity and return their tool policy",
-				parameters: Type.Object({
-					platform: Type.String(),
-					senderId: Type.String(),
-					channelId: Type.Optional(Type.String())
-				}),
-				handler: (params) => client.enforcePolicy({
-					platform: params.platform,
-					senderId: params.senderId,
-					channelId: params.channelId
-				})
-			}),
-			defineTool({
-				name: "check_permission",
-				description: "Check if a specific tool call is allowed for a sender",
+				name: "update_identity",
+				description: "Update display-shape fields on an identity: name / avatarUrl / timezone / locale. 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: Type.Object({
-					platform: Type.String(),
-					senderId: Type.String(),
-					toolName: Type.String()
+					identityId: Type.String(),
+					name: Type.Optional(Type.String()),
+					avatarUrl: Type.Optional(Type.String()),
+					timezone: Type.Optional(Type.String()),
+					locale: Type.Optional(Type.String())
 				}),
-				handler: (params) => client.checkToolPermission({
-					platform: params.platform,
-					senderId: params.senderId,
-					toolName: params.toolName
-				})
+				handler: (params) => {
+					const { identityId, ...rest } = params;
+					return client.updateIdentity(identityId, rest);
+				}
 			}),
 			defineTool({
 				name: "request_identity_verification",
-				description: "Send a verification phrase to the claimed identity's phone (SMS) or email. The person must relay the phrase back to confirm they own that identity.",
+				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`.",
 				parameters: Type.Object({
 					claimedIdentityId: Type.String({ description: "Identity being claimed" }),
 					requestingIdentityId: Type.String({ description: "Identity of the person making the claim" }),
-					requestingPlatform: Type.String({ description: "Platform the requester is on (discord, slack, chat, etc.)" }),
-					requestingPlatformId: Type.String({ description: "Requester's platform-specific user ID" }),
-					preferredChannel: Type.Optional(Type.String({ description: "'sms' or 'email'" }))
+					requestingProvider: Type.String({ description: "Provider the requester is on (discord, slack, chat, etc.)" }),
+					requestingPlatformId: Type.String({ description: "Requester's provider-specific user ID" }),
+					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'" }))
 				}),
-				handler: (params) => client.requestIdentityVerification({
-					claimedIdentityId: params.claimedIdentityId,
-					requestingIdentityId: params.requestingIdentityId,
-					requestingPlatform: params.requestingPlatform,
-					requestingPlatformId: params.requestingPlatformId,
-					preferredChannel: params.preferredChannel
-				})
+				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" });
+					const contact = contactEmail ? {
+						channel: "email",
+						value: contactEmail
+					} : contactMobile ? {
+						channel: "mobile",
+						value: contactMobile
+					} : void 0;
+					return client.requestIdentityVerification({
+						claimedIdentityId: params.claimedIdentityId,
+						requestingIdentityId: params.requestingIdentityId,
+						requestingProvider: params.requestingProvider,
+						requestingPlatformId: params.requestingPlatformId,
+						preferredChannel: params.preferredChannel,
+						contact
+					});
+				}
 			}),
 			defineTool({
 				name: "confirm_identity_verification",
-				description: "Confirm a verification by providing the three-word phrase. On success, the requesting identity is merged into the claimed identity.",
+				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).",
 				parameters: Type.Object({
+					claimedIdentityId: Type.String({ description: "Identity being claimed (matches request)" }),
 					verificationId: Type.String({ description: "Verification ID returned from request_identity_verification" }),
-					phrase: Type.String({ description: "Three-word phrase the person received via SMS or email" })
+					phrase: Type.String({ description: "Three-word phrase the person received via mobile or email" })
 				}),
 				handler: (params) => client.confirmIdentityVerification({
+					claimedIdentityId: params.claimedIdentityId,
 					verificationId: params.verificationId,
 					phrase: params.phrase
 				})
 			})
 		];
-		for (const tool of tools) {
-			api.registerTool(tool);
-			identityToolNames.add(tool.name);
-		}
+		for (const tool of tools) api.registerTool(tool);
 		log.info(`Registered ${String(tools.length)} identity tools`);
 		api.on("message_received", async (...args) => {
 			const event = args[0];
 			const ctx = args[1];
-			const platform = ctx.channelId ?? "unknown";
-			const senderId = event.from;
+			const provider = ctx.channelId ?? "unknown";
+			const senderId = event.metadata?.UserId ?? event.from;
 			if (!senderId) return;
-			const cacheKey = ctx.conversationId ?? `${platform}:${senderId}`;
-			const cached = getCached(cacheKey);
+			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 (!cached.accessAllowed) return {
 					block: true,
 					blockReason: "Identity: access denied for this sender"
@@ -318,76 +286,39 @@ const plugin = {
 				return;
 			}
 			try {
-				const resolveResult = await client.resolveIdentity({
-					platform,
+				const r = await client.resolveIdentity({
+					provider,
 					platformId: senderId
 				});
-				setCached(cacheKey, {
-					...await client.enforcePolicy({
-						platform,
-						senderId
-					}),
-					accessAllowed: resolveResult.accessAllowed
+				setCachedResolve(cacheKey, {
+					identityId: r.identityId,
+					accessAllowed: r.accessAllowed,
+					status: r.status
 				});
-				if (!resolveResult.accessAllowed) return {
+				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"
+					};
+				}
+				if (!r.accessAllowed) return {
 					block: true,
 					blockReason: "Identity: access denied for this sender"
 				};
-				log.info(`Identity resolved: ${senderId} → ${resolveResult.identityId ?? "unknown"} (${resolveResult.status})`);
+				log.info(`Identity resolved: ${senderId} → ${r.identityId} (${r.status})`);
 			} catch (e) {
 				log.error(`Identity resolution failed for ${senderId}: ${e.message}`);
-				if (failureMode === "closed") return {
-					block: true,
-					blockReason: "Identity: identity service unavailable — access denied (closed mode)"
-				};
-			}
-		}, { priority: 100 });
-		api.on("before_tool_call", async (...args) => {
-			const event = args[0];
-			const ctx = args[1];
-			if (identityToolNames.has(event.toolName)) return;
-			const sessionKey = ctx.sessionKey;
-			if (!sessionKey) return;
-			const perms = getCached(sessionKey);
-			if (!perms) {
-				if (failureMode === "permissive") return;
-				return {
-					block: true,
-					blockReason: "Identity: no identity context established — tool access denied"
-				};
-			}
-			if (!perms.identified) {
-				if (failureMode === "permissive") return;
 				return {
 					block: true,
-					blockReason: "Identity: unknown sender identity — tool access denied"
+					blockReason: "Identity: identity service unavailable — access denied (fail-closed)"
 				};
 			}
-			if (perms.deniedTools.includes("*") || perms.deniedTools.includes(event.toolName)) return {
-				block: true,
-				blockReason: `Identity: tool '${event.toolName}' is denied for your role`
-			};
-			if (perms.allowedTools.length > 0 && !perms.allowedTools.includes(event.toolName)) return {
-				block: true,
-				blockReason: `Identity: tool '${event.toolName}' is not in your allowed tools`
-			};
 		}, { priority: 100 });
-		api.on("after_tool_call", async (...args) => {
-			const event = args[0];
-			const sessionKey = args[1].sessionKey;
-			if (!sessionKey) return;
-			const perms = getCached(sessionKey);
-			if (!perms?.identityId) return;
-			try {
-				await client.checkToolPermission({
-					platform: "tool_audit",
-					senderId: perms.identityId,
-					toolName: event.toolName
-				});
-			} catch (e) {
-				log.error(`Audit logging failed: ${e.message}`);
-			}
-		});
+		const beforeToolCallStub = (event, ctx) => {
+			return Promise.resolve(void 0);
+		};
+		api.on("before_tool_call", (...args) => beforeToolCallStub(args[0], args[1]), { priority: 100 });
 		log.info("Alfe Identity plugin activated");
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/openclaw-identity",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "OpenClaw identity plugin — identity resolution, access gating, permission enforcement",
   "type": "module",
   "main": "./dist/plugin.js",
@@ -28,13 +28,14 @@
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
-    "@alfe.ai/agent-api-client": "0.0.12",
+    "@alfe.ai/agent-api-client": "0.0.13",
     "@alfe.ai/config": "0.0.8"
   },
   "license": "UNLICENSED",
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "lint": "eslint ."
   }