@bamdra/bamdra-user-bind 0.1.12 → 0.1.13

package/dist/index.js

@@ -46,6 +46,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",
@@ -63,6 +68,17 @@ var REQUIRED_FEISHU_IDENTITY_SCOPES = [
   "contact:user.employee_id:readonly",
   "contact:user.base:readonly"
 ];
+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));
@@ -130,6 +146,7 @@ var UserBindStore = class {
     `);
     this.ensureColumn(TABLES.profiles, "timezone", "TEXT");
     this.ensureColumn(TABLES.profiles, "notes", "TEXT");
+    this.migrateChannelScopedUserIds();
   }
   db;
   markdownSyncing = /* @__PURE__ */ new Set();
@@ -156,6 +173,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,22 +223,21 @@ 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,
       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,
       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,
@@ -257,10 +289,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
@@ -346,8 +378,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 +387,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 +395,43 @@ 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,
+        nickname: patch.nickname ?? null,
+        timezone: patch.timezone ?? null,
+        preferences: patch.preferences ?? null,
+        personality: patch.personality ?? null,
+        role: patch.role ?? null,
+        visibility: patch.visibility ?? current.visibility
+      }, patch.notes ?? null);
+      const currentHash = computeProfilePayloadHash({
+        name: current.name,
+        nickname: current.nickname,
+        timezone: current.timezone,
+        preferences: current.preferences,
+        personality: current.personality,
+        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
@@ -408,6 +467,94 @@ 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, email, avatar, nickname, preferences, personality, role, timezone, notes, visibility, source, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(user_id) DO UPDATE SET
+          name = excluded.name,
+          gender = excluded.gender,
+          email = excluded.email,
+          avatar = excluded.avatar,
+          nickname = excluded.nickname,
+          preferences = excluded.preferences,
+          personality = excluded.personality,
+          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.email,
+        merged.avatar,
+        merged.nickname,
+        merged.preferences,
+        merged.personality,
+        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,10 +570,24 @@ var UserBindRuntime = class {
   config;
   sessionCache = /* @__PURE__ */ new Map();
   bindingCache = /* @__PURE__ */ new Map();
-  feishuScopeStatus = null;
+  semanticCaptureCache = /* @__PURE__ */ new Map();
+  semanticCaptureInFlight = /* @__PURE__ */ new Set();
+  pendingBindingResolutions = /* @__PURE__ */ new Map();
+  feishuScopeStatusCache = /* @__PURE__ */ new Map();
   bitableMirror = null;
   feishuTokenCache = /* @__PURE__ */ new Map();
+  pendingBindingTimer = null;
+  pendingBindingKickTimer = null;
+  pendingBindingSweepInFlight = false;
   close() {
+    if (this.pendingBindingTimer) {
+      clearInterval(this.pendingBindingTimer);
+      this.pendingBindingTimer = null;
+    }
+    if (this.pendingBindingKickTimer) {
+      clearTimeout(this.pendingBindingKickTimer);
+      this.pendingBindingKickTimer = null;
+    }
     this.store.close();
   }
   register() {
@@ -438,15 +599,24 @@ var UserBindRuntime = class {
     });
     this.registerHooks();
     this.registerTools();
+    this.startPendingBindingWorker();
     exposeGlobalApi(this);
   }
   getIdentityForSession(sessionId) {
     return this.sessionCache.get(sessionId) ?? null;
   }
   async resolveFromContext(context) {
-    const parsed = parseIdentityContext(context);
+    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 +624,86 @@ 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;
+        } 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");
         }
       }
     }
+    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 +720,154 @@ var UserBindRuntime = class {
       expiresAt: Date.now() + this.config.cacheTtlMs,
       identity
     });
-    if (parsed.channelType === "feishu") {
+    if (shouldPersistIdentity && 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) {
@@ -546,6 +883,80 @@ var UserBindRuntime = class {
     }
     return refreshed;
   }
+  async captureProfileFromMessage(context, identity) {
+    const messageText = extractUserUtterance(context);
+    if (!messageText) {
+      logUserBindEvent("semantic-profile-capture-skipped-no-utterance", {
+        userId: identity.userId,
+        sessionId: identity.sessionId
+      });
+      return;
+    }
+    const fingerprint = hashId(`${identity.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;
+    }
+    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,
+          confidence: extraction?.confidence ?? 0,
+          messagePreview: messageText.slice(0, 120)
+        });
+        this.semanticCaptureCache.set(fingerprint, Date.now());
+        return;
+      }
+      const { patch, operations } = cleanupSemanticProfilePatch(
+        extraction.patch,
+        identity.profile,
+        extraction.operations
+      );
+      if (Object.keys(patch).length === 0) {
+        this.semanticCaptureCache.set(fingerprint, Date.now());
+        return;
+      }
+      await this.updateMyProfile(
+        { sessionId: identity.sessionId },
+        {
+          ...patch,
+          source: "semantic-self-update"
+        },
+        operations
+      );
+      logUserBindEvent("semantic-profile-capture-success", {
+        userId: identity.userId,
+        sessionId: identity.sessionId,
+        fields: Object.keys(patch),
+        operations,
+        confidence: extraction.confidence
+      });
+      this.semanticCaptureCache.set(fingerprint, Date.now());
+    } catch (error) {
+      logUserBindEvent("semantic-profile-capture-failed", {
+        userId: identity.userId,
+        sessionId: identity.sessionId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.semanticCaptureInFlight.delete(fingerprint);
+    }
+  }
+  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,18 +1023,23 @@ 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;
       }
+      const captureContext = mergeSemanticCaptureContext(event, context);
+      await this.captureProfileFromMessage(captureContext, identity);
       return {
         context: [
           {
@@ -639,9 +1055,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 nickname, timezone, and stable preferences can be used naturally in the response",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -649,11 +1072,11 @@ 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 preferences into their profile when they clearly provide them, such as nickname, communication style, timezone, role, or durable notes",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -661,18 +1084,67 @@ var UserBindRuntime = class {
         properties: {
           sessionId: { type: "string" },
           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"] },
           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,
+        properties: {
+          sessionId: { type: "string" }
+        }
+      },
+      execute: refreshMyBindingExecute
+    });
+    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,
@@ -680,7 +1152,7 @@ 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({
@@ -714,6 +1186,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 +1219,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,15 +1253,24 @@ 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) {
+  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(
@@ -794,45 +1279,58 @@ var UserBindRuntime = class {
           token
         );
         const scopes = extractScopes(result);
-        this.feishuScopeStatus = {
+        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,
-          ...this.feishuScopeStatus
+          ...status
         });
-        return this.feishuScopeStatus;
+        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);
-        this.feishuScopeStatus = {
+        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", this.feishuScopeStatus);
-        return this.feishuScopeStatus;
+        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);
       }
     }
-    this.feishuScopeStatus = {
+    return {
       scopes: [],
       missingIdentityScopes: [...REQUIRED_FEISHU_IDENTITY_SCOPES],
       hasDocumentAccess: false
     };
-    return this.feishuScopeStatus;
   }
   async getFeishuAppAccessToken(account) {
     const cached = this.feishuTokenCache.get(account.accountId);
@@ -993,6 +1491,9 @@ function exposeGlobalApi(runtime) {
     },
     async resolveIdentity(context) {
       return runtime.resolveFromContext(context);
+    },
+    async runPendingBindingSweep() {
+      return runtime.runPendingBindingSweep();
     }
   };
 }
@@ -1084,9 +1585,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 +1601,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 +1620,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,6 +1632,34 @@ 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),
@@ -1162,12 +1690,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,6 +1704,262 @@ function parseIdentityContext(context) {
     senderName
   };
 }
+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;
+  }
+  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 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;
+    }
+    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;
+  }
+}
+function extractMessageText(message) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  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;
+  }
+  const stripped = stripIdentityMetadata(rawText);
+  if (!stripped) {
+    return null;
+  }
+  if (looksLikeIdentityMetadata(stripped)) {
+    return null;
+  }
+  return stripped;
+}
+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;
+  }
+  const message = findNestedRecord(record, ["message"], ["event", "message"], ["payload", "message"]);
+  const messageText = extractMessageText(message);
+  if (messageText) {
+    return messageText;
+  }
+  const inputText = extractTextFromInput(record.input);
+  if (inputText) {
+    return inputText;
+  }
+  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 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 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, "");
+  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);
@@ -1224,6 +2008,108 @@ function inferChannelTypeFromSessionId(sessionId) {
   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) {
@@ -1234,8 +2120,24 @@ function extractOpenIdFromSessionId(sessionId) {
   if (!sessionId) {
     return null;
   }
-  const match = sessionId.match(/:([A-Za-z0-9_-]+)$/);
-  return match?.[1] ?? 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 : {};
@@ -1251,6 +2153,17 @@ function sanitizeProfilePatch(params) {
     notes: asNullableString(params.notes)
   };
 }
+function extractProfilePatchOperations(params) {
+  const operations = {};
+  const fields = ["nickname", "preferences", "personality", "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)) {
@@ -1332,44 +2245,102 @@ 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.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.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,
+      nickname: profile.nickname,
+      timezone: profile.timezone,
+      preferences: profile.preferences,
+      personality: profile.personality,
+      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.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.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,
+    nickname: patch.nickname ?? null,
+    timezone: patch.timezone ?? null,
+    preferences: patch.preferences ?? null,
+    personality: patch.personality ?? 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 +2350,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,13 +2367,16 @@ 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) {
@@ -1415,10 +2397,6 @@ function applyFrontmatterField(patch, key, value) {
     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 +2441,273 @@ function asTextResult(value) {
 function asNullableString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+async function inferSemanticProfileExtraction(messageText, currentProfile) {
+  const model = readProfileExtractorModelFromOpenClawConfig();
+  if (!model) {
+    return null;
+  }
+  const response = await fetch(`${model.baseUrl}/chat/completions`, {
+    method: "POST",
+    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.",
+            "Return JSON only.",
+            "Only capture durable, reusable traits or preferences 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.",
+            "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"?}}'
+          ].join("\n")
+        },
+        {
+          role: "user",
+          content: JSON.stringify({
+            current_profile: {
+              nickname: currentProfile.nickname,
+              preferences: currentProfile.preferences,
+              personality: currentProfile.personality,
+              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: {
+        nickname: asNullableString(patchInput.nickname),
+        preferences: asNullableString(patchInput.preferences),
+        personality: asNullableString(patchInput.personality),
+        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 ["nickname", "preferences", "personality", "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 nickname = asNullableString(patch.nickname);
+  const preferences = asNullableString(patch.preferences);
+  const personality = asNullableString(patch.personality);
+  const role = asNullableString(patch.role);
+  const timezone = asNullableString(patch.timezone);
+  const notes = asNullableString(patch.notes);
+  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 (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 = ["nickname", "preferences", "personality", "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") {
+    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)) {
@@ -1561,6 +2806,46 @@ 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 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;
+    }
+    return {
+      providerId,
+      modelId,
+      baseUrl: baseUrl.replace(/\/+$/, ""),
+      apiKey
+    };
+  } catch (error) {
+    logUserBindEvent("profile-extractor-config-read-failed", {
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
 function normalizeFeishuAccount(accountId, input, fallback) {
   const record = input && typeof input === "object" ? input : {};
   const enabled = record.enabled !== false && fallback.enabled !== false;
@@ -1602,12 +2887,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) {