@bamdra/bamdra-user-bind 0.1.12 → 0.1.14

package/dist/index.js

@@ -39,6 +39,9 @@ var import_node_sqlite = require("node:sqlite");
 var import_node_url = require("url");
 var PLUGIN_ID = "bamdra-user-bind";
 var GLOBAL_API_KEY = "__OPENCLAW_BAMDRA_USER_BIND__";
+var GLOBAL_RUNTIME_KEY = "__OPENCLAW_BAMDRA_USER_BIND_RUNTIME__";
+var GLOBAL_RUNTIME_BRAND_KEY = "__OPENCLAW_BAMDRA_USER_BIND_RUNTIME_BRAND__";
+var GLOBAL_PENDING_REFINE_KEY = "__OPENCLAW_BAMDRA_USER_BIND_PENDING_REFINE__";
 var PROFILE_SKILL_ID = "bamdra-user-bind-profile";
 var ADMIN_SKILL_ID = "bamdra-user-bind-admin";
 var SELF_TOOL_NAMES = [
@@ -46,6 +49,11 @@ var SELF_TOOL_NAMES = [
   "bamdra_user_bind_update_my_profile",
   "bamdra_user_bind_refresh_my_binding"
 ];
+var SELF_TOOL_ALIASES = [
+  "user_bind_get_my_profile",
+  "user_bind_update_my_profile",
+  "user_bind_refresh_my_binding"
+];
 var ADMIN_TOOL_NAMES = [
   "bamdra_user_bind_admin_query",
   "bamdra_user_bind_admin_edit",
@@ -59,10 +67,22 @@ var TABLES = {
   issues: "bamdra_user_bind_issues",
   audits: "bamdra_user_bind_audits"
 };
-var REQUIRED_FEISHU_IDENTITY_SCOPES = [
-  "contact:user.employee_id:readonly",
-  "contact:user.base:readonly"
-];
+var SEMANTIC_PROFILE_CAPTURE_TIMEOUT_MS = readSemanticProfileCaptureTimeoutMs();
+var SEMANTIC_PROFILE_BATCH_WINDOW_MS = 240;
+var SEMANTIC_PROFILE_BATCH_MAX_FRAGMENTS = 4;
+var SEMANTIC_PROFILE_BATCH_MAX_CHARS = 360;
+var SEMANTIC_PROFILE_RETRY_MAX_ATTEMPTS = 3;
+var CHANNELS_WITH_NATIVE_STABLE_IDS = /* @__PURE__ */ new Set([
+  "telegram",
+  "whatsapp",
+  "discord",
+  "googlechat",
+  "slack",
+  "mattermost",
+  "signal",
+  "imessage",
+  "msteams"
+]);
 function logUserBindEvent(event, details = {}) {
   try {
     console.info("[bamdra-user-bind]", event, JSON.stringify(details));
@@ -84,11 +104,15 @@ var UserBindStore = class {
         user_id TEXT PRIMARY KEY,
         name TEXT,
         gender TEXT,
+        birth_date TEXT,
+        birth_year TEXT,
+        age TEXT,
         email TEXT,
         avatar TEXT,
         nickname TEXT,
         preferences TEXT,
         personality TEXT,
+        interests TEXT,
         role TEXT,
         timezone TEXT,
         notes TEXT,
@@ -130,6 +154,11 @@ var UserBindStore = class {
     `);
     this.ensureColumn(TABLES.profiles, "timezone", "TEXT");
     this.ensureColumn(TABLES.profiles, "notes", "TEXT");
+    this.ensureColumn(TABLES.profiles, "birth_date", "TEXT");
+    this.ensureColumn(TABLES.profiles, "birth_year", "TEXT");
+    this.ensureColumn(TABLES.profiles, "age", "TEXT");
+    this.ensureColumn(TABLES.profiles, "interests", "TEXT");
+    this.migrateChannelScopedUserIds();
   }
   db;
   markdownSyncing = /* @__PURE__ */ new Set();
@@ -140,6 +169,16 @@ var UserBindStore = class {
     this.syncMarkdownToStore(userId);
     return this.getProfileFromDatabase(userId);
   }
+  listProfilesWithPendingSemanticRefine(limit = 20) {
+    const rows = this.db.prepare(`
+      SELECT user_id, name, gender, birth_date, birth_year, age, email, avatar, nickname, preferences, personality, interests, role, timezone, notes, visibility, source, updated_at
+      FROM ${TABLES.profiles}
+      WHERE notes LIKE '%[pending-profile-refine:%'
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(limit);
+    return rows.map(mapProfileRow);
+  }
   findBinding(channelType, openId) {
     if (!openId) {
       return null;
@@ -156,6 +195,22 @@ var UserBindStore = class {
       source: row.source
     };
   }
+  reconcileProvisionalIdentity(channelType, openId, stableUserId) {
+    if (!openId) {
+      return null;
+    }
+    const provisionalUserId = createProvisionalUserId(channelType, openId);
+    const scopedStableUserId = scopeUserId(channelType, stableUserId);
+    if (provisionalUserId === scopedStableUserId) {
+      return this.getProfile(scopedStableUserId);
+    }
+    const provisional = this.getProfile(provisionalUserId);
+    const stable = this.getProfile(scopedStableUserId);
+    if (!provisional || !stable) {
+      return stable;
+    }
+    return this.mergeUsers(provisionalUserId, scopedStableUserId);
+  }
   listIssues() {
     return this.db.prepare(`
       SELECT id, kind, user_id, details, status, updated_at
@@ -190,38 +245,45 @@ var UserBindStore = class {
     );
   }
   upsertIdentity(args) {
-    if (!this.markdownSyncing.has(args.userId)) {
-      this.syncMarkdownToStore(args.userId);
-    }
+    const scopedUserId = scopeUserId(args.channelType, args.userId);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const current = this.getProfileFromDatabase(args.userId);
+    const current = this.getProfileFromDatabase(scopedUserId);
+    const externalUserId = args.openId ?? getExternalUserId(args.channelType, args.userId);
     const next = {
-      userId: args.userId,
+      userId: scopedUserId,
       name: args.profilePatch.name ?? current?.name ?? null,
       gender: args.profilePatch.gender ?? current?.gender ?? null,
+      birthDate: args.profilePatch.birthDate ?? current?.birthDate ?? null,
+      birthYear: args.profilePatch.birthYear ?? current?.birthYear ?? null,
+      age: args.profilePatch.age ?? current?.age ?? null,
       email: args.profilePatch.email ?? current?.email ?? null,
       avatar: args.profilePatch.avatar ?? current?.avatar ?? null,
-      nickname: args.profilePatch.nickname ?? current?.nickname ?? "\u8001\u677F",
-      preferences: args.profilePatch.preferences ?? current?.preferences ?? "\u5E7D\u9ED8\u8BD9\u8C10\u7684\u5BF9\u8BDD\u98CE\u683C\uFF0C\u4F46\u662F\u4E0D\u8FC7\u5206",
+      nickname: args.profilePatch.nickname ?? current?.nickname ?? null,
+      preferences: args.profilePatch.preferences ?? current?.preferences ?? null,
       personality: args.profilePatch.personality ?? current?.personality ?? null,
+      interests: args.profilePatch.interests ?? current?.interests ?? null,
       role: args.profilePatch.role ?? current?.role ?? null,
-      timezone: args.profilePatch.timezone ?? current?.timezone ?? "Asia/Shanghai",
+      timezone: args.profilePatch.timezone ?? current?.timezone ?? getServerTimezone(),
       notes: args.profilePatch.notes ?? current?.notes ?? defaultProfileNotes(),
       visibility: args.profilePatch.visibility ?? current?.visibility ?? "private",
       source: args.source,
       updatedAt: now
     };
     this.db.prepare(`
-      INSERT INTO ${TABLES.profiles} (user_id, name, gender, email, avatar, nickname, preferences, personality, role, timezone, notes, visibility, source, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO ${TABLES.profiles} (user_id, name, gender, birth_date, birth_year, age, email, avatar, nickname, preferences, personality, interests, role, timezone, notes, visibility, source, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(user_id) DO UPDATE SET
         name = excluded.name,
         gender = excluded.gender,
+        birth_date = excluded.birth_date,
+        birth_year = excluded.birth_year,
+        age = excluded.age,
         email = excluded.email,
         avatar = excluded.avatar,
         nickname = excluded.nickname,
         preferences = excluded.preferences,
         personality = excluded.personality,
+        interests = excluded.interests,
         role = excluded.role,
         timezone = excluded.timezone,
         notes = excluded.notes,
@@ -232,11 +294,15 @@ var UserBindStore = class {
       next.userId,
       next.name,
       next.gender,
+      next.birthDate,
+      next.birthYear,
+      next.age,
       next.email,
       next.avatar,
       next.nickname,
       next.preferences,
       next.personality,
+      next.interests,
       next.role,
       next.timezone,
       next.notes,
@@ -257,10 +323,10 @@ var UserBindStore = class {
           updated_at = excluded.updated_at
       `).run(
         bindingId,
-        args.userId,
+        scopedUserId,
         args.channelType,
         args.openId,
-        args.userId,
+        externalUserId,
         null,
         args.source,
         now
@@ -286,6 +352,26 @@ var UserBindStore = class {
       }
     });
   }
+  replaceProfileNotes(userId, notes, source) {
+    const current = this.getProfile(userId);
+    if (!current) {
+      throw new Error(`Unknown user ${userId}`);
+    }
+    const next = {
+      ...current,
+      notes,
+      source,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.db.prepare(`
+      UPDATE ${TABLES.profiles}
+      SET notes = ?, source = ?, updated_at = ?
+      WHERE user_id = ?
+    `).run(next.notes, next.source, next.updatedAt, current.userId);
+    this.writeProfileMarkdown(next);
+    this.writeExports();
+    return next;
+  }
   mergeUsers(fromUserId, intoUserId) {
     const from = this.getProfile(fromUserId);
     const into = this.getProfile(intoUserId);
@@ -300,11 +386,15 @@ var UserBindStore = class {
       profilePatch: {
         name: into.name ?? from.name,
         gender: into.gender ?? from.gender,
+        birthDate: into.birthDate ?? from.birthDate,
+        birthYear: into.birthYear ?? from.birthYear,
+        age: into.age ?? from.age,
         email: into.email ?? from.email,
         avatar: into.avatar ?? from.avatar,
         nickname: into.nickname ?? from.nickname,
         preferences: into.preferences ?? from.preferences,
         personality: into.personality ?? from.personality,
+        interests: into.interests ?? from.interests,
         role: into.role ?? from.role,
         timezone: into.timezone ?? from.timezone,
         notes: joinNotes(into.notes, from.notes),
@@ -322,7 +412,7 @@ var UserBindStore = class {
   }
   getProfileFromDatabase(userId) {
     const row = this.db.prepare(`
-      SELECT user_id, name, gender, email, avatar, nickname, preferences, personality, role, timezone, notes, visibility, source, updated_at
+      SELECT user_id, name, gender, birth_date, birth_year, age, email, avatar, nickname, preferences, personality, interests, role, timezone, notes, visibility, source, updated_at
       FROM ${TABLES.profiles} WHERE user_id = ?
     `).get(userId);
     return row ? mapProfileRow(row) : null;
@@ -346,8 +436,6 @@ var UserBindStore = class {
       }
       const current = this.getProfileFromDatabase(userId);
       const parsed = parseProfileMarkdown((0, import_node_fs.readFileSync)(markdownPath, "utf8"));
-      const markdownMtime = (0, import_node_fs.statSync)(markdownPath).mtime.toISOString();
-      const dbTime = current?.updatedAt ?? (/* @__PURE__ */ new Date(0)).toISOString();
       const patch = {
         ...parsed.profilePatch,
         notes: parsed.notes
@@ -357,7 +445,7 @@ var UserBindStore = class {
           userId,
           channelType: "manual",
           openId: null,
-          source: "markdown-profile",
+          source: parsed.source ?? "markdown-profile",
           profilePatch: {
             ...patch,
             visibility: patch.visibility ?? "private"
@@ -365,14 +453,53 @@ var UserBindStore = class {
         });
         return;
       }
-      if (markdownMtime <= dbTime && !hasProfileDifference(current, patch)) {
+      const markdownMtime = (0, import_node_fs.statSync)(markdownPath).mtime.toISOString();
+      const markdownHash = computeProfilePayloadHash({
+        name: patch.name ?? null,
+        gender: patch.gender ?? null,
+        birthDate: patch.birthDate ?? null,
+        birthYear: patch.birthYear ?? null,
+        age: patch.age ?? null,
+        nickname: patch.nickname ?? null,
+        timezone: patch.timezone ?? null,
+        preferences: patch.preferences ?? null,
+        personality: patch.personality ?? null,
+        interests: patch.interests ?? null,
+        role: patch.role ?? null,
+        visibility: patch.visibility ?? current.visibility
+      }, patch.notes ?? null);
+      const currentHash = computeProfilePayloadHash({
+        name: current.name,
+        gender: current.gender,
+        birthDate: current.birthDate,
+        birthYear: current.birthYear,
+        age: current.age,
+        nickname: current.nickname,
+        timezone: current.timezone,
+        preferences: current.preferences,
+        personality: current.personality,
+        interests: current.interests,
+        role: current.role,
+        visibility: current.visibility
+      }, current.notes);
+      if (markdownHash === currentHash) {
+        return;
+      }
+      if (parsed.syncHash && parsed.syncHash === markdownHash) {
+        return;
+      }
+      const dbTime = current.updatedAt;
+      if (parsed.updatedAt && parsed.updatedAt <= dbTime && markdownMtime <= dbTime) {
+        return;
+      }
+      if (!parsed.syncHash && markdownMtime <= dbTime) {
         return;
       }
       this.upsertIdentity({
         userId,
         channelType: "manual",
         openId: null,
-        source: "markdown-profile",
+        source: parsed.source ?? "markdown-profile",
         profilePatch: {
           ...current,
           ...patch
@@ -389,7 +516,7 @@ var UserBindStore = class {
   }
   writeExports() {
     const profiles = this.db.prepare(`
-      SELECT user_id, name, gender, email, avatar, nickname, preferences, personality, role, timezone, notes, visibility, source, updated_at
+      SELECT user_id, name, gender, birth_date, birth_year, age, email, avatar, nickname, preferences, personality, interests, role, timezone, notes, visibility, source, updated_at
       FROM ${TABLES.profiles}
       ORDER BY updated_at DESC
     `).all();
@@ -408,6 +535,102 @@ var UserBindStore = class {
     }
     this.db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
   }
+  migrateChannelScopedUserIds() {
+    const rows = this.db.prepare(`
+      SELECT DISTINCT user_id, channel_type
+      FROM ${TABLES.bindings}
+      WHERE user_id IS NOT NULL AND channel_type IS NOT NULL
+    `).all();
+    const renames = rows.map((row) => {
+      const currentUserId = String(row.user_id ?? "");
+      const channelType = String(row.channel_type ?? "");
+      const scopedUserId = scopeUserId(channelType, currentUserId);
+      if (!currentUserId || !channelType || scopedUserId === currentUserId) {
+        return null;
+      }
+      return { currentUserId, scopedUserId };
+    }).filter((item) => item != null);
+    if (renames.length === 0) {
+      return;
+    }
+    for (const { currentUserId, scopedUserId } of renames) {
+      this.renameUserId(currentUserId, scopedUserId);
+    }
+    this.writeExports();
+  }
+  renameUserId(fromUserId, toUserId) {
+    if (fromUserId === toUserId) {
+      return;
+    }
+    const existingTarget = this.getProfileFromDatabase(toUserId);
+    const sourceProfile = this.getProfileFromDatabase(fromUserId);
+    if (sourceProfile && !existingTarget) {
+      this.db.prepare(`UPDATE ${TABLES.profiles} SET user_id = ? WHERE user_id = ?`).run(toUserId, fromUserId);
+    } else if (sourceProfile && existingTarget) {
+      const merged = {
+        ...sourceProfile,
+        ...existingTarget,
+        userId: toUserId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: existingTarget.source || sourceProfile.source,
+        notes: joinNotes(existingTarget.notes, sourceProfile.notes)
+      };
+      this.db.prepare(`DELETE FROM ${TABLES.profiles} WHERE user_id = ?`).run(fromUserId);
+      this.db.prepare(`
+        INSERT INTO ${TABLES.profiles} (user_id, name, gender, birth_date, birth_year, age, email, avatar, nickname, preferences, personality, interests, role, timezone, notes, visibility, source, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id) DO UPDATE SET
+          name = excluded.name,
+          gender = excluded.gender,
+          birth_date = excluded.birth_date,
+          birth_year = excluded.birth_year,
+          age = excluded.age,
+          email = excluded.email,
+          avatar = excluded.avatar,
+          nickname = excluded.nickname,
+          preferences = excluded.preferences,
+          personality = excluded.personality,
+          interests = excluded.interests,
+          role = excluded.role,
+          timezone = excluded.timezone,
+          notes = excluded.notes,
+          visibility = excluded.visibility,
+          source = excluded.source,
+          updated_at = excluded.updated_at
+      `).run(
+        merged.userId,
+        merged.name,
+        merged.gender,
+        merged.birthDate,
+        merged.birthYear,
+        merged.age,
+        merged.email,
+        merged.avatar,
+        merged.nickname,
+        merged.preferences,
+        merged.personality,
+        merged.interests,
+        merged.role,
+        merged.timezone,
+        merged.notes,
+        merged.visibility,
+        merged.source,
+        merged.updatedAt
+      );
+    }
+    this.db.prepare(`UPDATE ${TABLES.bindings} SET user_id = ?, external_user_id = ?, updated_at = ? WHERE user_id = ?`).run(
+      toUserId,
+      getExternalUserId(extractChannelFromScopedUserId(toUserId) ?? "manual", toUserId),
+      (/* @__PURE__ */ new Date()).toISOString(),
+      fromUserId
+    );
+    const oldMarkdownPath = this.profileMarkdownPath(fromUserId);
+    const newMarkdownPath = this.profileMarkdownPath(toUserId);
+    if ((0, import_node_fs.existsSync)(oldMarkdownPath) && !(0, import_node_fs.existsSync)(newMarkdownPath)) {
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(newMarkdownPath), { recursive: true });
+      (0, import_node_fs.cpSync)(oldMarkdownPath, newMarkdownPath);
+    }
+  }
 };
 var UserBindRuntime = class {
   constructor(host, inputConfig) {
@@ -423,13 +646,51 @@ var UserBindRuntime = class {
   config;
   sessionCache = /* @__PURE__ */ new Map();
   bindingCache = /* @__PURE__ */ new Map();
-  feishuScopeStatus = null;
-  bitableMirror = null;
+  semanticCaptureCache = /* @__PURE__ */ new Map();
+  semanticCaptureInFlight = /* @__PURE__ */ new Set();
+  semanticCaptureRetryTimers = /* @__PURE__ */ new Map();
+  semanticCaptureRetryAttempts = /* @__PURE__ */ new Map();
+  pendingSemanticCaptures = /* @__PURE__ */ new Map();
+  pendingBindingResolutions = /* @__PURE__ */ new Map();
   feishuTokenCache = /* @__PURE__ */ new Map();
+  globalPendingSemanticRefines = getGlobalPendingSemanticRefines();
+  pendingBindingTimer = null;
+  pendingBindingKickTimer = null;
+  pendingSemanticSweepTimer = null;
+  pendingBindingSweepInFlight = false;
+  pendingSemanticSweepInFlight = false;
+  registered = false;
   close() {
+    if (this.pendingBindingTimer) {
+      clearInterval(this.pendingBindingTimer);
+      this.pendingBindingTimer = null;
+    }
+    if (this.pendingBindingKickTimer) {
+      clearTimeout(this.pendingBindingKickTimer);
+      this.pendingBindingKickTimer = null;
+    }
+    if (this.pendingSemanticSweepTimer) {
+      clearTimeout(this.pendingSemanticSweepTimer);
+      this.pendingSemanticSweepTimer = null;
+    }
+    for (const pending of this.pendingSemanticCaptures.values()) {
+      if (pending.timer) {
+        clearTimeout(pending.timer);
+      }
+    }
+    this.pendingSemanticCaptures.clear();
+    for (const timer of this.semanticCaptureRetryTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.semanticCaptureRetryTimers.clear();
+    this.semanticCaptureRetryAttempts.clear();
     this.store.close();
   }
   register() {
+    if (this.registered) {
+      return;
+    }
+    this.registered = true;
     queueMicrotask(() => {
       try {
         bootstrapOpenClawHost(this.config);
@@ -438,15 +699,25 @@ var UserBindRuntime = class {
     });
     this.registerHooks();
     this.registerTools();
+    this.startPendingBindingWorker();
+    this.schedulePendingSemanticSweep();
     exposeGlobalApi(this);
   }
   getIdentityForSession(sessionId) {
     return this.sessionCache.get(sessionId) ?? null;
   }
-  async resolveFromContext(context) {
-    const parsed = parseIdentityContext(context);
+  async resolveFromContext(context, options = {}) {
+    const parsed = parseIdentityContext(enrichIdentityContext(context));
     if (parsed.sessionId && !parsed.channelType) {
-      return this.sessionCache.get(parsed.sessionId) ?? null;
+      const cached2 = this.sessionCache.get(parsed.sessionId) ?? null;
+      if (cached2 && isProvisionalScopedUserId(cached2.userId) && cached2.senderOpenId) {
+        return this.resolveFromContext({
+          sessionId: parsed.sessionId,
+          channel: { type: cached2.channelType },
+          sender: { id: cached2.senderOpenId, name: cached2.senderName }
+        });
+      }
+      return cached2;
     }
     if (!parsed.sessionId || !parsed.channelType) {
       return null;
@@ -454,47 +725,90 @@ var UserBindRuntime = class {
     const cacheKey = `${parsed.channelType}:${parsed.openId ?? parsed.sessionId}`;
     const cached = this.bindingCache.get(cacheKey);
     if (cached && cached.expiresAt > Date.now()) {
-      this.sessionCache.set(parsed.sessionId, cached.identity);
-      return cached.identity;
+      if (parsed.openId && (isProvisionalScopedUserId(cached.identity.userId) || cached.identity.source === "synthetic-fallback")) {
+        const rebound = this.store.findBinding(parsed.channelType, parsed.openId);
+        if (!rebound || rebound.userId === cached.identity.userId) {
+          this.sessionCache.set(parsed.sessionId, cached.identity);
+          return cached.identity;
+        }
+        this.bindingCache.delete(cacheKey);
+      } else {
+        this.sessionCache.set(parsed.sessionId, cached.identity);
+        return cached.identity;
+      }
     }
     const binding = this.store.findBinding(parsed.channelType, parsed.openId);
     let userId = binding?.userId ?? null;
     let source = binding?.source ?? "local";
+    const provisionalUserId = parsed.openId ? createProvisionalUserId(parsed.channelType, parsed.openId) : null;
     let remoteProfilePatch = {};
     if (parsed.channelType === "feishu" && parsed.openId) {
-      const scopeStatus = await this.ensureFeishuScopeStatus();
-      if (scopeStatus.missingIdentityScopes.length > 0) {
-        const details = `Missing Feishu scopes: ${scopeStatus.missingIdentityScopes.join(", ")}`;
-        logUserBindEvent("feishu-scope-missing", {
-          openId: parsed.openId,
-          missingScopes: scopeStatus.missingIdentityScopes
-        });
-        this.store.recordIssue("feishu-scope-missing", details);
-      }
       if (!userId) {
-        const remote = await this.tryResolveFeishuUser(parsed.openId);
-        if (remote?.userId) {
-          userId = remote.userId;
-          source = remote.source;
-          remoteProfilePatch = remote.profilePatch;
+        if (options.allowRemoteLookup) {
+          const remote = await this.tryResolveFeishuUser(parsed.openId);
+          if (remote?.userId) {
+            userId = remote.userId;
+            source = remote.source;
+            remoteProfilePatch = remote.profilePatch;
+          } else if (remote?.source === "feishu-contact-scope-missing") {
+            source = remote.source;
+            remoteProfilePatch = remote.profilePatch;
+            this.enqueuePendingBindingResolution(parsed.channelType, parsed.openId, remote.source);
+          } else {
+            this.store.recordIssue("feishu-resolution", `Failed to resolve real user id for ${parsed.openId}`);
+            this.enqueuePendingBindingResolution(parsed.channelType, parsed.openId, "feishu-resolution-miss");
+          }
         } else {
-          this.store.recordIssue("feishu-resolution", `Failed to resolve real user id for ${parsed.openId}`);
+          this.enqueuePendingBindingResolution(parsed.channelType, parsed.openId, "feishu-deferred-resolution");
         }
       }
     }
+    const profilePatch = {
+      name: parsed.senderName,
+      ...remoteProfilePatch
+    };
+    if (!userId && parsed.openId && parsed.channelType && CHANNELS_WITH_NATIVE_STABLE_IDS.has(parsed.channelType)) {
+      userId = `${parsed.channelType}:${parsed.openId}`;
+      source = "channel-native";
+    }
+    if (!userId && provisionalUserId) {
+      userId = provisionalUserId;
+      source = "provisional-openid";
+      this.enqueuePendingBindingResolution(parsed.channelType, parsed.openId, source);
+    }
+    const shouldPersistIdentity = Boolean(userId);
     if (!userId) {
-      userId = `${parsed.channelType}:${parsed.openId ?? parsed.sessionId}`;
+      userId = createEphemeralUserId(parsed.channelType, parsed.openId, parsed.sessionId);
       source = "synthetic-fallback";
     }
-    const profile = this.store.upsertIdentity({
+    if (shouldPersistIdentity) {
+      this.store.getProfile(userId);
+    }
+    const profile = shouldPersistIdentity ? (() => {
+      let persisted = this.store.upsertIdentity({
+        userId,
+        channelType: parsed.channelType,
+        openId: parsed.openId,
+        source,
+        profilePatch
+      });
+      if (provisionalUserId && persisted.userId !== provisionalUserId && source !== "provisional-openid") {
+        const reconciled = this.store.reconcileProvisionalIdentity(parsed.channelType, parsed.openId, persisted.userId);
+        if (reconciled) {
+          persisted = reconciled;
+          logUserBindEvent("provisional-profile-merged", {
+            provisionalUserId,
+            stableUserId: persisted.userId,
+            sessionId: parsed.sessionId
+          });
+        }
+      }
+      return persisted;
+    })() : buildLightweightProfile({
       userId,
-      channelType: parsed.channelType,
-      openId: parsed.openId,
       source,
-      profilePatch: {
-        name: parsed.senderName,
-        ...remoteProfilePatch
-      }
+      current: null,
+      profilePatch
     });
     const identity = {
       sessionId: parsed.sessionId,
@@ -511,26 +825,151 @@ var UserBindRuntime = class {
       expiresAt: Date.now() + this.config.cacheTtlMs,
       identity
     });
-    if (parsed.channelType === "feishu") {
-      await this.syncFeishuMirror(identity);
-    }
     return identity;
   }
+  startPendingBindingWorker() {
+    if (this.pendingBindingTimer) {
+      return;
+    }
+    this.pendingBindingTimer = setInterval(() => {
+      void this.runPendingBindingSweep();
+    }, 60 * 1e3);
+    this.pendingBindingTimer.unref?.();
+  }
+  schedulePendingBindingSweep(delayMs) {
+    if (this.pendingBindingKickTimer) {
+      return;
+    }
+    this.pendingBindingKickTimer = setTimeout(() => {
+      this.pendingBindingKickTimer = null;
+      void this.runPendingBindingSweep();
+    }, delayMs);
+    this.pendingBindingKickTimer.unref?.();
+  }
+  enqueuePendingBindingResolution(channelType, openId, reason) {
+    if (!openId) {
+      return;
+    }
+    const key = `${channelType}:${openId}`;
+    const current = this.pendingBindingResolutions.get(key);
+    if (current) {
+      current.reason = reason;
+      current.nextAttemptAt = Math.min(current.nextAttemptAt, Date.now() + 5e3);
+      this.pendingBindingResolutions.set(key, current);
+    } else {
+      this.pendingBindingResolutions.set(key, {
+        channelType,
+        openId,
+        reason,
+        attempts: 0,
+        nextAttemptAt: Date.now() + 5e3
+      });
+    }
+    this.schedulePendingBindingSweep(5e3);
+  }
+  async runPendingBindingSweep() {
+    if (this.pendingBindingSweepInFlight || this.pendingBindingResolutions.size === 0) {
+      return;
+    }
+    this.pendingBindingSweepInFlight = true;
+    try {
+      const now = Date.now();
+      for (const [key, pending] of this.pendingBindingResolutions.entries()) {
+        if (pending.nextAttemptAt > now) {
+          continue;
+        }
+        const existing = this.store.findBinding(pending.channelType, pending.openId);
+        if (existing && !isProvisionalScopedUserId(existing.userId)) {
+          this.store.upsertIdentity({
+            userId: existing.userId,
+            channelType: pending.channelType,
+            openId: pending.openId,
+            source: existing.source,
+            profilePatch: {}
+          });
+          this.store.reconcileProvisionalIdentity(pending.channelType, pending.openId, existing.userId);
+          this.dropCachedOpenIdIdentity(pending.channelType, pending.openId);
+          this.pendingBindingResolutions.delete(key);
+          logUserBindEvent("pending-binding-reconciled", {
+            channelType: pending.channelType,
+            openId: pending.openId,
+            userId: existing.userId
+          });
+          continue;
+        }
+        if (pending.channelType !== "feishu") {
+          this.pendingBindingResolutions.delete(key);
+          continue;
+        }
+        const remote = await this.tryResolveFeishuUser(pending.openId);
+        if (remote?.userId) {
+          this.store.upsertIdentity({
+            userId: remote.userId,
+            channelType: pending.channelType,
+            openId: pending.openId,
+            source: remote.source,
+            profilePatch: remote.profilePatch
+          });
+          this.store.reconcileProvisionalIdentity(pending.channelType, pending.openId, remote.userId);
+          this.dropCachedOpenIdIdentity(pending.channelType, pending.openId);
+          this.pendingBindingResolutions.delete(key);
+          logUserBindEvent("pending-binding-resolved", {
+            channelType: pending.channelType,
+            openId: pending.openId,
+            userId: remote.userId,
+            source: remote.source
+          });
+          continue;
+        }
+        pending.attempts += 1;
+        pending.nextAttemptAt = Date.now() + getPendingBindingRetryDelayMs(remote?.source ?? pending.reason, pending.attempts);
+        this.pendingBindingResolutions.set(key, pending);
+      }
+    } finally {
+      this.pendingBindingSweepInFlight = false;
+    }
+  }
+  dropCachedOpenIdIdentity(channelType, openId) {
+    const cacheKey = `${channelType}:${openId}`;
+    this.bindingCache.delete(cacheKey);
+    for (const [sessionId, identity] of this.sessionCache.entries()) {
+      if (identity.channelType === channelType && identity.senderOpenId === openId) {
+        this.sessionCache.delete(sessionId);
+      }
+    }
+  }
   async getMyProfile(context) {
     const identity = await this.requireCurrentIdentity(context);
     return identity.profile;
   }
-  async updateMyProfile(context, patch) {
+  async updateMyProfile(context, patch, operations) {
     const identity = await this.requireCurrentIdentity(context);
-    const updated = this.store.updateProfile(identity.userId, {
-      ...patch,
+    const fallbackOperations = extractProfilePatchOperations(context && typeof context === "object" ? context : {});
+    const nextPatch = applyProfilePatchOperations(identity.profile, patch, operations ?? fallbackOperations);
+    const updated = identity.source === "synthetic-fallback" ? this.store.upsertIdentity({
+      userId: createStableLocalUserId(identity.channelType, identity.senderOpenId, identity.sessionId),
+      channelType: identity.channelType,
+      openId: identity.senderOpenId,
+      source: "self-bootstrap",
+      profilePatch: {
+        ...identity.profile,
+        ...nextPatch
+      }
+    }) : this.store.updateProfile(identity.userId, {
+      ...nextPatch,
       source: "self-update"
     });
     const nextIdentity = {
       ...identity,
+      userId: updated.userId,
+      source: updated.source,
       profile: updated
     };
     this.sessionCache.set(identity.sessionId, nextIdentity);
+    this.bindingCache.set(`${identity.channelType}:${identity.senderOpenId ?? identity.sessionId}`, {
+      expiresAt: Date.now() + this.config.cacheTtlMs,
+      identity: nextIdentity
+    });
     return updated;
   }
   async refreshMyBinding(context) {
@@ -540,12 +979,366 @@ var UserBindRuntime = class {
       sessionId: identity.sessionId,
       sender: { id: identity.senderOpenId, name: identity.senderName },
       channel: { type: identity.channelType }
-    });
+    }, { allowRemoteLookup: true });
     if (!refreshed) {
       throw new Error("Unable to refresh binding for current session");
     }
     return refreshed;
   }
+  async captureProfileFromMessage(context, identity) {
+    const utteranceText = extractUserUtterance(context);
+    if (!utteranceText) {
+      logUserBindEvent("semantic-profile-capture-skipped-no-utterance", {
+        userId: identity.userId,
+        sessionId: identity.sessionId
+      });
+      return;
+    }
+    const messageText = buildSemanticCaptureInput(context, utteranceText);
+    if (!messageText) {
+      return;
+    }
+    if (shouldIgnoreSemanticProfileCaptureCandidate(utteranceText) && messageText === utteranceText) {
+      logUserBindEvent("semantic-profile-capture-skipped-trivial-utterance", {
+        userId: identity.userId,
+        sessionId: identity.sessionId,
+        messagePreview: utteranceText.slice(0, 120)
+      });
+      return;
+    }
+    this.enqueueSemanticProfileCapture(identity, messageText);
+  }
+  enqueueSemanticProfileCapture(identity, messageText) {
+    const sessionId = identity.sessionId;
+    const pending = this.pendingSemanticCaptures.get(sessionId) ?? {
+      identity,
+      messages: [],
+      timer: null
+    };
+    pending.identity = identity;
+    pending.messages = appendSemanticCaptureCandidate(pending.messages, messageText);
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+    }
+    pending.timer = setTimeout(() => {
+      pending.timer = null;
+      void this.flushSemanticProfileCapture(sessionId).catch((error) => {
+        logUserBindEvent("semantic-profile-capture-flush-failed", {
+          userId: identity.userId,
+          sessionId,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, SEMANTIC_PROFILE_BATCH_WINDOW_MS);
+    this.pendingSemanticCaptures.set(sessionId, pending);
+  }
+  async flushSemanticProfileCapture(sessionId) {
+    const pending = this.pendingSemanticCaptures.get(sessionId);
+    if (!pending) {
+      return;
+    }
+    this.pendingSemanticCaptures.delete(sessionId);
+    const identity = pending.identity;
+    const messageText = buildSemanticProfileBatchText(pending.messages);
+    if (!messageText) {
+      return;
+    }
+    if (shouldSkipSemanticProfileCapture(messageText)) {
+      logUserBindEvent("semantic-profile-capture-skipped-insufficient-signal", {
+        userId: identity.userId,
+        sessionId,
+        messagePreview: messageText.slice(0, 120)
+      });
+      return;
+    }
+    const fingerprint = hashId(`${sessionId}:${messageText}`);
+    this.pruneSemanticCaptureCache();
+    if (this.semanticCaptureInFlight.has(fingerprint)) {
+      return;
+    }
+    const processedAt = this.semanticCaptureCache.get(fingerprint);
+    if (processedAt && processedAt > Date.now() - 12 * 60 * 60 * 1e3) {
+      return;
+    }
+    await this.runSemanticProfileCapture(identity, sessionId, messageText, fingerprint);
+  }
+  async runSemanticProfileCapture(identity, sessionId, messageText, fingerprint) {
+    this.semanticCaptureInFlight.add(fingerprint);
+    try {
+      const extraction = await inferSemanticProfileExtraction(messageText, identity.profile);
+      if (!extraction?.shouldUpdate) {
+        logUserBindEvent("semantic-profile-capture-noop", {
+          userId: identity.userId,
+          sessionId,
+          confidence: extraction?.confidence ?? 0,
+          messagePreview: messageText.slice(0, 120)
+        });
+        this.semanticCaptureCache.set(fingerprint, Date.now());
+        this.clearSemanticProfileRetryState(fingerprint);
+        return;
+      }
+      const { patch, operations } = cleanupSemanticProfilePatch(
+        extraction.patch,
+        identity.profile,
+        extraction.operations
+      );
+      if (Object.keys(patch).length === 0) {
+        this.semanticCaptureCache.set(fingerprint, Date.now());
+        this.clearSemanticProfileRetryState(fingerprint);
+        return;
+      }
+      await this.updateMyProfile(
+        { sessionId },
+        {
+          ...patch,
+          source: "semantic-self-update"
+        },
+        operations
+      );
+      await this.removePendingSemanticRefineNote(sessionId, fingerprint);
+      logUserBindEvent("semantic-profile-capture-success", {
+        userId: identity.userId,
+        sessionId,
+        fields: Object.keys(patch),
+        operations,
+        confidence: extraction.confidence
+      });
+      this.semanticCaptureCache.set(fingerprint, Date.now());
+      this.clearSemanticProfileRetryState(fingerprint);
+    } catch (error) {
+      if (this.shouldRetrySemanticProfileCapture(error)) {
+        await this.ensurePendingSemanticRefineNote(sessionId, messageText, fingerprint);
+        this.scheduleSemanticProfileRetry(identity, sessionId, messageText, fingerprint, error);
+        return;
+      }
+      logUserBindEvent("semantic-profile-capture-failed", {
+        userId: identity.userId,
+        sessionId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.semanticCaptureInFlight.delete(fingerprint);
+    }
+  }
+  scheduleSemanticProfileRetry(identity, sessionId, messageText, fingerprint, error) {
+    const nextAttempt = (this.semanticCaptureRetryAttempts.get(fingerprint) ?? 0) + 1;
+    if (nextAttempt > SEMANTIC_PROFILE_RETRY_MAX_ATTEMPTS) {
+      logUserBindEvent("semantic-profile-capture-failed", {
+        userId: identity.userId,
+        sessionId,
+        attempt: nextAttempt - 1,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    const existing = this.semanticCaptureRetryTimers.get(fingerprint);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    this.semanticCaptureRetryAttempts.set(fingerprint, nextAttempt);
+    const delayMs = computeSemanticProfileRetryDelayMs(nextAttempt);
+    const timer = setTimeout(() => {
+      this.semanticCaptureRetryTimers.delete(fingerprint);
+      void this.runSemanticProfileCapture(identity, sessionId, messageText, fingerprint);
+    }, delayMs);
+    this.semanticCaptureRetryTimers.set(fingerprint, timer);
+    logUserBindEvent("semantic-profile-capture-retry-scheduled", {
+      userId: identity.userId,
+      sessionId,
+      attempt: nextAttempt,
+      delayMs,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+  schedulePendingSemanticSweep(delayMs = 1200) {
+    if (this.pendingSemanticSweepTimer) {
+      clearTimeout(this.pendingSemanticSweepTimer);
+    }
+    logUserBindEvent("pending-semantic-refine-sweep-scheduled", { delayMs });
+    this.pendingSemanticSweepTimer = setTimeout(() => {
+      this.pendingSemanticSweepTimer = null;
+      void this.runPendingSemanticSweep().catch((error) => {
+        logUserBindEvent("pending-semantic-refine-sweep-failed", {
+          message: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, delayMs);
+  }
+  async runPendingSemanticSweep() {
+    if (this.pendingSemanticSweepInFlight) {
+      logUserBindEvent("pending-semantic-refine-sweep-skipped", { reason: "already-in-flight" });
+      return;
+    }
+    this.pendingSemanticSweepInFlight = true;
+    try {
+      const profiles = this.store.listProfilesWithPendingSemanticRefine();
+      logUserBindEvent("pending-semantic-refine-sweep-start", {
+        profileCount: profiles.length,
+        userIds: profiles.slice(0, 10).map((profile) => profile.userId)
+      });
+      for (const profile of profiles) {
+        const entries = extractPendingSemanticRefineEntries(profile.notes);
+        logUserBindEvent("pending-semantic-refine-profile-scan", {
+          userId: profile.userId,
+          entryCount: entries.length
+        });
+        for (const entry of entries) {
+          const cachedAt = this.semanticCaptureCache.get(entry.fingerprint);
+          if (cachedAt && cachedAt > Date.now() - 12 * 60 * 60 * 1e3) {
+            logUserBindEvent("pending-semantic-refine-entry-skipped", {
+              userId: profile.userId,
+              fingerprint: entry.fingerprint,
+              reason: "recently-cached"
+            });
+            continue;
+          }
+          if (this.semanticCaptureInFlight.has(entry.fingerprint)) {
+            logUserBindEvent("pending-semantic-refine-entry-skipped", {
+              userId: profile.userId,
+              fingerprint: entry.fingerprint,
+              reason: "already-in-flight"
+            });
+            continue;
+          }
+          if (this.globalPendingSemanticRefines.has(entry.fingerprint)) {
+            logUserBindEvent("pending-semantic-refine-entry-skipped", {
+              userId: profile.userId,
+              fingerprint: entry.fingerprint,
+              reason: "process-global-in-flight"
+            });
+            continue;
+          }
+          await this.runPendingSemanticProfileCapture(profile, entry.messageText, entry.fingerprint);
+        }
+      }
+    } finally {
+      this.pendingSemanticSweepInFlight = false;
+    }
+  }
+  async runPendingSemanticProfileCapture(profile, messageText, fingerprint) {
+    if (this.globalPendingSemanticRefines.has(fingerprint)) {
+      logUserBindEvent("pending-semantic-refine-entry-skipped", {
+        userId: profile.userId,
+        fingerprint,
+        reason: "process-global-in-flight"
+      });
+      return;
+    }
+    this.globalPendingSemanticRefines.add(fingerprint);
+    this.semanticCaptureInFlight.add(fingerprint);
+    try {
+      logUserBindEvent("pending-semantic-refine-entry-start", {
+        userId: profile.userId,
+        fingerprint,
+        messagePreview: messageText.slice(0, 120)
+      });
+      const extraction = await inferSemanticProfileExtraction(messageText, profile);
+      if (!extraction?.shouldUpdate) {
+        logUserBindEvent("pending-semantic-refine-noop", {
+          userId: profile.userId,
+          fingerprint
+        });
+        this.semanticCaptureCache.set(fingerprint, Date.now());
+        this.clearSemanticProfileRetryState(fingerprint);
+        return;
+      }
+      const { patch, operations } = cleanupSemanticProfilePatch(
+        extraction.patch,
+        profile,
+        extraction.operations
+      );
+      const nextPatch = applyProfilePatchOperations(profile, patch, operations);
+      const cleanedNotes = removePendingSemanticRefineEntry(nextPatch.notes ?? profile.notes, fingerprint);
+      const updated = this.store.updateProfile(profile.userId, {
+        ...nextPatch,
+        notes: cleanedNotes,
+        source: "semantic-self-update"
+      });
+      const finalProfile = updated.notes?.includes(`[pending-profile-refine:${fingerprint}]`) ? this.store.replaceProfileNotes(
+        profile.userId,
+        removePendingSemanticRefineEntry(updated.notes, fingerprint),
+        "semantic-self-update"
+      ) : updated;
+      logUserBindEvent("pending-semantic-refine-recovered", {
+        userId: profile.userId,
+        fields: Object.keys(patch),
+        confidence: extraction.confidence,
+        notesCleared: !finalProfile.notes?.includes(`[pending-profile-refine:${fingerprint}]`)
+      });
+      this.semanticCaptureCache.set(fingerprint, Date.now());
+      this.clearSemanticProfileRetryState(fingerprint);
+    } catch (error) {
+      if (this.shouldRetrySemanticProfileCapture(error)) {
+        const nextAttempt = (this.semanticCaptureRetryAttempts.get(fingerprint) ?? 0) + 1;
+        this.semanticCaptureRetryAttempts.set(fingerprint, nextAttempt);
+        if (nextAttempt <= SEMANTIC_PROFILE_RETRY_MAX_ATTEMPTS) {
+          this.schedulePendingSemanticSweep(computeSemanticProfileRetryDelayMs(nextAttempt));
+          return;
+        }
+      }
+      logUserBindEvent("pending-semantic-refine-failed", {
+        userId: profile.userId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.semanticCaptureInFlight.delete(fingerprint);
+      this.globalPendingSemanticRefines.delete(fingerprint);
+    }
+  }
+  clearSemanticProfileRetryState(fingerprint) {
+    const timer = this.semanticCaptureRetryTimers.get(fingerprint);
+    if (timer) {
+      clearTimeout(timer);
+      this.semanticCaptureRetryTimers.delete(fingerprint);
+    }
+    this.semanticCaptureRetryAttempts.delete(fingerprint);
+  }
+  shouldRetrySemanticProfileCapture(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes("timed out") || normalized.includes("aborted due to timeout") || normalized.includes("network connection error") || normalized.includes("connection error") || normalized.includes("rate limit") || normalized.includes("429") || normalized.includes("503") || normalized.includes("busy");
+  }
+  async ensurePendingSemanticRefineNote(sessionId, messageText, fingerprint) {
+    const note = buildPendingSemanticRefineNote(messageText, fingerprint);
+    const identity = await this.resolveFromContext({ sessionId });
+    if (!identity) {
+      return;
+    }
+    if (identity.profile.notes?.includes(note)) {
+      return;
+    }
+    await this.updateMyProfile(
+      { sessionId },
+      {
+        notes: note,
+        source: "semantic-refine-pending"
+      },
+      { notes: "append" }
+    );
+  }
+  async removePendingSemanticRefineNote(sessionId, fingerprint) {
+    const identity = await this.resolveFromContext({ sessionId });
+    const currentNotes = identity?.profile.notes ?? null;
+    if (!currentNotes || !currentNotes.includes(`[pending-profile-refine:${fingerprint}]`)) {
+      return;
+    }
+    await this.updateMyProfile(
+      { sessionId },
+      {
+        notes: `[pending-profile-refine:${fingerprint}]`,
+        source: "semantic-self-update"
+      },
+      { notes: "remove" }
+    );
+  }
+  pruneSemanticCaptureCache() {
+    const cutoff = Date.now() - 12 * 60 * 60 * 1e3;
+    for (const [fingerprint, ts] of this.semanticCaptureCache.entries()) {
+      if (ts < cutoff) {
+        this.semanticCaptureCache.delete(fingerprint);
+      }
+    }
+  }
   async adminInstruction(toolName, instruction, context) {
     const requester = await this.resolveFromContext(context);
     const agentId = getAgentIdFromContext(context);
@@ -612,14 +1405,17 @@ var UserBindRuntime = class {
     this.host.registerHook?.(
       ["message:received", "message:preprocessed"],
       async (event) => {
-        await this.resolveFromContext(event);
+        const identity = await this.resolveFromContext(event);
+        if (identity) {
+          await this.captureProfileFromMessage(event, identity);
+        }
       },
       {
         name: "bamdra-user-bind-resolve",
         description: "Resolve runtime identity from channel sender metadata"
       }
     );
-    this.host.on?.("before_prompt_build", async (_event, context) => {
+    this.host.on?.("before_prompt_build", async (event, context) => {
       const identity = await this.resolveFromContext(context);
       if (!identity) {
         return;
@@ -639,9 +1435,16 @@ var UserBindRuntime = class {
     if (!registerTool) {
       return;
     }
+    const getMyProfileExecute = async (_id, params) => asTextResult(await this.getMyProfile(params));
+    const updateMyProfileExecute = async (_id, params) => asTextResult(await this.updateMyProfile(
+      params,
+      sanitizeProfilePatch(params),
+      extractProfilePatchOperations(params)
+    ));
+    const refreshMyBindingExecute = async (_id, params) => asTextResult(await this.refreshMyBinding(params));
     registerTool({
       name: "bamdra_user_bind_get_my_profile",
-      description: "Get the current user's bound profile",
+      description: "Get the current user's bound profile before replying so identity facts, timezone, and stable personal preferences can be used naturally in the response",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -649,30 +1452,48 @@ var UserBindRuntime = class {
           sessionId: { type: "string" }
         }
       },
-      execute: async (_id, params) => asTextResult(await this.getMyProfile(params))
+      execute: getMyProfileExecute
     });
     registerTool({
       name: "bamdra_user_bind_update_my_profile",
-      description: "Update the current user's own profile fields",
+      description: "Immediately write the current user's stable profile information when they clearly provide it, such as name, nickname, gender, age, birthday, timezone, interests, communication style, role, or durable notes",
       parameters: {
         type: "object",
         additionalProperties: false,
         required: ["sessionId"],
         properties: {
           sessionId: { type: "string" },
+          name: { type: "string" },
+          nameOperation: { type: "string", enum: ["replace", "append", "remove"] },
+          gender: { type: "string" },
+          genderOperation: { type: "string", enum: ["replace", "append", "remove"] },
+          birthDate: { type: "string" },
+          birthDateOperation: { type: "string", enum: ["replace", "append", "remove"] },
+          birthYear: { type: "string" },
+          birthYearOperation: { type: "string", enum: ["replace", "append", "remove"] },
+          age: { type: "string" },
+          ageOperation: { type: "string", enum: ["replace", "append", "remove"] },
           nickname: { type: "string" },
+          nicknameOperation: { type: "string", enum: ["replace", "append", "remove"] },
           preferences: { type: "string" },
+          preferencesOperation: { type: "string", enum: ["replace", "append", "remove"] },
           personality: { type: "string" },
+          personalityOperation: { type: "string", enum: ["replace", "append", "remove"] },
+          interests: { type: "string" },
+          interestsOperation: { type: "string", enum: ["replace", "append", "remove"] },
           role: { type: "string" },
+          roleOperation: { type: "string", enum: ["replace", "append", "remove"] },
           timezone: { type: "string" },
-          notes: { type: "string" }
+          timezoneOperation: { type: "string", enum: ["replace", "append", "remove"] },
+          notes: { type: "string" },
+          notesOperation: { type: "string", enum: ["replace", "append", "remove"] }
         }
       },
-      execute: async (_id, params) => asTextResult(await this.updateMyProfile(params, sanitizeProfilePatch(params)))
+      execute: updateMyProfileExecute
     });
     registerTool({
       name: "bamdra_user_bind_refresh_my_binding",
-      description: "Refresh the current user's identity binding",
+      description: "Refresh the current user's identity binding when the session looks unresolved, stale, or mapped to the wrong external identity, then fetch the profile again",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -680,32 +1501,75 @@ var UserBindRuntime = class {
           sessionId: { type: "string" }
         }
       },
-      execute: async (_id, params) => asTextResult(await this.refreshMyBinding(params))
+      execute: refreshMyBindingExecute
     });
-    for (const toolName of ADMIN_TOOL_NAMES) {
-      registerTool({
-        name: toolName,
-        description: `Administrative natural-language tool for ${toolName.replace("bamdra_user_bind_admin_", "")}`,
-        parameters: {
-          type: "object",
-          additionalProperties: false,
-          required: ["instruction"],
-          properties: {
-            instruction: { type: "string" },
-            sessionId: { type: "string" },
-            agentId: { type: "string" }
-          }
-        },
-        execute: async (_id, params) => asTextResult(await this.adminInstruction(toolName, String(params.instruction ?? ""), params))
-      });
-    }
-  }
-  async requireCurrentIdentity(context) {
-    const identity = await this.resolveFromContext(context);
-    if (!identity) {
-      throw new Error("Unable to resolve current user identity");
-    }
-    return identity;
+    registerTool({
+      name: SELF_TOOL_ALIASES[0],
+      description: "Alias of bamdra_user_bind_get_my_profile",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sessionId: { type: "string" }
+        }
+      },
+      execute: getMyProfileExecute
+    });
+    registerTool({
+      name: SELF_TOOL_ALIASES[1],
+      description: "Alias of bamdra_user_bind_update_my_profile",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["sessionId"],
+        properties: {
+          sessionId: { type: "string" },
+          nickname: { type: "string" },
+          preferences: { type: "string" },
+          personality: { type: "string" },
+          role: { type: "string" },
+          timezone: { type: "string" },
+          notes: { type: "string" }
+        }
+      },
+      execute: updateMyProfileExecute
+    });
+    registerTool({
+      name: SELF_TOOL_ALIASES[2],
+      description: "Alias of bamdra_user_bind_refresh_my_binding",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sessionId: { type: "string" }
+        }
+      },
+      execute: refreshMyBindingExecute
+    });
+    for (const toolName of ADMIN_TOOL_NAMES) {
+      registerTool({
+        name: toolName,
+        description: `Administrative natural-language tool for ${toolName.replace("bamdra_user_bind_admin_", "")}`,
+        parameters: {
+          type: "object",
+          additionalProperties: false,
+          required: ["instruction"],
+          properties: {
+            instruction: { type: "string" },
+            sessionId: { type: "string" },
+            agentId: { type: "string" }
+          }
+        },
+        execute: async (_id, params) => asTextResult(await this.adminInstruction(toolName, String(params.instruction ?? ""), params))
+      });
+    }
+  }
+  async requireCurrentIdentity(context) {
+    const identity = await this.resolveFromContext(context);
+    if (!identity) {
+      throw new Error("Unable to resolve current user identity");
+    }
+    return identity;
   }
   async tryResolveFeishuUser(openId) {
     logUserBindEvent("feishu-resolution-start", { openId });
@@ -714,6 +1578,7 @@ var UserBindRuntime = class {
       logUserBindEvent("feishu-resolution-skipped", { reason: "no-feishu-accounts-configured" });
       return null;
     }
+    const contactScopeBlockedAccounts = /* @__PURE__ */ new Set();
     for (const account of accounts) {
       try {
         const token = await this.getFeishuAppAccessToken(account);
@@ -746,6 +1611,9 @@ var UserBindRuntime = class {
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        if (looksLikeFeishuContactScopeError(message)) {
+          contactScopeBlockedAccounts.add(account.accountId);
+        }
         logUserBindEvent("feishu-resolution-attempt-failed", {
           accountId: account.accountId,
           openId,
@@ -777,63 +1645,18 @@ var UserBindRuntime = class {
       } catch {
       }
     }
+    if (contactScopeBlockedAccounts.size > 0) {
+      return {
+        userId: "",
+        source: "feishu-contact-scope-missing",
+        profilePatch: {
+          notes: renderFeishuContactScopeGuidance([...contactScopeBlockedAccounts])
+        }
+      };
+    }
     logUserBindEvent("feishu-resolution-empty", { openId });
     return null;
   }
-  async ensureFeishuScopeStatus() {
-    if (this.feishuScopeStatus) {
-      return this.feishuScopeStatus;
-    }
-    const accounts = readFeishuAccountsFromOpenClawConfig();
-    for (const account of accounts) {
-      try {
-        const token = await this.getFeishuAppAccessToken(account);
-        const result = await feishuJsonRequest(
-          account,
-          "/open-apis/application/v6/scopes",
-          token
-        );
-        const scopes = extractScopes(result);
-        this.feishuScopeStatus = {
-          scopes,
-          missingIdentityScopes: REQUIRED_FEISHU_IDENTITY_SCOPES.filter((scope) => !scopes.includes(scope)),
-          hasDocumentAccess: scopes.some((scope) => scope.startsWith("bitable:") || scope.startsWith("drive:") || scope.startsWith("docx:") || scope.startsWith("docs:"))
-        };
-        logUserBindEvent("feishu-scopes-read", {
-          accountId: account.accountId,
-          ...this.feishuScopeStatus
-        });
-        return this.feishuScopeStatus;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logUserBindEvent("feishu-scopes-attempt-failed", { accountId: account.accountId, message });
-      }
-    }
-    const executor = this.host.callTool ?? this.host.invokeTool;
-    if (typeof executor === "function") {
-      try {
-        const result = await executor.call(this.host, "feishu_app_scopes", {});
-        const scopes = extractScopes(result);
-        this.feishuScopeStatus = {
-          scopes,
-          missingIdentityScopes: REQUIRED_FEISHU_IDENTITY_SCOPES.filter((scope) => !scopes.includes(scope)),
-          hasDocumentAccess: scopes.some((scope) => scope.startsWith("bitable:") || scope.startsWith("drive:") || scope.startsWith("docx:") || scope.startsWith("docs:"))
-        };
-        logUserBindEvent("feishu-scopes-read", this.feishuScopeStatus);
-        return this.feishuScopeStatus;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logUserBindEvent("feishu-scopes-failed", { message });
-        this.store.recordIssue("feishu-scope-read", message);
-      }
-    }
-    this.feishuScopeStatus = {
-      scopes: [],
-      missingIdentityScopes: [...REQUIRED_FEISHU_IDENTITY_SCOPES],
-      hasDocumentAccess: false
-    };
-    return this.feishuScopeStatus;
-  }
   async getFeishuAppAccessToken(account) {
     const cached = this.feishuTokenCache.get(account.accountId);
     if (cached && cached.expiresAt > Date.now()) {
@@ -865,108 +1688,17 @@ var UserBindRuntime = class {
     });
     return token;
   }
-  async syncFeishuMirror(identity) {
-    const scopeStatus = await this.ensureFeishuScopeStatus();
-    if (!scopeStatus.hasDocumentAccess) {
-      return;
-    }
-    const executor = this.host.callTool ?? this.host.invokeTool;
-    if (typeof executor !== "function") {
-      return;
-    }
-    try {
-      const mirror = await this.ensureFeishuBitableMirror(executor.bind(this.host));
-      if (!mirror.appToken || !mirror.tableId) {
-        return;
-      }
-      const existing = await executor.call(this.host, "feishu_bitable_list_records", {
-        app_token: mirror.appToken,
-        table_id: mirror.tableId
-      });
-      const recordId = findBitableRecordId(existing, identity.userId);
-      const fields = {
-        user_id: identity.userId,
-        channel_type: identity.channelType,
-        open_id: identity.senderOpenId,
-        name: identity.profile.name,
-        nickname: identity.profile.nickname,
-        preferences: identity.profile.preferences,
-        personality: identity.profile.personality,
-        role: identity.profile.role,
-        timezone: identity.profile.timezone,
-        email: identity.profile.email,
-        avatar: identity.profile.avatar
-      };
-      if (recordId) {
-        await executor.call(this.host, "feishu_bitable_update_record", {
-          app_token: mirror.appToken,
-          table_id: mirror.tableId,
-          record_id: recordId,
-          fields
-        });
-      } else {
-        await executor.call(this.host, "feishu_bitable_create_record", {
-          app_token: mirror.appToken,
-          table_id: mirror.tableId,
-          fields
-        });
-      }
-      logUserBindEvent("feishu-bitable-sync-success", { userId: identity.userId });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logUserBindEvent("feishu-bitable-sync-failed", { userId: identity.userId, message });
-      this.store.recordIssue("feishu-bitable-sync", message, identity.userId);
-    }
-  }
-  async ensureFeishuBitableMirror(executor) {
-    if (this.bitableMirror?.appToken && this.bitableMirror?.tableId) {
-      return this.bitableMirror;
-    }
-    try {
-      const app = await executor("feishu_bitable_create_app", { name: "Bamdra User Bind" });
-      const appToken = extractDeepString(app, [
-        ["data", "app", "app_token"],
-        ["data", "app_token"],
-        ["app", "app_token"],
-        ["app_token"]
-      ]);
-      if (!appToken) {
-        return { appToken: null, tableId: null };
-      }
-      const meta = await executor("feishu_bitable_get_meta", { app_token: appToken });
-      const tableId = extractDeepString(meta, [
-        ["data", "tables", "0", "table_id"],
-        ["data", "items", "0", "table_id"],
-        ["tables", "0", "table_id"]
-      ]);
-      if (!tableId) {
-        this.store.recordIssue("feishu-bitable-init", "Unable to determine users table id from Feishu bitable metadata");
-        return { appToken, tableId: null };
-      }
-      for (const fieldName of ["user_id", "channel_type", "open_id", "name", "nickname", "preferences", "personality", "role", "timezone", "email", "avatar"]) {
-        try {
-          await executor("feishu_bitable_create_field", {
-            app_token: appToken,
-            table_id: tableId,
-            field_name: fieldName,
-            type: 1
-          });
-        } catch {
-        }
-      }
-      this.bitableMirror = { appToken, tableId };
-      logUserBindEvent("feishu-bitable-ready", this.bitableMirror);
-      return this.bitableMirror;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logUserBindEvent("feishu-bitable-init-failed", { message });
-      this.store.recordIssue("feishu-bitable-init", message);
-      return { appToken: null, tableId: null };
-    }
-  }
 };
 function createUserBindPlugin(api) {
-  return new UserBindRuntime(api, api.pluginConfig ?? api.config ?? api.plugin?.config);
+  const globalRecord = globalThis;
+  const existing = globalRecord[GLOBAL_RUNTIME_KEY];
+  if (isUserBindRuntimeLike(existing)) {
+    return existing;
+  }
+  const runtime = new UserBindRuntime(api, api.pluginConfig ?? api.config ?? api.plugin?.config);
+  runtime[GLOBAL_RUNTIME_BRAND_KEY] = true;
+  globalRecord[GLOBAL_RUNTIME_KEY] = runtime;
+  return runtime;
 }
 function register(api) {
   createUserBindPlugin(api).register();
@@ -976,12 +1708,12 @@ async function activate(api) {
 }
 function normalizeConfig(input) {
   const root = (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw", "data", "bamdra-user-bind");
-  const storeRoot = input?.localStorePath ?? root;
+  const storeRoot = expandHomePath(input?.localStorePath) ?? root;
   return {
     enabled: input?.enabled ?? true,
     localStorePath: storeRoot,
-    exportPath: input?.exportPath ?? (0, import_node_path.join)(storeRoot, "exports"),
-    profileMarkdownRoot: input?.profileMarkdownRoot ?? (0, import_node_path.join)(storeRoot, "profiles", "private"),
+    exportPath: expandHomePath(input?.exportPath) ?? (0, import_node_path.join)(storeRoot, "exports"),
+    profileMarkdownRoot: expandHomePath(input?.profileMarkdownRoot) ?? (0, import_node_path.join)(storeRoot, "profiles", "private"),
     cacheTtlMs: input?.cacheTtlMs ?? 30 * 60 * 1e3,
     adminAgents: input?.adminAgents?.length ? input.adminAgents : ["main"]
   };
@@ -993,6 +1725,9 @@ function exposeGlobalApi(runtime) {
     },
     async resolveIdentity(context) {
       return runtime.resolveFromContext(context);
+    },
+    async runPendingBindingSweep() {
+      return runtime.runPendingBindingSweep();
     }
   };
 }
@@ -1016,17 +1751,18 @@ function bootstrapOpenClawHost(config) {
   materializeBundledSkill(adminSkillSource, adminSkillTarget);
   const original = (0, import_node_fs.readFileSync)(configPath, "utf8");
   const parsed = JSON.parse(original);
-  const changed = ensureHostConfig(parsed, config, profileSkillTarget, adminSkillTarget);
+  const changed = ensureHostConfig(parsed, config, packageRoot, profileSkillTarget, adminSkillTarget);
   if (!changed) {
     return;
   }
   (0, import_node_fs.writeFileSync)(configPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
 }
-function ensureHostConfig(config, pluginConfig, profileSkillTarget, adminSkillTarget) {
+function ensureHostConfig(config, pluginConfig, packageRoot, profileSkillTarget, adminSkillTarget) {
   let changed = false;
   const plugins = ensureObject(config, "plugins");
   const entries = ensureObject(plugins, "entries");
+  const installs = ensureObject(plugins, "installs");
   const load = ensureObject(plugins, "load");
   const tools = ensureObject(config, "tools");
   const skills = ensureObject(config, "skills");
@@ -1037,6 +1773,11 @@ function ensureHostConfig(config, pluginConfig, profileSkillTarget, adminSkillTa
   changed = ensureArrayIncludes(plugins, "allow", PLUGIN_ID) || changed;
   changed = ensureArrayIncludes(load, "paths", (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw", "extensions")) || changed;
   changed = ensureArrayIncludes(skillsLoad, "extraDirs", (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw", "skills")) || changed;
+  changed = ensureInstallMetadata(
+    installs,
+    PLUGIN_ID,
+    readPluginInstallMetadata(PLUGIN_ID, packageRoot, (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw", "extensions", PLUGIN_ID))
+  ) || changed;
   if (entry.enabled !== true) {
     entry.enabled = true;
     changed = true;
@@ -1076,6 +1817,46 @@ function materializeBundledSkill(sourceDir, targetDir) {
   (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(targetDir), { recursive: true });
   (0, import_node_fs.cpSync)(sourceDir, targetDir, { recursive: true });
 }
+function readPluginInstallMetadata(pluginId, packageRoot, installPath) {
+  try {
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(packageRoot, "package.json"), "utf8"));
+    const packageName = typeof pkg.name === "string" ? pkg.name : pluginId;
+    const version = typeof pkg.version === "string" ? pkg.version : "0.0.0";
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      source: "npm",
+      spec: packageName,
+      installPath,
+      version,
+      resolvedName: packageName,
+      resolvedVersion: version,
+      resolvedSpec: `${packageName}@${version}`,
+      resolvedAt: now,
+      installedAt: now
+    };
+  } catch {
+    return null;
+  }
+}
+function ensureInstallMetadata(installs, pluginId, metadata) {
+  if (!metadata) {
+    return false;
+  }
+  const current = installs[pluginId];
+  if (current && typeof current === "object" && !Array.isArray(current)) {
+    const install = current;
+    let changed = false;
+    for (const [key, value] of Object.entries(metadata)) {
+      if (typeof install[key] !== "string" || install[key] === "") {
+        install[key] = value;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  installs[pluginId] = metadata;
+  return true;
+}
 function ensureToolNames(tools, values) {
   let changed = false;
   for (const value of values) {
@@ -1084,9 +1865,8 @@ function ensureToolNames(tools, values) {
   return changed;
 }
 function ensureAgentSkills(agents, skillId) {
-  const list = Array.isArray(agents.list) ? agents.list : [];
   let changed = false;
-  for (const item of list) {
+  for (const item of iterAgentConfigs(agents)) {
     if (!item || typeof item !== "object") {
       continue;
     }
@@ -1101,10 +1881,9 @@ function ensureAgentSkills(agents, skillId) {
   return changed;
 }
 function ensureAdminSkill(agents, skillId, adminAgents) {
-  const list = Array.isArray(agents.list) ? agents.list : [];
   let changed = false;
   let attached = false;
-  for (const item of list) {
+  for (const item of iterAgentConfigs(agents)) {
     if (!item || typeof item !== "object") {
       continue;
     }
@@ -1121,6 +1900,7 @@ function ensureAdminSkill(agents, skillId, adminAgents) {
     }
     attached = true;
   }
+  const list = Array.isArray(agents.list) ? agents.list : [];
   if (!attached && list.length > 0 && list[0] && typeof list[0] === "object") {
     const agent = list[0];
     const current = Array.isArray(agent.skills) ? [...agent.skills] : [];
@@ -1132,16 +1912,48 @@ function ensureAdminSkill(agents, skillId, adminAgents) {
   }
   return changed;
 }
+function* iterAgentConfigs(agents) {
+  const seen = /* @__PURE__ */ new Set();
+  const list = Array.isArray(agents.list) ? agents.list : [];
+  for (const item of list) {
+    if (item && typeof item === "object") {
+      const agent = item;
+      seen.add(agent);
+      yield agent;
+    }
+  }
+  if (list.length > 0) {
+    return;
+  }
+  for (const [key, value] of Object.entries(agents)) {
+    if (key === "list" || key === "defaults" || !value || typeof value !== "object" || Array.isArray(value)) {
+      continue;
+    }
+    const agent = value;
+    if (seen.has(agent)) {
+      continue;
+    }
+    seen.add(agent);
+    if (!getConfiguredAgentId(agent)) {
+      agent.id = key;
+    }
+    yield agent;
+  }
+}
 function mapProfileRow(row) {
   return {
     userId: String(row.user_id),
     name: asNullableString(row.name),
     gender: asNullableString(row.gender),
+    birthDate: asNullableString(row.birth_date),
+    birthYear: asNullableString(row.birth_year),
+    age: asNullableString(row.age),
     email: asNullableString(row.email),
     avatar: asNullableString(row.avatar),
     nickname: asNullableString(row.nickname),
     preferences: asNullableString(row.preferences),
     personality: asNullableString(row.personality),
+    interests: asNullableString(row.interests),
     role: asNullableString(row.role),
     timezone: asNullableString(row.timezone),
     notes: asNullableString(row.notes),
@@ -1162,12 +1974,12 @@ function parseIdentityContext(context) {
   const metadataText = asNullableString(record.text) ?? asNullableString(message.text) ?? asNullableString(record.content) ?? asNullableString(metadata.text) ?? asNullableString(input.text) ?? asNullableString(findNestedValue(record, ["message", "content", "text"]));
   const conversationInfo = metadataText ? extractTaggedJsonBlock(metadataText, "Conversation info (untrusted metadata)") : null;
   const senderInfo = metadataText ? extractTaggedJsonBlock(metadataText, "Sender (untrusted metadata)") : null;
-  const senderIdFromText = metadataText ? extractRegexValue(metadataText, /"sender_id"\s*:\s*"([^"]+)"/) : null;
+  const senderIdFromText = extractSenderIdFromMetadataText(metadataText);
   const senderNameFromText = metadataText ? extractRegexValue(metadataText, /"sender"\s*:\s*"([^"]+)"/) : null;
   const senderNameFromMessageLine = metadataText ? extractRegexValue(metadataText, /\]\s*([^\n:：]{1,40})\s*[:：]/) : null;
   const sessionId = asNullableString(record.sessionKey) ?? asNullableString(record.sessionId) ?? asNullableString(session.id) ?? asNullableString(conversation.id) ?? asNullableString(metadata.sessionId) ?? asNullableString(input.sessionId) ?? asNullableString(input.session?.id) ?? asNullableString(record.context?.sessionId) ?? asNullableString(conversationInfo?.session_id) ?? asNullableString(conversationInfo?.message_id);
-  const channelType = asNullableString(record.channelType) ?? asNullableString(channel.type) ?? asNullableString(metadata.channelType) ?? asNullableString(conversation?.provider) ?? asNullableString(record.provider) ?? asNullableString(conversationInfo?.provider) ?? inferChannelTypeFromSessionId(sessionId);
-  const openId = asNullableString(sender.id) ?? asNullableString(sender.open_id) ?? asNullableString(sender.openId) ?? asNullableString(sender.user_id) ?? asNullableString(senderInfo?.id) ?? asNullableString(conversationInfo?.sender_id) ?? senderIdFromText ?? extractOpenIdFromSessionId(sessionId);
+  const channelType = asNullableString(record.channelType) ?? asNullableString(channel.type) ?? asNullableString(metadata.channelType) ?? asNullableString(conversation?.provider) ?? asNullableString(record.provider) ?? asNullableString(conversationInfo?.provider) ?? inferChannelTypeFromSenderId(extractSenderId(record, sender, senderInfo, conversationInfo, message, senderIdFromText)) ?? inferChannelTypeFromSessionId(sessionId);
+  const openId = extractSenderId(record, sender, senderInfo, conversationInfo, message, senderIdFromText) ?? extractOpenIdFromSessionId(sessionId);
   const senderName = asNullableString(sender.name) ?? asNullableString(sender.display_name) ?? asNullableString(senderInfo?.name) ?? asNullableString(conversationInfo?.sender) ?? senderNameFromText ?? senderNameFromMessageLine;
   return {
     sessionId,
@@ -1176,102 +1988,629 @@ function parseIdentityContext(context) {
     senderName
   };
 }
-function findNestedRecord(root, ...paths) {
-  for (const path of paths) {
-    const value = findNestedValue(root, path);
-    if (value && typeof value === "object") {
-      return value;
-    }
+function enrichIdentityContext(context) {
+  const record = context && typeof context === "object" ? { ...context } : {};
+  const sessionManager = record.sessionManager && typeof record.sessionManager === "object" ? record.sessionManager : null;
+  if (!sessionManager) {
+    return record;
   }
-  return {};
+  const sessionSnapshot = readSessionManagerSnapshot(sessionManager);
+  if (!sessionSnapshot) {
+    return record;
+  }
+  if (!record.sessionId && sessionSnapshot.sessionId) {
+    record.sessionId = sessionSnapshot.sessionId;
+  }
+  if (!record.text && sessionSnapshot.metadataText) {
+    record.text = sessionSnapshot.metadataText;
+  }
+  const metadata = record.metadata && typeof record.metadata === "object" ? { ...record.metadata } : {};
+  if (!metadata.text && sessionSnapshot.metadataText) {
+    metadata.text = sessionSnapshot.metadataText;
+  }
+  if (!metadata.sessionId && sessionSnapshot.sessionId) {
+    metadata.sessionId = sessionSnapshot.sessionId;
+  }
+  if (Object.keys(metadata).length > 0) {
+    record.metadata = metadata;
+  }
+  if (!record.channelType && sessionSnapshot.channelType) {
+    record.channelType = sessionSnapshot.channelType;
+  }
+  if (!record.openId && sessionSnapshot.openId) {
+    record.openId = sessionSnapshot.openId;
+  }
+  return record;
 }
-function findNestedValue(root, path) {
-  let current = root;
-  for (const part of path) {
-    if (!current || typeof current !== "object") {
-      return null;
+function readSessionManagerSnapshot(sessionManager) {
+  try {
+    const getSessionId = sessionManager.getSessionId;
+    const getBranch = sessionManager.getBranch;
+    const sessionId = typeof getSessionId === "function" ? asNullableString(getSessionId()) : null;
+    const branch = typeof getBranch === "function" ? getBranch() : [];
+    if (!Array.isArray(branch) || branch.length === 0) {
+      return sessionId ? {
+        sessionId,
+        metadataText: null,
+        channelType: inferChannelTypeFromSessionId(sessionId),
+        openId: extractOpenIdFromSessionId(sessionId)
+      } : null;
     }
-    current = current[part];
+    for (let i = branch.length - 1; i >= 0; i -= 1) {
+      const entry = branch[i];
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const item = entry;
+      const message = item.message && typeof item.message === "object" ? item.message : null;
+      if (item.type !== "message" || !message || message.role !== "user") {
+        continue;
+      }
+      const metadataText = extractMessageText(message);
+      if (!metadataText || !looksLikeIdentityMetadata(metadataText)) {
+        continue;
+      }
+      const openId = extractSenderIdFromMetadataText(metadataText);
+      const channelType = inferChannelTypeFromSenderId(openId) ?? inferChannelTypeFromSessionId(sessionId);
+      return {
+        sessionId,
+        metadataText,
+        channelType,
+        openId
+      };
+    }
+    return sessionId ? {
+      sessionId,
+      metadataText: null,
+      channelType: inferChannelTypeFromSessionId(sessionId),
+      openId: extractOpenIdFromSessionId(sessionId)
+    } : null;
+  } catch (error) {
+    logUserBindEvent("session-manager-read-failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
   }
-  return current;
 }
-function extractTaggedJsonBlock(text, label) {
-  const start = text.indexOf(label);
-  if (start < 0) {
+function extractMessageText(message) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
     return null;
   }
-  const block = text.slice(start).match(/```json\s*([\s\S]*?)\s*```/i);
-  if (!block) {
+  const text = content.filter((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string").map((part) => String(part.text)).join("\n");
+  return text || null;
+}
+function looksLikeIdentityMetadata(text) {
+  return text.includes("Conversation info (untrusted metadata)") || text.includes("Sender (untrusted metadata)") || /"sender_id"\s*:\s*"/.test(text);
+}
+function extractUserUtterance(context) {
+  const record = context && typeof context === "object" ? context : {};
+  const rawText = extractHookContextText(record) ?? readLatestUserMessageFromSessionManager(record.sessionManager);
+  if (!rawText) {
     return null;
   }
-  try {
-    const parsed = JSON.parse(block[1]);
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
+  const stripped = stripIdentityMetadata(rawText);
+  if (!stripped) {
     return null;
   }
-}
-function inferChannelTypeFromSessionId(sessionId) {
-  if (!sessionId) {
+  if (looksLikeIdentityMetadata(stripped)) {
     return null;
   }
-  if (sessionId.includes(":feishu:")) {
-    return "feishu";
+  return stripped;
+}
+function buildSemanticCaptureInput(context, utteranceText) {
+  const record = context && typeof context === "object" ? context : {};
+  const recentDialogue = readRecentProfileCaptureDialogue(record.sessionManager, utteranceText);
+  if (!recentDialogue) {
+    return utteranceText;
   }
-  if (sessionId.includes(":telegram:")) {
-    return "telegram";
+  return [
+    "Recent profile-collection exchange:",
+    recentDialogue
+  ].join("\n");
+}
+function shouldSkipSemanticProfileCapture(text) {
+  const normalized = normalizeSemanticCaptureText(text);
+  if (!normalized) {
+    return true;
   }
-  if (sessionId.includes(":whatsapp:")) {
-    return "whatsapp";
+  if (isTrivialSemanticCaptureUtterance(normalized)) {
+    return true;
   }
-  return null;
+  const tokenCount = normalized.split(/\s+/).filter(Boolean).length;
+  if (normalized.length <= 4) {
+    return true;
+  }
+  return tokenCount <= 1 && !containsCjkCharacters(normalized);
 }
-function extractRegexValue(text, pattern) {
-  const match = text.match(pattern);
-  return match?.[1]?.trim() || null;
+function shouldIgnoreSemanticProfileCaptureCandidate(text) {
+  const normalized = normalizeSemanticCaptureText(text);
+  return !normalized || isTrivialSemanticCaptureUtterance(normalized);
 }
-function extractOpenIdFromSessionId(sessionId) {
-  if (!sessionId) {
-    return null;
-  }
-  const match = sessionId.match(/:([A-Za-z0-9_-]+)$/);
-  return match?.[1] ?? null;
+function isTrivialSemanticCaptureUtterance(normalized) {
+  const trivialUtterances = /* @__PURE__ */ new Set([
+    "hi",
+    "hello",
+    "hey",
+    "\u4F60\u597D",
+    "\u60A8\u597D",
+    "\u5728\u5417",
+    "\u5728\u4E48",
+    "\u5728\u4E0D\u5728",
+    "\u6709\u4EBA\u5417",
+    "ping",
+    "test",
+    "\u6D4B\u8BD5"
+  ]);
+  return trivialUtterances.has(normalized);
 }
-function getAgentIdFromContext(context) {
-  const record = context && typeof context === "object" ? context : {};
-  return asNullableString(record.agentId) ?? asNullableString(record.agent?.id) ?? asNullableString(record.agent?.name);
+function normalizeSemanticCaptureText(text) {
+  return text.trim().toLowerCase().replace(/[!?.,，。！？、;；:："'`~()\[\]{}<>@#%^&*_+=|\\/.-]+/g, " ").replace(/\s+/g, " ").trim();
 }
-function sanitizeProfilePatch(params) {
-  return {
-    nickname: asNullableString(params.nickname),
-    preferences: asNullableString(params.preferences),
-    personality: asNullableString(params.personality),
-    role: asNullableString(params.role),
-    timezone: asNullableString(params.timezone),
-    notes: asNullableString(params.notes)
-  };
+function containsCjkCharacters(text) {
+  return /[\u3400-\u9fff\uf900-\ufaff]/.test(text);
 }
-function parseAdminInstruction(instruction) {
-  const normalized = instruction.trim();
-  if (/issue|问题|失败/i.test(normalized)) {
-    return { action: "list_issues", userIds: [], patch: {} };
+function appendSemanticCaptureCandidate(existing, messageText) {
+  const normalizedCandidate = normalizeSemanticCaptureText(messageText);
+  if (!normalizedCandidate) {
+    return existing;
+  }
+  const deduped = existing.filter((item) => normalizeSemanticCaptureText(item) !== normalizedCandidate);
+  deduped.push(messageText.trim());
+  const recent = deduped.slice(-SEMANTIC_PROFILE_BATCH_MAX_FRAGMENTS);
+  while (recent.join("\n").length > SEMANTIC_PROFILE_BATCH_MAX_CHARS && recent.length > 1) {
+    recent.shift();
+  }
+  return recent;
+}
+function buildSemanticProfileBatchText(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return null;
   }
-  if (/merge|合并/i.test(normalized)) {
-    const userIds = normalized.match(/user[:=]([A-Za-z0-9:_-]+)/g)?.map((item) => item.split(/[:=]/)[1]) ?? [];
-    return { action: "merge", userIds, patch: {} };
+  const combined = messages.map((item) => item.trim()).filter(Boolean).join("\n");
+  return combined || null;
+}
+function extractHookContextText(record) {
+  const directText = normalizeHookText(
+    record.bodyForAgent ?? record.body ?? record.prompt ?? record.text ?? findNestedValue(record, ["context", "bodyForAgent"]) ?? findNestedValue(record, ["context", "body"]) ?? findNestedValue(record, ["context", "text"]) ?? findNestedValue(record, ["context", "content"])
+  );
+  if (directText) {
+    return directText;
   }
-  if (/sync|重同步|同步/i.test(normalized)) {
-    return { action: "sync", userIds: extractUserIds(normalized), patch: {} };
+  const message = findNestedRecord(record, ["message"], ["event", "message"], ["payload", "message"]);
+  const messageText = extractMessageText(message);
+  if (messageText) {
+    return messageText;
   }
-  if (/edit|修改|改成|更新/i.test(normalized)) {
-    return {
-      action: "edit",
-      userIds: extractUserIds(normalized),
-      patch: extractProfilePatch(normalized)
-    };
+  const inputText = extractTextFromInput(record.input);
+  if (inputText) {
+    return inputText;
   }
-  return {
-    action: "query",
+  const messages = Array.isArray(record.messages) ? record.messages : [];
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const item = messages[i];
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const messageRecord = item;
+    const role = asNullableString(messageRecord.role) ?? "user";
+    if (role !== "user") {
+      continue;
+    }
+    const text = normalizeHookText(messageRecord.text ?? messageRecord.content);
+    if (text) {
+      return text;
+    }
+  }
+  return null;
+}
+function extractTextFromInput(input) {
+  if (typeof input === "string") {
+    return normalizeHookText(input);
+  }
+  if (!input || typeof input !== "object") {
+    return null;
+  }
+  const record = input;
+  const directText = normalizeHookText(record.text ?? record.content);
+  if (directText) {
+    return directText;
+  }
+  const message = record.message && typeof record.message === "object" ? record.message : null;
+  const messageText = normalizeHookText(message?.text ?? message?.content);
+  if (messageText) {
+    return messageText;
+  }
+  const messages = Array.isArray(record.messages) ? record.messages : [];
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const item = messages[i];
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const messageRecord = item;
+    const role = asNullableString(messageRecord.role) ?? "user";
+    if (role !== "user") {
+      continue;
+    }
+    const text = normalizeHookText(messageRecord.text ?? messageRecord.content);
+    if (text) {
+      return text;
+    }
+  }
+  return null;
+}
+function normalizeHookText(value) {
+  if (typeof value === "string") {
+    return value.trim() || null;
+  }
+  if (Array.isArray(value)) {
+    const text = value.map((item) => {
+      if (!item || typeof item !== "object") {
+        return "";
+      }
+      return asNullableString(item.text) ?? "";
+    }).filter(Boolean).join("\n").trim();
+    return text || null;
+  }
+  return null;
+}
+function readRecentProfileCaptureDialogue(sessionManager, latestUserText) {
+  if (!sessionManager || typeof sessionManager !== "object") {
+    return null;
+  }
+  try {
+    const getBranch = sessionManager.getBranch;
+    const branch = typeof getBranch === "function" ? getBranch() : [];
+    if (!Array.isArray(branch) || branch.length === 0) {
+      return null;
+    }
+    const conversation = [];
+    for (let i = 0; i < branch.length; i += 1) {
+      const entry = branch[i];
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const item = entry;
+      const message = item.message && typeof item.message === "object" ? item.message : null;
+      if (item.type !== "message" || !message) {
+        continue;
+      }
+      const role = asNullableString(message.role);
+      if (role !== "assistant" && role !== "user") {
+        continue;
+      }
+      const text = extractMessageText(message);
+      if (!text || looksLikeIdentityMetadata(text)) {
+        continue;
+      }
+      conversation.push({ role, text: text.trim() });
+    }
+    for (let i = conversation.length - 1; i >= 0; i -= 1) {
+      const entry = conversation[i];
+      if (entry.role !== "user") {
+        continue;
+      }
+      const previous = conversation[i - 1];
+      if (!previous || previous.role !== "assistant" || !looksLikeProfileCollectionPrompt(previous.text)) {
+        continue;
+      }
+      const normalizedEntry = normalizeSemanticCaptureText(entry.text);
+      const normalizedLatest = normalizeSemanticCaptureText(latestUserText);
+      if (normalizedLatest && normalizedEntry && normalizedEntry !== normalizedLatest) {
+        continue;
+      }
+      return [
+        `assistant: ${previous.text}`,
+        `user: ${latestUserText}`
+      ].join("\n");
+    }
+  } catch (error) {
+    logUserBindEvent("session-manager-dialogue-read-failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return null;
+}
+function looksLikeProfileCollectionPrompt(text) {
+  const normalized = normalizeSemanticCaptureText(text);
+  if (!normalized) {
+    return false;
+  }
+  const keywords = [
+    "\u600E\u4E48\u79F0\u547C\u4F60",
+    "\u5982\u4F55\u79F0\u547C\u4F60",
+    "\u600E\u4E48\u53EB\u4F60",
+    "\u53EB\u4F60\u4EC0\u4E48",
+    "\u79F0\u547C",
+    "\u504F\u597D\u7684\u56DE\u7B54\u98CE\u683C",
+    "\u56DE\u590D\u98CE\u683C",
+    "\u56DE\u7B54\u98CE\u683C",
+    "\u6C9F\u901A\u98CE\u683C",
+    "\u4F60\u559C\u6B22\u6211\u600E\u4E48\u56DE\u590D",
+    "\u4F60\u66F4\u559C\u6B22",
+    "what should i call you",
+    "how should i address you",
+    "preferred style",
+    "reply style",
+    "response style"
+  ];
+  return keywords.some((keyword) => normalized.includes(normalizeSemanticCaptureText(keyword)));
+}
+function readLatestUserMessageFromSessionManager(sessionManager) {
+  if (!sessionManager || typeof sessionManager !== "object") {
+    return null;
+  }
+  try {
+    const getBranch = sessionManager.getBranch;
+    const branch = typeof getBranch === "function" ? getBranch() : [];
+    if (!Array.isArray(branch) || branch.length === 0) {
+      return null;
+    }
+    for (let i = branch.length - 1; i >= 0; i -= 1) {
+      const entry = branch[i];
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const item = entry;
+      const message = item.message && typeof item.message === "object" ? item.message : null;
+      if (item.type !== "message" || !message || message.role !== "user") {
+        continue;
+      }
+      const text = extractMessageText(message);
+      if (text && !looksLikeIdentityMetadata(text)) {
+        return text.trim();
+      }
+    }
+  } catch (error) {
+    logUserBindEvent("session-manager-user-message-read-failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return null;
+}
+function stripIdentityMetadata(text) {
+  const hadMetadata = looksLikeIdentityMetadata(text);
+  let cleaned = text.replace(/Conversation info \(untrusted metadata\):\s*```json[\s\S]*?```/gi, "").replace(/Sender \(untrusted metadata\):\s*```json[\s\S]*?```/gi, "").replace(/^\s*\[[^\n]*message_id[^\n]*\]\s*$/gim, "").replace(/^\s*\[[^\n]*sender_id[^\n]*\]\s*$/gim, "");
+  if (hadMetadata) {
+    cleaned = cleaned.replace(/^\s*[^\n:：]{1,40}[:：]\s*/m, "");
+  }
+  cleaned = cleaned.trim();
+  return cleaned || null;
+}
+function findNestedRecord(root, ...paths) {
+  for (const path of paths) {
+    const value = findNestedValue(root, path);
+    if (value && typeof value === "object") {
+      return value;
+    }
+  }
+  return {};
+}
+function findNestedValue(root, path) {
+  let current = root;
+  for (const part of path) {
+    if (!current || typeof current !== "object") {
+      return null;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function extractTaggedJsonBlock(text, label) {
+  const start = text.indexOf(label);
+  if (start < 0) {
+    return null;
+  }
+  const block = text.slice(start).match(/```json\s*([\s\S]*?)\s*```/i);
+  if (!block) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(block[1]);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function inferChannelTypeFromSessionId(sessionId) {
+  if (!sessionId) {
+    return null;
+  }
+  if (sessionId.includes(":feishu:")) {
+    return "feishu";
+  }
+  if (sessionId.includes(":telegram:")) {
+    return "telegram";
+  }
+  if (sessionId.includes(":whatsapp:")) {
+    return "whatsapp";
+  }
+  if (sessionId.includes(":discord:")) {
+    return "discord";
+  }
+  if (sessionId.includes(":googlechat:")) {
+    return "googlechat";
+  }
+  if (sessionId.includes(":slack:")) {
+    return "slack";
+  }
+  if (sessionId.includes(":mattermost:")) {
+    return "mattermost";
+  }
+  if (sessionId.includes(":signal:")) {
+    return "signal";
+  }
+  if (sessionId.includes(":imessage:")) {
+    return "imessage";
+  }
+  if (sessionId.includes(":msteams:")) {
+    return "msteams";
+  }
+  return null;
+}
+function inferChannelTypeFromSenderId(senderId) {
+  if (!senderId) {
+    return null;
+  }
+  if (/^(?:ou|oc)_[A-Za-z0-9_-]+$/.test(senderId)) {
+    return "feishu";
+  }
+  if (/@(?:s\.whatsapp\.net|g\.us)$/.test(senderId)) {
+    return "whatsapp";
+  }
+  if (/^users\/.+/.test(senderId) || /^spaces\/.+/.test(senderId)) {
+    return "googlechat";
+  }
+  return null;
+}
+function extractSenderId(record, sender, senderInfo, conversationInfo, message, senderIdFromText) {
+  return firstNonEmptyString(
+    asNullableString(record.openId),
+    asNullableString(record.senderId),
+    asNullableString(record.userId),
+    asNullableString(record.fromId),
+    asNullableString(record.participantId),
+    asNullableString(record.authorId),
+    asNullableString(sender.id),
+    asNullableString(sender.open_id),
+    asNullableString(sender.openId),
+    asNullableString(sender.user_id),
+    asNullableString(sender.userId),
+    asNullableString(sender.sender_id),
+    asNullableString(sender.senderId),
+    asNullableString(sender.from_id),
+    asNullableString(sender.fromId),
+    asNullableString(sender.author_id),
+    asNullableString(sender.authorId),
+    asNullableString(sender.chat_id),
+    asNullableString(sender.chatId),
+    asNullableString(sender.participant),
+    asNullableString(sender.participant_id),
+    asNullableString(sender.participantId),
+    asNullableString(sender.jid),
+    asNullableString(sender.handle),
+    asNullableString(sender.username),
+    asNullableString(sender.phone),
+    asNullableString(sender.phone_number),
+    asNullableString(findNestedValue(sender, ["from", "id"])),
+    asNullableString(findNestedValue(sender, ["author", "id"])),
+    asNullableString(findNestedValue(message, ["from", "id"])),
+    asNullableString(findNestedValue(message, ["author", "id"])),
+    asNullableString(findNestedValue(message, ["user", "id"])),
+    asNullableString(senderInfo?.id),
+    asNullableString(senderInfo?.user_id),
+    asNullableString(senderInfo?.sender_id),
+    asNullableString(conversationInfo?.sender_id),
+    asNullableString(conversationInfo?.user_id),
+    asNullableString(conversationInfo?.from_id),
+    senderIdFromText
+  );
+}
+function extractSenderIdFromMetadataText(metadataText) {
+  if (!metadataText) {
+    return null;
+  }
+  return firstNonEmptyString(
+    extractRegexValue(metadataText, /"sender_id"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"user_id"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"from_id"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"author_id"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"chat_id"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"participant"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"jid"\s*:\s*"([^"]+)"/),
+    extractRegexValue(metadataText, /"id"\s*:\s*"((?:ou|oc)_[^"]+)"/)
+  );
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function extractRegexValue(text, pattern) {
+  const match = text.match(pattern);
+  return match?.[1]?.trim() || null;
+}
+function extractOpenIdFromSessionId(sessionId) {
+  if (!sessionId) {
+    return null;
+  }
+  for (const channel of ["feishu", "telegram", "whatsapp", "discord", "googlechat", "slack", "mattermost", "signal", "imessage", "msteams"]) {
+    const marker = `:${channel}:`;
+    const channelIndex = sessionId.indexOf(marker);
+    if (channelIndex < 0) {
+      continue;
+    }
+    const remainder = sessionId.slice(channelIndex + marker.length);
+    const modeSeparator = remainder.indexOf(":");
+    if (modeSeparator < 0) {
+      continue;
+    }
+    const senderId = remainder.slice(modeSeparator + 1).trim();
+    if (senderId) {
+      return senderId;
+    }
+  }
+  const match = sessionId.match(/:([^:]+)$/);
+  return match?.[1]?.trim() || null;
+}
+function getAgentIdFromContext(context) {
+  const record = context && typeof context === "object" ? context : {};
+  return asNullableString(record.agentId) ?? asNullableString(record.agent?.id) ?? asNullableString(record.agent?.name);
+}
+function sanitizeProfilePatch(params) {
+  return {
+    name: asNullableString(params.name),
+    gender: asNullableString(params.gender),
+    birthDate: asNullableString(params.birthDate) ?? asNullableString(params.birthday),
+    birthYear: asNullableString(params.birthYear),
+    age: asNullableString(params.age),
+    nickname: asNullableString(params.nickname),
+    preferences: asNullableString(params.preferences),
+    personality: asNullableString(params.personality),
+    interests: asNullableString(params.interests),
+    role: asNullableString(params.role),
+    timezone: asNullableString(params.timezone),
+    notes: asNullableString(params.notes)
+  };
+}
+function extractProfilePatchOperations(params) {
+  const operations = {};
+  const fields = ["name", "gender", "birthDate", "birthYear", "age", "nickname", "preferences", "personality", "interests", "role", "timezone", "notes"];
+  for (const field of fields) {
+    const raw = asNullableString(params[`${field}Operation`]) ?? asNullableString(params[`${field}_operation`]);
+    if (raw === "replace" || raw === "append" || raw === "remove") {
+      operations[field] = raw;
+    }
+  }
+  return Object.keys(operations).length > 0 ? operations : void 0;
+}
+function parseAdminInstruction(instruction) {
+  const normalized = instruction.trim();
+  if (/issue|问题|失败/i.test(normalized)) {
+    return { action: "list_issues", userIds: [], patch: {} };
+  }
+  if (/merge|合并/i.test(normalized)) {
+    const userIds = normalized.match(/user[:=]([A-Za-z0-9:_-]+)/g)?.map((item) => item.split(/[:=]/)[1]) ?? [];
+    return { action: "merge", userIds, patch: {} };
+  }
+  if (/sync|重同步|同步/i.test(normalized)) {
+    return { action: "sync", userIds: extractUserIds(normalized), patch: {} };
+  }
+  if (/edit|修改|改成|更新/i.test(normalized)) {
+    return {
+      action: "edit",
+      userIds: extractUserIds(normalized),
+      patch: extractProfilePatch(normalized)
+    };
+  }
+  return {
+    action: "query",
     userIds: extractUserIds(normalized),
     patch: {}
   };
@@ -1281,11 +2620,32 @@ function extractUserIds(input) {
 }
 function extractProfilePatch(input) {
   const patch = {};
+  const name = input.match(/(?:name|姓名)[=:： ]([^,，]+)/i);
+  const gender = input.match(/(?:gender|性别)[=:： ]([^,，]+)/i);
+  const birthDate = input.match(/(?:birthdate|birthday|生日)[=:： ]([^,，]+)/i);
+  const birthYear = input.match(/(?:birthyear|出生年份|出生年月)[=:： ]([^,，]+)/i);
+  const age = input.match(/(?:age|年龄)[=:： ]([^,，]+)/i);
   const nickname = input.match(/(?:nickname|称呼)[=:： ]([^,，]+)$/i) ?? input.match(/(?:nickname|称呼)[=:： ]([^,，]+)/i);
   const role = input.match(/(?:role|职责|角色)[=:： ]([^,，]+)/i);
   const preferences = input.match(/(?:preferences|偏好)[=:： ]([^,，]+)/i);
   const personality = input.match(/(?:personality|性格)[=:： ]([^,，]+)/i);
+  const interests = input.match(/(?:interests|兴趣|爱好)[=:： ]([^,，]+)/i);
   const timezone = input.match(/(?:timezone|时区)[=:： ]([^,，]+)/i);
+  if (name) {
+    patch.name = name[1].trim();
+  }
+  if (gender) {
+    patch.gender = gender[1].trim();
+  }
+  if (birthDate) {
+    patch.birthDate = birthDate[1].trim();
+  }
+  if (birthYear) {
+    patch.birthYear = birthYear[1].trim();
+  }
+  if (age) {
+    patch.age = age[1].trim();
+  }
   if (nickname) {
     patch.nickname = nickname[1].trim();
   }
@@ -1298,6 +2658,9 @@ function extractProfilePatch(input) {
   if (personality) {
     patch.personality = personality[1].trim();
   }
+  if (interests) {
+    patch.interests = interests[1].trim();
+  }
   if (timezone) {
     patch.timezone = timezone[1].trim();
   }
@@ -1311,6 +2674,18 @@ function renderIdentityContext(identity) {
   if (identity.profile.name) {
     lines.push(`Name: ${identity.profile.name}`);
   }
+  if (identity.profile.gender) {
+    lines.push(`Gender: ${identity.profile.gender}`);
+  }
+  if (identity.profile.birthDate) {
+    lines.push(`Birth date: ${identity.profile.birthDate}`);
+  }
+  if (identity.profile.birthYear) {
+    lines.push(`Birth year: ${identity.profile.birthYear}`);
+  }
+  if (identity.profile.age) {
+    lines.push(`Age: ${identity.profile.age}`);
+  }
   if (identity.profile.nickname) {
     lines.push(`Preferred address: ${identity.profile.nickname}`);
   }
@@ -1323,6 +2698,9 @@ function renderIdentityContext(identity) {
   if (identity.profile.personality) {
     lines.push(`Personality: ${identity.profile.personality}`);
   }
+  if (identity.profile.interests) {
+    lines.push(`Interests: ${identity.profile.interests}`);
+  }
   if (identity.profile.role) {
     lines.push(`Role: ${identity.profile.role}`);
   }
@@ -1332,44 +2710,142 @@ function renderIdentityContext(identity) {
   return lines.join("\n");
 }
 function renderProfileMarkdown(profile) {
-  const frontmatter = [
+  const notes = sanitizeProfileNotes(profile.notes) ?? defaultProfileNotes();
+  const frontmatterLines = [
     "---",
-    `userId: ${escapeFrontmatter(profile.userId)}`,
-    `name: ${escapeFrontmatter(profile.name)}`,
-    `nickname: ${escapeFrontmatter(profile.nickname)}`,
-    `timezone: ${escapeFrontmatter(profile.timezone ?? "Asia/Shanghai")}`,
-    `preferences: ${escapeFrontmatter(profile.preferences ?? "\u5E7D\u9ED8\u8BD9\u8C10\u7684\u5BF9\u8BDD\u98CE\u683C\uFF0C\u4F46\u662F\u4E0D\u8FC7\u5206")}`,
-    `personality: ${escapeFrontmatter(profile.personality)}`,
-    `role: ${escapeFrontmatter(profile.role)}`,
+    `userId: ${escapeFrontmatter(profile.userId)}`
+  ];
+  if (profile.name) {
+    frontmatterLines.push(`name: ${escapeFrontmatter(profile.name)}`);
+  }
+  if (profile.gender) {
+    frontmatterLines.push(`gender: ${escapeFrontmatter(profile.gender)}`);
+  }
+  if (profile.birthDate) {
+    frontmatterLines.push(`birthDate: ${escapeFrontmatter(profile.birthDate)}`);
+  }
+  if (profile.birthYear) {
+    frontmatterLines.push(`birthYear: ${escapeFrontmatter(profile.birthYear)}`);
+  }
+  if (profile.age) {
+    frontmatterLines.push(`age: ${escapeFrontmatter(profile.age)}`);
+  }
+  if (profile.nickname) {
+    frontmatterLines.push(`nickname: ${escapeFrontmatter(profile.nickname)}`);
+  }
+  if (profile.timezone) {
+    frontmatterLines.push(`timezone: ${escapeFrontmatter(profile.timezone)}`);
+  }
+  if (profile.preferences) {
+    frontmatterLines.push(`preferences: ${escapeFrontmatter(profile.preferences)}`);
+  }
+  if (profile.personality) {
+    frontmatterLines.push(`personality: ${escapeFrontmatter(profile.personality)}`);
+  }
+  if (profile.interests) {
+    frontmatterLines.push(`interests: ${escapeFrontmatter(profile.interests)}`);
+  }
+  if (profile.role) {
+    frontmatterLines.push(`role: ${escapeFrontmatter(profile.role)}`);
+  }
+  frontmatterLines.push(
     `visibility: ${escapeFrontmatter(profile.visibility)}`,
     `source: ${escapeFrontmatter(profile.source)}`,
     `updatedAt: ${escapeFrontmatter(profile.updatedAt)}`,
+    `syncHash: ${escapeFrontmatter(computeProfilePayloadHash({
+      name: profile.name,
+      gender: profile.gender,
+      birthDate: profile.birthDate,
+      birthYear: profile.birthYear,
+      age: profile.age,
+      nickname: profile.nickname,
+      timezone: profile.timezone,
+      preferences: profile.preferences,
+      personality: profile.personality,
+      interests: profile.interests,
+      role: profile.role,
+      visibility: profile.visibility
+    }, notes))}`,
     "---"
-  ].join("\n");
-  const notes = sanitizeProfileNotes(profile.notes) ?? defaultProfileNotes();
+  );
+  const frontmatter = frontmatterLines.join("\n");
+  const confirmedProfileLines = renderConfirmedProfileSection(profile);
   return `${frontmatter}
 
 # \u7528\u6237\u753B\u50CF
 
-\u8FD9\u4E2A\u6587\u4EF6\u662F\u5F53\u524D\u7528\u6237\u7684\u53EF\u7F16\u8F91\u753B\u50CF\u955C\u50CF\u3002\u4F60\u53EF\u4EE5\u76F4\u63A5\u4FEE\u6539\u4E0A\u9762\u7684\u5B57\u6BB5\u548C\u4E0B\u9762\u7684\u8BF4\u660E\u5185\u5BB9\u3002
+\u8FD9\u4E2A\u6587\u4EF6\u7531\u7CFB\u7EDF\u7EF4\u62A4\u3002Frontmatter \u662F\u7CFB\u7EDF\u673A\u5668\u8BFB\u5199\u7684\u7ED3\u6784\u5316\u6E90\uFF1B\u4E0B\u9762\u7684\u201C\u5DF2\u786E\u8BA4\u753B\u50CF\u201D\u662F\u7ED9\u4EBA\u770B\u7684\u540C\u6B65\u955C\u50CF\u3002\u6CA1\u6709\u51FA\u73B0\u7684\u5B57\u6BB5\uFF0C\u8868\u793A\u5F53\u524D\u8FD8\u6CA1\u6709\u786E\u8BA4\uFF0C\u4E0D\u4EE3\u8868\u7A7A\u503C\u7ED3\u8BBA\u3002
 
-## \u4F7F\u7528\u5EFA\u8BAE
+## \u5DF2\u786E\u8BA4\u753B\u50CF
 
-- \u5E38\u7528\u79F0\u547C\uFF1A\u4F8B\u5982\u201C\u8001\u677F\u201D
-- \u65F6\u533A\uFF1A\u4F8B\u5982 Asia/Shanghai
-- \u98CE\u683C\u504F\u597D\uFF1A\u4F8B\u5982\u201C\u5E7D\u9ED8\u8BD9\u8C10\u7684\u5BF9\u8BDD\u98CE\u683C\uFF0C\u4F46\u662F\u4E0D\u8FC7\u5206\u201D
-- \u89D2\u8272\u4FE1\u606F\uFF1A\u4F8B\u5982\u5DE5\u4F5C\u804C\u8D23\u3001\u534F\u4F5C\u8FB9\u754C\u3001\u5E38\u89C1\u4EFB\u52A1
-- \u5176\u4ED6\u5907\u6CE8\uFF1A\u4F8B\u5982\u7981\u5FCC\u3001\u4E60\u60EF\u3001\u8F93\u51FA\u504F\u597D
+${confirmedProfileLines}
 
-## \u5907\u6CE8
+## \u8865\u5145\u5907\u6CE8
 
 ${notes}
 `;
 }
+function renderConfirmedProfileSection(profile) {
+  const rows = [];
+  if (profile.name) {
+    rows.push(`- \u59D3\u540D\uFF1A${profile.name}`);
+  }
+  if (profile.gender) {
+    rows.push(`- \u6027\u522B\uFF1A${profile.gender}`);
+  }
+  if (profile.birthDate) {
+    rows.push(`- \u751F\u65E5\uFF1A${profile.birthDate}`);
+  }
+  if (profile.birthYear) {
+    rows.push(`- \u51FA\u751F\u5E74\u4EFD\uFF1A${profile.birthYear}`);
+  }
+  if (profile.age) {
+    rows.push(`- \u5E74\u9F84\uFF1A${profile.age}`);
+  }
+  if (profile.nickname) {
+    rows.push(`- \u79F0\u547C\uFF1A${profile.nickname}`);
+  }
+  if (profile.preferences) {
+    rows.push(`- \u56DE\u7B54\u504F\u597D\uFF1A${profile.preferences}`);
+  }
+  if (profile.personality) {
+    rows.push(`- \u98CE\u683C\u504F\u597D\uFF1A${profile.personality}`);
+  }
+  if (profile.interests) {
+    rows.push(`- \u5174\u8DA3\u7231\u597D\uFF1A${profile.interests}`);
+  }
+  if (profile.role) {
+    rows.push(`- \u89D2\u8272\u8EAB\u4EFD\uFF1A${profile.role}`);
+  }
+  if (profile.timezone) {
+    rows.push(`- \u65F6\u533A\uFF1A${profile.timezone}`);
+  }
+  return rows.length > 0 ? rows.join("\n") : "- \u6682\u65E0\u5DF2\u786E\u8BA4\u7684\u7ED3\u6784\u5316\u753B\u50CF\u5B57\u6BB5";
+}
+function computeProfilePayloadHash(patch, notes) {
+  return hashId(JSON.stringify({
+    name: patch.name ?? null,
+    gender: patch.gender ?? null,
+    birthDate: patch.birthDate ?? null,
+    birthYear: patch.birthYear ?? null,
+    age: patch.age ?? null,
+    nickname: patch.nickname ?? null,
+    timezone: patch.timezone ?? null,
+    preferences: patch.preferences ?? null,
+    personality: patch.personality ?? null,
+    interests: patch.interests ?? null,
+    role: patch.role ?? null,
+    visibility: patch.visibility ?? "private",
+    notes: sanitizeProfileNotes(notes) ?? null
+  }));
+}
 function parseProfileMarkdown(markdown) {
   const lines = markdown.split(/\r?\n/);
   const patch = {};
   let notes = null;
+  let updatedAt = null;
+  let source = null;
+  let syncHash = null;
   let index = 0;
   if (lines[index] === "---") {
     index += 1;
@@ -1379,7 +2855,15 @@ function parseProfileMarkdown(markdown) {
       if (separatorIndex > 0) {
         const key = line.slice(0, separatorIndex).trim();
         const value = line.slice(separatorIndex + 1).trim();
-        applyFrontmatterField(patch, key, value);
+        if (key === "updatedAt") {
+          updatedAt = value === "null" ? null : value;
+        } else if (key === "source") {
+          source = value === "null" ? null : value;
+        } else if (key === "syncHash") {
+          syncHash = value === "null" ? null : value;
+        } else {
+          applyFrontmatterField(patch, key, value);
+        }
       }
       index += 1;
     }
@@ -1388,19 +2872,30 @@ function parseProfileMarkdown(markdown) {
     }
   }
   const body = lines.slice(index).join("\n");
-  const notesMatch = body.match(/##\s*备注\s*\n([\s\S]*)$/);
+  const notesMatch = body.match(/##\s*(?:补充备注|备注)\s*\n([\s\S]*)$/);
   if (notesMatch?.[1]) {
     notes = sanitizeProfileNotes(notesMatch[1]);
   }
   return {
     profilePatch: patch,
-    notes
+    notes,
+    updatedAt,
+    source,
+    syncHash
   };
 }
 function applyFrontmatterField(patch, key, value) {
   const normalized = value === "null" ? null : value;
   if (key === "name") {
     patch.name = normalized;
+  } else if (key === "gender") {
+    patch.gender = normalized;
+  } else if (key === "birthDate") {
+    patch.birthDate = normalized;
+  } else if (key === "birthYear") {
+    patch.birthYear = normalized;
+  } else if (key === "age") {
+    patch.age = normalized;
   } else if (key === "nickname") {
     patch.nickname = normalized;
   } else if (key === "timezone") {
@@ -1409,16 +2904,14 @@ function applyFrontmatterField(patch, key, value) {
     patch.preferences = normalized;
   } else if (key === "personality") {
     patch.personality = normalized;
+  } else if (key === "interests") {
+    patch.interests = normalized;
   } else if (key === "role") {
     patch.role = normalized;
   } else if (key === "visibility") {
     patch.visibility = normalized === "shared" ? "shared" : "private";
   }
 }
-function hasProfileDifference(current, patch) {
-  const entries = Object.entries(patch);
-  return entries.some(([key, value]) => value != null && current[key] !== value);
-}
 function renderYamlList(rows) {
   if (rows.length === 0) {
     return "[]\n";
@@ -1463,6 +2956,386 @@ function asTextResult(value) {
 function asNullableString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function expandHomePath(value) {
+  const text = asNullableString(value);
+  if (!text) {
+    return null;
+  }
+  if (text === "~") {
+    return (0, import_node_os.homedir)();
+  }
+  if (text.startsWith("~/")) {
+    return (0, import_node_path.join)((0, import_node_os.homedir)(), text.slice(2));
+  }
+  return text;
+}
+function computeSemanticProfileRetryDelayMs(attempt) {
+  const base = Number(process.env.BAMDRA_USER_BIND_RETRY_BASE_MS ?? 5e3);
+  const safeBase = Number.isFinite(base) && base > 0 ? base : 5e3;
+  return safeBase * Math.max(1, attempt);
+}
+function buildPendingSemanticRefineNote(messageText, fingerprint) {
+  const compact = messageText.replace(/\s+/g, " ").trim().slice(0, 120);
+  return `[pending-profile-refine:${fingerprint}] ${compact}`;
+}
+function extractPendingSemanticRefineEntries(notes) {
+  const value = sanitizeProfileNotes(notes);
+  if (!value) {
+    return [];
+  }
+  const entries = [];
+  const pattern = /\[pending-profile-refine:([a-f0-9]+)\]\s*([^\n]+)/g;
+  for (const match of value.matchAll(pattern)) {
+    const fingerprint = match[1]?.trim();
+    const messageText = match[2]?.trim();
+    if (!fingerprint || !messageText) {
+      continue;
+    }
+    entries.push({ fingerprint, messageText });
+  }
+  return entries;
+}
+function removePendingSemanticRefineEntry(notes, fingerprint) {
+  const value = sanitizeProfileNotes(notes);
+  if (!value) {
+    return null;
+  }
+  const pattern = new RegExp(`(?:^|\\n)\\[pending-profile-refine:${escapeRegExp(fingerprint)}\\][^\\n]*(?=\\n|$)`, "g");
+  const cleaned = value.replace(pattern, "").replace(/\n{3,}/g, "\n\n").trim();
+  return cleaned || null;
+}
+async function inferSemanticProfileExtraction(messageText, currentProfile) {
+  const model = readProfileExtractorModelFromOpenClawConfig();
+  if (!model) {
+    return null;
+  }
+  logUserBindEvent("semantic-profile-extractor-request", {
+    providerId: model.providerId,
+    modelId: model.modelId,
+    baseUrl: model.baseUrl,
+    timeoutMs: SEMANTIC_PROFILE_CAPTURE_TIMEOUT_MS,
+    messageChars: messageText.length
+  });
+  const response = await fetch(`${model.baseUrl}/chat/completions`, {
+    method: "POST",
+    signal: AbortSignal.timeout(SEMANTIC_PROFILE_CAPTURE_TIMEOUT_MS),
+    headers: {
+      authorization: `Bearer ${model.apiKey}`,
+      "content-type": "application/json; charset=utf-8"
+    },
+    body: JSON.stringify({
+      model: model.modelId,
+      temperature: 0,
+      max_tokens: 400,
+      response_format: { type: "json_object" },
+      messages: [
+        {
+          role: "system",
+          content: [
+            "You extract stable user-profile information from a single user message, a short window of recent user messages, or a brief assistant-question plus user-answer exchange from the same conversation.",
+            "Return JSON only.",
+            "Only capture durable, reusable identity facts, preferences, and personal profile details that should affect future conversations.",
+            "Ignore transient task requirements, one-off requests, or speculative guesses.",
+            "Prefer precision, but do not miss clear self-descriptions or durable profile facts.",
+            "Allowed fields: name, gender, birthDate, birthYear, age, nickname, preferences, personality, interests, role, timezone, notes.",
+            "For each field, also decide the update operation: replace, append, or remove.",
+            "Use the structured fields whenever possible instead of dumping transcripts into notes.",
+            "notes is only for durable boundaries or habits that do not fit the structured fields cleanly.",
+            "Use append when the user adds another stable fact or preference without revoking the old one.",
+            "Use replace when the user corrects or changes an existing stable fact or preference.",
+            "Use remove when the user clearly asks to drop a specific old fact or preference.",
+            "Do not require rigid trigger phrases. Judge by meaning, not literal wording.",
+            "If the input includes a recent assistant profile-collection question followed by a short user answer, use that dialogue context to resolve what the user meant.",
+            "Treat meta-instructions about saving or updating the profile as control signals, not profile content themselves.",
+            "Do not copy placeholders, examples, or template language into the patch.",
+            'Return exactly this shape: {"should_update":boolean,"confidence":number,"patch":{"name":string?,"gender":string?,"birthDate":string?,"birthYear":string?,"age":string?,"nickname":string?,"preferences":string?,"personality":string?,"interests":string?,"role":string?,"timezone":string?,"notes":string?},"operations":{"name":"replace|append|remove"?,"gender":"replace|append|remove"?,"birthDate":"replace|append|remove"?,"birthYear":"replace|append|remove"?,"age":"replace|append|remove"?,"nickname":"replace|append|remove"?,"preferences":"replace|append|remove"?,"personality":"replace|append|remove"?,"interests":"replace|append|remove"?,"role":"replace|append|remove"?,"timezone":"replace|append|remove"?,"notes":"replace|append|remove"?}}'
+          ].join("\n")
+        },
+        {
+          role: "user",
+          content: JSON.stringify({
+            current_profile: {
+              name: currentProfile.name,
+              gender: currentProfile.gender,
+              birthDate: currentProfile.birthDate,
+              birthYear: currentProfile.birthYear,
+              age: currentProfile.age,
+              nickname: currentProfile.nickname,
+              preferences: currentProfile.preferences,
+              personality: currentProfile.personality,
+              interests: currentProfile.interests,
+              role: currentProfile.role,
+              timezone: currentProfile.timezone,
+              notes: currentProfile.notes
+            },
+            latest_user_message: messageText
+          })
+        }
+      ]
+    })
+  });
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(`semantic profile extractor request failed: ${JSON.stringify(payload)}`);
+  }
+  const content = extractOpenAiMessageContent(payload);
+  const parsed = parseSemanticExtractionResult(content);
+  if (!parsed) {
+    throw new Error(`semantic profile extractor returned unreadable content: ${content}`);
+  }
+  return parsed;
+}
+function extractOpenAiMessageContent(payload) {
+  const choices = Array.isArray(payload.choices) ? payload.choices : [];
+  const first = choices[0];
+  if (!first || typeof first !== "object") {
+    return "";
+  }
+  const message = first.message;
+  if (!message || typeof message !== "object") {
+    return "";
+  }
+  const content = message.content;
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((item) => {
+    if (!item || typeof item !== "object") {
+      return "";
+    }
+    const record = item;
+    return asNullableString(record.text) ?? "";
+  }).filter(Boolean).join("\n").trim();
+}
+function parseSemanticExtractionResult(content) {
+  const jsonText = extractJsonObject(content);
+  if (!jsonText) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(jsonText);
+    const patchInput = parsed.patch && typeof parsed.patch === "object" ? parsed.patch : {};
+    const operationsInput = parsed.operations && typeof parsed.operations === "object" ? parsed.operations : {};
+    return {
+      shouldUpdate: parsed.should_update === true || parsed.shouldUpdate === true,
+      confidence: Number(parsed.confidence ?? 0),
+      patch: {
+        name: asNullableString(patchInput.name),
+        gender: asNullableString(patchInput.gender),
+        birthDate: asNullableString(patchInput.birthDate),
+        birthYear: asNullableString(patchInput.birthYear),
+        age: asNullableString(patchInput.age),
+        nickname: asNullableString(patchInput.nickname),
+        preferences: asNullableString(patchInput.preferences),
+        personality: asNullableString(patchInput.personality),
+        interests: asNullableString(patchInput.interests),
+        role: asNullableString(patchInput.role),
+        timezone: asNullableString(patchInput.timezone),
+        notes: asNullableString(patchInput.notes)
+      },
+      operations: parseProfilePatchOperations(operationsInput)
+    };
+  } catch {
+    return null;
+  }
+}
+function parseProfilePatchOperations(input) {
+  const operations = {};
+  for (const field of ["name", "gender", "birthDate", "birthYear", "age", "nickname", "preferences", "personality", "interests", "role", "timezone", "notes"]) {
+    const raw = asNullableString(input[field]);
+    if (raw === "replace" || raw === "append" || raw === "remove") {
+      operations[field] = raw;
+    }
+  }
+  return Object.keys(operations).length > 0 ? operations : void 0;
+}
+function extractJsonObject(content) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fenced?.[1]) {
+    return fenced[1].trim();
+  }
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    return trimmed.slice(start, end + 1);
+  }
+  return null;
+}
+function cleanupSemanticProfilePatch(patch, currentProfile, operations) {
+  const next = {};
+  const nextOperations = {};
+  const name = asNullableString(patch.name);
+  const gender = asNullableString(patch.gender);
+  const birthDate = asNullableString(patch.birthDate);
+  const birthYear = asNullableString(patch.birthYear);
+  const age = asNullableString(patch.age);
+  const nickname = asNullableString(patch.nickname);
+  const preferences = asNullableString(patch.preferences);
+  const personality = asNullableString(patch.personality);
+  const interests = asNullableString(patch.interests);
+  const role = asNullableString(patch.role);
+  const timezone = asNullableString(patch.timezone);
+  const notes = asNullableString(patch.notes);
+  if (name && name !== currentProfile.name) {
+    next.name = name;
+    if (operations?.name) {
+      nextOperations.name = operations.name;
+    }
+  }
+  if (gender && gender !== currentProfile.gender) {
+    next.gender = gender;
+    if (operations?.gender) {
+      nextOperations.gender = operations.gender;
+    }
+  }
+  if (birthDate && birthDate !== currentProfile.birthDate) {
+    next.birthDate = birthDate;
+    if (operations?.birthDate) {
+      nextOperations.birthDate = operations.birthDate;
+    }
+  }
+  if (birthYear && birthYear !== currentProfile.birthYear) {
+    next.birthYear = birthYear;
+    if (operations?.birthYear) {
+      nextOperations.birthYear = operations.birthYear;
+    }
+  }
+  if (age && age !== currentProfile.age) {
+    next.age = age;
+    if (operations?.age) {
+      nextOperations.age = operations.age;
+    }
+  }
+  if (nickname && nickname !== currentProfile.nickname) {
+    next.nickname = nickname;
+    if (operations?.nickname) {
+      nextOperations.nickname = operations.nickname;
+    }
+  }
+  if (preferences && preferences !== currentProfile.preferences) {
+    next.preferences = preferences;
+    if (operations?.preferences) {
+      nextOperations.preferences = operations.preferences;
+    }
+  }
+  if (personality && personality !== currentProfile.personality) {
+    next.personality = personality;
+    if (operations?.personality) {
+      nextOperations.personality = operations.personality;
+    }
+  }
+  if (interests && interests !== currentProfile.interests) {
+    next.interests = interests;
+    if (operations?.interests) {
+      nextOperations.interests = operations.interests;
+    }
+  }
+  if (role && role !== currentProfile.role) {
+    next.role = role;
+    if (operations?.role) {
+      nextOperations.role = operations.role;
+    }
+  }
+  if (timezone && timezone !== currentProfile.timezone) {
+    next.timezone = timezone;
+    if (operations?.timezone) {
+      nextOperations.timezone = operations.timezone;
+    }
+  }
+  if (notes) {
+    next.notes = notes;
+    if (operations?.notes) {
+      nextOperations.notes = operations.notes;
+    }
+  }
+  return {
+    patch: next,
+    operations: Object.keys(nextOperations).length > 0 ? nextOperations : void 0
+  };
+}
+function applyProfilePatchOperations(currentProfile, patch, operations) {
+  const next = {};
+  const fields = ["name", "gender", "birthDate", "birthYear", "age", "nickname", "preferences", "personality", "interests", "role", "timezone", "notes"];
+  for (const field of fields) {
+    if (patch[field] === void 0) {
+      continue;
+    }
+    const currentValue = currentProfile[field];
+    const incomingValue = asNullableString(patch[field]);
+    const operation = operations?.[field] ?? defaultProfileFieldOperation(field);
+    const resolved = resolveProfileFieldUpdate(field, currentValue, incomingValue, operation);
+    if (resolved !== void 0) {
+      next[field] = resolved;
+    }
+  }
+  return next;
+}
+function defaultProfileFieldOperation(field) {
+  if (field === "notes" || field === "interests") {
+    return "append";
+  }
+  return "replace";
+}
+function resolveProfileFieldUpdate(field, currentValue, incomingValue, operation) {
+  if (operation === "remove") {
+    if (!currentValue) {
+      return void 0;
+    }
+    if (!incomingValue) {
+      return null;
+    }
+    const removed = removeProfileFeatureValue(currentValue, incomingValue);
+    return removed === currentValue ? void 0 : removed;
+  }
+  if (!incomingValue) {
+    return void 0;
+  }
+  if (operation === "append") {
+    if (field === "notes") {
+      const mergedNotes = joinNotes(currentValue, incomingValue);
+      return mergedNotes === currentValue ? void 0 : mergedNotes;
+    }
+    const appended = appendProfileFeatureValue(currentValue, incomingValue);
+    return appended === currentValue ? void 0 : appended;
+  }
+  return incomingValue === currentValue ? void 0 : incomingValue;
+}
+function appendProfileFeatureValue(currentValue, incomingValue) {
+  if (!currentValue) {
+    return incomingValue;
+  }
+  const currentItems = splitProfileFeatureValues(currentValue);
+  const incomingItems = splitProfileFeatureValues(incomingValue);
+  const merged = [...currentItems];
+  for (const item of incomingItems) {
+    if (!merged.includes(item)) {
+      merged.push(item);
+    }
+  }
+  return merged.join("\uFF1B");
+}
+function removeProfileFeatureValue(currentValue, incomingValue) {
+  const currentItems = splitProfileFeatureValues(currentValue);
+  const removals = new Set(splitProfileFeatureValues(incomingValue));
+  const nextItems = currentItems.filter((item) => !removals.has(item));
+  if (nextItems.length === currentItems.length) {
+    return currentValue;
+  }
+  return nextItems.length > 0 ? nextItems.join("\uFF1B") : null;
+}
+function splitProfileFeatureValues(value) {
+  return value.split(/[\n;；,，、]+/u).map((item) => item.trim()).filter(Boolean);
+}
 function ensureObject(parent, key) {
   const current = parent[key];
   if (current && typeof current === "object" && !Array.isArray(current)) {
@@ -1484,60 +3357,6 @@ function ensureArrayIncludes(parent, key, value) {
   parent[key] = current;
   return true;
 }
-function extractScopes(result) {
-  const candidates = [
-    findNestedValue(result, ["data", "scopes"]),
-    findNestedValue(result, ["scopes"]),
-    findNestedValue(result, ["data", "items"])
-  ];
-  for (const candidate of candidates) {
-    if (!Array.isArray(candidate)) {
-      continue;
-    }
-    const scopes = candidate.map((item) => {
-      if (typeof item === "string") {
-        return item;
-      }
-      if (item && typeof item === "object") {
-        const record = item;
-        const scope = record.scope ?? record.name;
-        return typeof scope === "string" ? scope : "";
-      }
-      return "";
-    }).filter(Boolean);
-    if (scopes.length > 0) {
-      return scopes;
-    }
-  }
-  return [];
-}
-function findBitableRecordId(result, userId) {
-  const candidates = [
-    findNestedValue(result, ["data", "items"]),
-    findNestedValue(result, ["items"]),
-    findNestedValue(result, ["data", "records"])
-  ];
-  for (const candidate of candidates) {
-    if (!Array.isArray(candidate)) {
-      continue;
-    }
-    for (const item of candidate) {
-      if (!item || typeof item !== "object") {
-        continue;
-      }
-      const record = item;
-      const fields = record.fields && typeof record.fields === "object" ? record.fields : {};
-      if (String(fields.user_id ?? "") !== userId) {
-        continue;
-      }
-      const recordId = record.record_id ?? record.recordId ?? record.id;
-      if (typeof recordId === "string" && recordId.trim()) {
-        return recordId;
-      }
-    }
-  }
-  return null;
-}
 function readFeishuAccountsFromOpenClawConfig() {
   const openclawConfigPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw", "openclaw.json");
   if (!(0, import_node_fs.existsSync)(openclawConfigPath)) {
@@ -1561,6 +3380,89 @@ function readFeishuAccountsFromOpenClawConfig() {
     return [];
   }
 }
+function readProfileExtractorModelFromOpenClawConfig() {
+  const openclawConfigPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw", "openclaw.json");
+  if (!(0, import_node_fs.existsSync)(openclawConfigPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(openclawConfigPath, "utf8"));
+    const models = parsed.models && typeof parsed.models === "object" ? parsed.models : {};
+    const providers = models.providers && typeof models.providers === "object" ? models.providers : {};
+    const agents = parsed.agents && typeof parsed.agents === "object" ? parsed.agents : {};
+    const defaults = agents.defaults && typeof agents.defaults === "object" ? agents.defaults : {};
+    const defaultModel = defaults.model && typeof defaults.model === "object" ? defaults.model : {};
+    const candidates = [
+      ...readConfiguredModelRefs(defaultModel.fallback),
+      ...readConfiguredModelRefs(defaultModel.fallbacks),
+      ...readConfiguredModelRefs(models.fallback),
+      ...readConfiguredModelRefs(models.fallbacks),
+      ...readConfiguredModelRefs(defaultModel.primary),
+      ...readConfiguredModelRefs(models.primary)
+    ];
+    for (const configuredModel of candidates) {
+      if (!configuredModel.includes("/")) {
+        continue;
+      }
+      const [providerId, modelId] = configuredModel.split("/", 2);
+      const provider = providers[providerId] && typeof providers[providerId] === "object" ? providers[providerId] : null;
+      if (!provider) {
+        continue;
+      }
+      const api = asNullableString(provider.api);
+      const baseUrl = asNullableString(provider.baseUrl) ?? asNullableString(provider.baseURL);
+      const apiKey = asNullableString(provider.apiKey);
+      if (api !== "openai-completions" || !baseUrl || !apiKey) {
+        continue;
+      }
+      return {
+        providerId,
+        modelId,
+        baseUrl: baseUrl.replace(/\/+$/, ""),
+        apiKey
+      };
+    }
+    return null;
+  } catch (error) {
+    logUserBindEvent("profile-extractor-config-read-failed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function readSemanticProfileCaptureTimeoutMs() {
+  const raw = Number(process.env.BAMDRA_USER_BIND_SEMANTIC_TIMEOUT_MS ?? "12000");
+  if (!Number.isFinite(raw)) {
+    return 12e3;
+  }
+  return Math.max(2500, Math.floor(raw));
+}
+function isUserBindRuntimeLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return record[GLOBAL_RUNTIME_BRAND_KEY] === true && typeof record.register === "function" && typeof record.close === "function";
+}
+function getGlobalPendingSemanticRefines() {
+  const globalRecord = globalThis;
+  const existing = globalRecord[GLOBAL_PENDING_REFINE_KEY];
+  if (existing instanceof Set) {
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Set();
+  globalRecord[GLOBAL_PENDING_REFINE_KEY] = created;
+  return created;
+}
+function readConfiguredModelRefs(value) {
+  if (typeof value === "string") {
+    return value.trim() ? [value.trim()] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => asNullableString(item)).filter((item) => Boolean(item));
+  }
+  return [];
+}
 function normalizeFeishuAccount(accountId, input, fallback) {
   const record = input && typeof input === "object" ? input : {};
   const enabled = record.enabled !== false && fallback.enabled !== false;
@@ -1602,12 +3504,107 @@ function getConfiguredAgentId(agent) {
 }
 function defaultProfileNotes() {
   return [
-    "- \u5EFA\u8BAE\u79F0\u547C\uFF1A\u8001\u677F",
-    "- \u65F6\u533A\uFF1AAsia/Shanghai",
-    "- \u504F\u597D\uFF1A\u5E7D\u9ED8\u8BD9\u8C10\u7684\u5BF9\u8BDD\u98CE\u683C\uFF0C\u4F46\u662F\u4E0D\u8FC7\u5206",
-    "- \u4F60\u53EF\u4EE5\u5728\u8FD9\u91CC\u7EE7\u7EED\u8865\u5145\u5DE5\u4F5C\u80CC\u666F\u3001\u8868\u8FBE\u4E60\u60EF\u3001\u7981\u5FCC\u548C\u957F\u671F\u504F\u597D\u3002"
+    "- \u8FD9\u91CC\u53EA\u8BB0\u5F55\u5DF2\u7ECF\u786E\u8BA4\u7684\u957F\u671F\u753B\u50CF\u4FE1\u606F\uFF0C\u4E0D\u8BB0\u5F55\u4E34\u65F6\u4EFB\u52A1\u8981\u6C42\u3002",
+    `- \u82E5\u7528\u6237\u5C1A\u672A\u660E\u786E\u63D0\u4F9B\u65F6\u533A\uFF0C\u9ED8\u8BA4\u8DDF\u968F\u5F53\u524D\u670D\u52A1\u5668\u65F6\u533A\uFF08\u5F53\u524D\u68C0\u6D4B\u503C\uFF1A${getServerTimezone()}\uFF09\u3002`,
+    "- \u5907\u6CE8\u91CC\u9002\u5408\u5199\u6682\u65F6\u8FD8\u4E0D\u4FBF\u7ED3\u6784\u5316\u3001\u4F46\u5DF2\u7ECF\u786E\u8BA4\u7684\u957F\u671F\u4E60\u60EF\u3001\u8FB9\u754C\u548C\u534F\u4F5C\u504F\u597D\u3002"
   ].join("\n");
 }
+function createEphemeralUserId(channelType, openId, sessionId) {
+  return `temp_${hashId(`${channelType}:${openId ?? sessionId}`)}`;
+}
+function createProvisionalUserId(channelType, openId) {
+  return `${channelType}:oid_${hashId(`${channelType}:${openId}`)}`;
+}
+function createStableLocalUserId(channelType, openId, sessionId) {
+  return `${channelType}:ub_${hashId(`${channelType}:${openId ?? sessionId}`)}`;
+}
+function isProvisionalScopedUserId(userId) {
+  return /:oid_[a-f0-9]+$/i.test(userId);
+}
+function getPendingBindingRetryDelayMs(reason, attempts) {
+  if (reason === "feishu-contact-scope-missing") {
+    return Math.min(30 * 60 * 1e3, Math.max(6e4, attempts * 5 * 6e4));
+  }
+  return Math.min(10 * 60 * 1e3, Math.max(15e3, attempts * 3e4));
+}
+function scopeUserId(channelType, userId) {
+  if (!userId) {
+    return userId;
+  }
+  if (channelType === "manual" || channelType === "local") {
+    return userId;
+  }
+  if (userId.startsWith("temp_") || userId.startsWith("ub_")) {
+    return userId;
+  }
+  if (extractChannelFromScopedUserId(userId)) {
+    return userId;
+  }
+  return `${channelType}:${userId}`;
+}
+function getExternalUserId(channelType, userId) {
+  if (!userId) {
+    return userId;
+  }
+  if (channelType === "manual" || channelType === "local") {
+    return userId;
+  }
+  if (userId.startsWith("temp_") || userId.startsWith("ub_")) {
+    return userId;
+  }
+  const currentChannel = extractChannelFromScopedUserId(userId);
+  if (currentChannel && userId.startsWith(`${currentChannel}:`)) {
+    return userId.slice(currentChannel.length + 1);
+  }
+  return userId;
+}
+function extractChannelFromScopedUserId(userId) {
+  const match = userId.match(/^([a-z][a-z0-9_-]*):(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  return match[1].toLowerCase();
+}
+function buildLightweightProfile(args) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    userId: args.userId,
+    name: args.profilePatch.name ?? args.current?.name ?? null,
+    gender: args.profilePatch.gender ?? args.current?.gender ?? null,
+    email: args.profilePatch.email ?? args.current?.email ?? null,
+    avatar: args.profilePatch.avatar ?? args.current?.avatar ?? null,
+    nickname: args.profilePatch.nickname ?? args.current?.nickname ?? null,
+    preferences: args.profilePatch.preferences ?? args.current?.preferences ?? null,
+    personality: args.profilePatch.personality ?? args.current?.personality ?? null,
+    role: args.profilePatch.role ?? args.current?.role ?? null,
+    timezone: args.profilePatch.timezone ?? args.current?.timezone ?? getServerTimezone(),
+    notes: args.profilePatch.notes ?? args.current?.notes ?? defaultProfileNotes(),
+    visibility: args.profilePatch.visibility ?? args.current?.visibility ?? "private",
+    source: args.source,
+    updatedAt: now
+  };
+}
+function looksLikeFeishuContactScopeError(message) {
+  return message.includes("99991672") || message.includes("permission_violations") || message.includes("contact:contact.base:readonly") || message.includes("contact:contact:access_as_app") || message.includes("contact:contact:readonly");
+}
+function renderFeishuContactScopeGuidance(accountIds) {
+  const scopeText = accountIds.length > 0 ? `\u6D89\u53CA\u8D26\u53F7\uFF1A${accountIds.join("\u3001")}\u3002` : "";
+  return [
+    "\u5F53\u524D\u65E0\u6CD5\u5B8C\u6574\u542F\u7528\u7528\u6237\u753B\u50CF\u3002",
+    "\u539F\u56E0\uFF1A\u5BF9\u5E94\u7684 Feishu App \u7F3A\u5C11\u8054\u7CFB\u4EBA\u6743\u9650\uFF0C\u6682\u65F6\u65E0\u6CD5\u7A33\u5B9A\u89E3\u6790\u771F\u5B9E\u7528\u6237\u8EAB\u4EFD\u3002",
+    `${scopeText}\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u5F00\u901A\u8054\u7CFB\u4EBA\u76F8\u5173\u6743\u9650\uFF0C\u4EE5\u4FDD\u8BC1\u7528\u6237\u753B\u50CF\u53EF\u7528\u3002`
+  ].join(" ");
+}
+function getServerTimezone() {
+  try {
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (typeof timezone === "string" && timezone.trim()) {
+      return timezone.trim();
+    }
+  } catch {
+  }
+  return "UTC";
+}
 function sanitizeProfileNotes(notes) {
   const value = typeof notes === "string" ? notes.trim() : "";
   if (!value) {