@bamdra/bamdra-user-bind 0.1.13 → 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 = [
@@ -64,10 +67,11 @@ 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",
@@ -100,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,
@@ -146,6 +154,10 @@ 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;
@@ -157,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;
@@ -231,11 +253,15 @@ var UserBindStore = class {
       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 ?? 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 ?? getServerTimezone(),
       notes: args.profilePatch.notes ?? current?.notes ?? defaultProfileNotes(),
@@ -244,16 +270,20 @@ var UserBindStore = class {
       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,
@@ -264,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,
@@ -318,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);
@@ -332,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),
@@ -354,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;
@@ -398,19 +456,29 @@ var UserBindStore = class {
       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);
@@ -448,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();
@@ -509,16 +577,20 @@ var UserBindStore = class {
       };
       this.db.prepare(`DELETE FROM ${TABLES.profiles} WHERE user_id = ?`).run(fromUserId);
       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,
@@ -529,11 +601,15 @@ var UserBindStore = class {
         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,
@@ -572,13 +648,18 @@ var UserBindRuntime = class {
   bindingCache = /* @__PURE__ */ new Map();
   semanticCaptureCache = /* @__PURE__ */ new Map();
   semanticCaptureInFlight = /* @__PURE__ */ new Set();
+  semanticCaptureRetryTimers = /* @__PURE__ */ new Map();
+  semanticCaptureRetryAttempts = /* @__PURE__ */ new Map();
+  pendingSemanticCaptures = /* @__PURE__ */ new Map();
   pendingBindingResolutions = /* @__PURE__ */ new Map();
-  feishuScopeStatusCache = /* @__PURE__ */ new Map();
-  bitableMirror = null;
   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);
@@ -588,9 +669,28 @@ var UserBindRuntime = class {
       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);
@@ -600,12 +700,13 @@ var UserBindRuntime = class {
     this.registerHooks();
     this.registerTools();
     this.startPendingBindingWorker();
+    this.schedulePendingSemanticSweep();
     exposeGlobalApi(this);
   }
   getIdentityForSession(sessionId) {
     return this.sessionCache.get(sessionId) ?? null;
   }
-  async resolveFromContext(context) {
+  async resolveFromContext(context, options = {}) {
     const parsed = parseIdentityContext(enrichIdentityContext(context));
     if (parsed.sessionId && !parsed.channelType) {
       const cached2 = this.sessionCache.get(parsed.sessionId) ?? null;
@@ -643,18 +744,22 @@ var UserBindRuntime = class {
     let remoteProfilePatch = {};
     if (parsed.channelType === "feishu" && parsed.openId) {
       if (!userId) {
-        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);
+        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-resolution-miss");
+          this.enqueuePendingBindingResolution(parsed.channelType, parsed.openId, "feishu-deferred-resolution");
         }
       }
     }
@@ -720,9 +825,6 @@ var UserBindRuntime = class {
       expiresAt: Date.now() + this.config.cacheTtlMs,
       identity
     });
-    if (shouldPersistIdentity && parsed.channelType === "feishu") {
-      await this.syncFeishuMirror(identity);
-    }
     return identity;
   }
   startPendingBindingWorker() {
@@ -877,22 +979,79 @@ 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 messageText = extractUserUtterance(context);
-    if (!messageText) {
+    const utteranceText = extractUserUtterance(context);
+    if (!utteranceText) {
       logUserBindEvent("semantic-profile-capture-skipped-no-utterance", {
         userId: identity.userId,
         sessionId: identity.sessionId
       });
       return;
     }
-    const fingerprint = hashId(`${identity.sessionId}:${messageText}`);
+    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;
@@ -901,17 +1060,21 @@ var UserBindRuntime = class {
     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: identity.sessionId,
+          sessionId,
           confidence: extraction?.confidence ?? 0,
           messagePreview: messageText.slice(0, 120)
         });
         this.semanticCaptureCache.set(fingerprint, Date.now());
+        this.clearSemanticProfileRetryState(fingerprint);
         return;
       }
       const { patch, operations } = cleanupSemanticProfilePatch(
@@ -921,34 +1084,253 @@ var UserBindRuntime = class {
       );
       if (Object.keys(patch).length === 0) {
         this.semanticCaptureCache.set(fingerprint, Date.now());
+        this.clearSemanticProfileRetryState(fingerprint);
         return;
       }
       await this.updateMyProfile(
-        { sessionId: identity.sessionId },
+        { sessionId },
         {
           ...patch,
           source: "semantic-self-update"
         },
         operations
       );
+      await this.removePendingSemanticRefineNote(sessionId, fingerprint);
       logUserBindEvent("semantic-profile-capture-success", {
         userId: identity.userId,
-        sessionId: identity.sessionId,
+        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: identity.sessionId,
+        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()) {
@@ -1038,8 +1420,6 @@ var UserBindRuntime = class {
       if (!identity) {
         return;
       }
-      const captureContext = mergeSemanticCaptureContext(event, context);
-      await this.captureProfileFromMessage(captureContext, identity);
       return {
         context: [
           {
@@ -1064,7 +1444,7 @@ var UserBindRuntime = class {
     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 before replying so nickname, timezone, and stable preferences can be used naturally in the response",
+      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,
@@ -1076,19 +1456,31 @@ var UserBindRuntime = class {
     });
     registerTool({
       name: "bamdra_user_bind_update_my_profile",
-      description: "Immediately write the current user's stable preferences into their profile when they clearly provide them, such as nickname, communication style, timezone, role, or durable notes",
+      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" },
@@ -1265,73 +1657,6 @@ var UserBindRuntime = class {
     logUserBindEvent("feishu-resolution-empty", { openId });
     return null;
   }
-  async ensureFeishuScopeStatus(account) {
-    if (account) {
-      const cached = this.feishuScopeStatusCache.get(account.accountId);
-      if (cached) {
-        return cached;
-      }
-      try {
-        const token = await this.getFeishuAppAccessToken(account);
-        const result = await feishuJsonRequest(
-          account,
-          "/open-apis/application/v6/scopes",
-          token
-        );
-        const scopes = extractScopes(result);
-        const status = {
-          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:"))
-        };
-        this.feishuScopeStatusCache.set(account.accountId, status);
-        logUserBindEvent("feishu-scopes-read", {
-          accountId: account.accountId,
-          ...status
-        });
-        return status;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logUserBindEvent("feishu-scopes-attempt-failed", { accountId: account.accountId, message });
-      }
-    }
-    const accounts = readFeishuAccountsFromOpenClawConfig();
-    for (const candidate of accounts) {
-      const cached = this.feishuScopeStatusCache.get(candidate.accountId);
-      if (cached?.hasDocumentAccess) {
-        return cached;
-      }
-    }
-    for (const candidate of accounts) {
-      const status = await this.ensureFeishuScopeStatus(candidate);
-      if (status.hasDocumentAccess) {
-        return status;
-      }
-    }
-    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);
-        const status = {
-          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", status);
-        return status;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logUserBindEvent("feishu-scopes-failed", { message });
-        this.store.recordIssue("feishu-scope-read", message);
-      }
-    }
-    return {
-      scopes: [],
-      missingIdentityScopes: [...REQUIRED_FEISHU_IDENTITY_SCOPES],
-      hasDocumentAccess: false
-    };
-  }
   async getFeishuAppAccessToken(account) {
     const cached = this.feishuTokenCache.get(account.accountId);
     if (cached && cached.expiresAt > Date.now()) {
@@ -1363,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();
@@ -1474,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"]
   };
@@ -1517,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");
@@ -1538,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;
@@ -1577,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) {
@@ -1665,11 +1945,15 @@ function mapProfileRow(row) {
     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),
@@ -1817,6 +2101,78 @@ function extractUserUtterance(context) {
   }
   return stripped;
 }
+function buildSemanticCaptureInput(context, utteranceText) {
+  const record = context && typeof context === "object" ? context : {};
+  const recentDialogue = readRecentProfileCaptureDialogue(record.sessionManager, utteranceText);
+  if (!recentDialogue) {
+    return utteranceText;
+  }
+  return [
+    "Recent profile-collection exchange:",
+    recentDialogue
+  ].join("\n");
+}
+function shouldSkipSemanticProfileCapture(text) {
+  const normalized = normalizeSemanticCaptureText(text);
+  if (!normalized) {
+    return true;
+  }
+  if (isTrivialSemanticCaptureUtterance(normalized)) {
+    return true;
+  }
+  const tokenCount = normalized.split(/\s+/).filter(Boolean).length;
+  if (normalized.length <= 4) {
+    return true;
+  }
+  return tokenCount <= 1 && !containsCjkCharacters(normalized);
+}
+function shouldIgnoreSemanticProfileCaptureCandidate(text) {
+  const normalized = normalizeSemanticCaptureText(text);
+  return !normalized || isTrivialSemanticCaptureUtterance(normalized);
+}
+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 normalizeSemanticCaptureText(text) {
+  return text.trim().toLowerCase().replace(/[!?.,，。！？、;；:："'`~()\[\]{}<>@#%^&*_+=|\\/.-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function containsCjkCharacters(text) {
+  return /[\u3400-\u9fff\uf900-\ufaff]/.test(text);
+}
+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;
+  }
+  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"])
@@ -1901,6 +2257,88 @@ function normalizeHookText(value) {
   }
   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;
@@ -1933,24 +2371,6 @@ function readLatestUserMessageFromSessionManager(sessionManager) {
   }
   return null;
 }
-function mergeSemanticCaptureContext(event, context) {
-  const merged = {};
-  if (event && typeof event === "object") {
-    Object.assign(merged, event);
-  }
-  if (context && typeof context === "object") {
-    const record = context;
-    for (const [key, value] of Object.entries(record)) {
-      if (merged[key] === void 0) {
-        merged[key] = value;
-      }
-    }
-  }
-  if (merged.sessionManager === void 0 && context && typeof context === "object") {
-    merged.sessionManager = context.sessionManager;
-  }
-  return merged;
-}
 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, "");
@@ -2145,9 +2565,15 @@ function getAgentIdFromContext(context) {
 }
 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)
@@ -2155,7 +2581,7 @@ function sanitizeProfilePatch(params) {
 }
 function extractProfilePatchOperations(params) {
   const operations = {};
-  const fields = ["nickname", "preferences", "personality", "role", "timezone", "notes"];
+  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") {
@@ -2194,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();
   }
@@ -2211,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();
   }
@@ -2224,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}`);
   }
@@ -2236,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}`);
   }
@@ -2253,6 +2718,18 @@ function renderProfileMarkdown(profile) {
   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)}`);
   }
@@ -2265,6 +2742,9 @@ function renderProfileMarkdown(profile) {
   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)}`);
   }
@@ -2274,10 +2754,15 @@ function renderProfileMarkdown(profile) {
     `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))}`,
@@ -2305,6 +2790,18 @@ function renderConfirmedProfileSection(profile) {
   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}`);
   }
@@ -2314,6 +2811,9 @@ function renderConfirmedProfileSection(profile) {
   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}`);
   }
@@ -2325,10 +2825,15 @@ function renderConfirmedProfileSection(profile) {
 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
@@ -2383,6 +2888,14 @@ 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") {
@@ -2391,6 +2904,8 @@ 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") {
@@ -2441,13 +2956,72 @@ 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"
@@ -2461,32 +3035,38 @@ async function inferSemanticProfileExtraction(messageText, currentProfile) {
         {
           role: "system",
           content: [
-            "You extract stable user-profile information from a single user message.",
+            "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 traits or preferences that should affect future conversations.",
+            "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 clear addressing / style preferences.",
-            "Allowed fields: nickname, preferences, personality, role, timezone, notes.",
+            "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.",
-            "notes is only for durable boundaries or habits that do not fit the structured fields.",
-            "A preferred form of address counts as nickname even when phrased naturally, for example: '\u4EE5\u540E\u53EB\u6211\u4E30\u54E5', '\u53EB\u6211\u4EB2\u7231\u7684\u8001\u5927', '\u4F60\u5C31\u53EB\u6211\u963F\u4E30'.",
-            "A reusable response preference counts as preferences, for example: '\u5148\u7ED9\u7ED3\u8BBA\u518D\u5C55\u5F00', '\u8BF4\u8BDD\u76F4\u63A5\u4E00\u70B9\u4F46\u522B\u592A\u786C', '\u522B\u592A\u5B98\u65B9'.",
-            "Use append when the user adds another stable preference without revoking the old one.",
-            "Use replace when the user corrects or changes an existing stable preference.",
-            "Use remove when the user clearly asks to drop a specific old preference or trait.",
-            "If a message clearly contains both an addressing preference and a communication preference, capture both.",
-            "Do not require rigid trigger phrases. Judge by meaning.",
-            "Do not copy placeholders, examples, or template language.",
-            'Return exactly this shape: {"should_update":boolean,"confidence":number,"patch":{"nickname":string?,"preferences":string?,"personality":string?,"role":string?,"timezone":string?,"notes":string?},"operations":{"nickname":"replace|append|remove"?,"preferences":"replace|append|remove"?,"personality":"replace|append|remove"?,"role":"replace|append|remove"?,"timezone":"replace|append|remove"?,"notes":"replace|append|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
@@ -2546,9 +3126,15 @@ function parseSemanticExtractionResult(content) {
       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)
@@ -2561,7 +3147,7 @@ function parseSemanticExtractionResult(content) {
 }
 function parseProfilePatchOperations(input) {
   const operations = {};
-  for (const field of ["nickname", "preferences", "personality", "role", "timezone", "notes"]) {
+  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;
@@ -2588,12 +3174,48 @@ function extractJsonObject(content) {
 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) {
@@ -2612,6 +3234,12 @@ function cleanupSemanticProfilePatch(patch, currentProfile, operations) {
       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) {
@@ -2637,7 +3265,7 @@ function cleanupSemanticProfilePatch(patch, currentProfile, operations) {
 }
 function applyProfilePatchOperations(currentProfile, patch, operations) {
   const next = {};
-  const fields = ["nickname", "preferences", "personality", "role", "timezone", "notes"];
+  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;
@@ -2653,7 +3281,7 @@ function applyProfilePatchOperations(currentProfile, patch, operations) {
   return next;
 }
 function defaultProfileFieldOperation(field) {
-  if (field === "notes") {
+  if (field === "notes" || field === "interests") {
     return "append";
   }
   return "replace";
@@ -2729,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)) {
@@ -2818,27 +3392,37 @@ function readProfileExtractorModelFromOpenClawConfig() {
     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 configuredModel = asNullableString(defaultModel.primary) ?? asNullableString(models.primary);
-    if (!configuredModel || !configuredModel.includes("/")) {
-      return null;
-    }
-    const [providerId, modelId] = configuredModel.split("/", 2);
-    const provider = providers[providerId] && typeof providers[providerId] === "object" ? providers[providerId] : null;
-    if (!provider) {
-      return null;
-    }
-    const api = asNullableString(provider.api);
-    const baseUrl = asNullableString(provider.baseUrl) ?? asNullableString(provider.baseURL);
-    const apiKey = asNullableString(provider.apiKey);
-    if (api !== "openai-completions" || !baseUrl || !apiKey) {
-      return null;
+    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 {
-      providerId,
-      modelId,
-      baseUrl: baseUrl.replace(/\/+$/, ""),
-      apiKey
-    };
+    return null;
   } catch (error) {
     logUserBindEvent("profile-extractor-config-read-failed", {
       message: error instanceof Error ? error.message : String(error)
@@ -2846,6 +3430,39 @@ function readProfileExtractorModelFromOpenClawConfig() {
     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;