nikou-cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -1173,6 +1173,24 @@ function safeJsonStringify(payload) {
     return `{"error":"JSON.stringify failed","reason":"${msg}"}`;
   }
 }
+function countReplacementChars(text) {
+  return (text.match(/\uFFFD/g) || []).length;
+}
+function decodeProcessOutputChunk(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  const utf8 = chunk.toString("utf8");
+  if (process2.platform !== "win32" || !utf8.includes("\uFFFD")) {
+    return utf8;
+  }
+  try {
+    const decoded = new TextDecoder("gb18030").decode(chunk);
+    return countReplacementChars(decoded) < countReplacementChars(utf8) ? decoded : utf8;
+  } catch {
+    return utf8;
+  }
+}
 function toSingleLineLog(text, maxLength = 600) {
   const normalized = String(text || "").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
   if (normalized.length <= maxLength) return normalized;
@@ -6097,13 +6115,6 @@ import fs11 from "fs";
 import path10 from "path";
 import process6 from "process";
 import { spawnSync as spawnSync3 } from "child_process";
-function quoteWindowsCmdArg(value) {
-  const text = String(value ?? "");
-  if (!text) {
-    return '""';
-  }
-  return `"${text.replace(/(["^&|<>%])/g, "^$1")}"`;
-}
 function isExecutableFile(filePath) {
   if (!filePath || !fs11.existsSync(filePath)) {
     return false;
@@ -6202,22 +6213,22 @@ function resolveCliExecution(commandName, args, env = process6.env) {
     prependPathDir(env, path10.dirname(commandPath));
   }
   if (process6.platform === "win32") {
-    const commandLine = [
-      quoteWindowsCmdArg(commandPath),
-      ...normalizedArgs.map((item) => quoteWindowsCmdArg(item))
-    ].join(" ");
     return {
       command: "cmd.exe",
-      args: ["/d", "/s", "/c", `"${commandLine}"`],
+      args: ["/d", "/c", "call", commandPath, ...normalizedArgs],
       shell: false,
-      displayCommand
+      displayCommand,
+      resolvedPath: commandPath,
+      fallback: "cmd"
     };
   }
   return {
     command: commandPath,
     args: normalizedArgs,
     shell: false,
-    displayCommand
+    displayCommand,
+    resolvedPath: commandPath,
+    fallback: commandPath === commandName ? "direct-unresolved" : "direct"
   };
 }
 
@@ -6309,6 +6320,19 @@ var CodexRunner = class {
   resolveCodexExecution(args, env = process7.env) {
     return resolveCliExecution("codex", args, env);
   }
+  buildFailureMessage(stderr, stdout, code, dirPath, execConfig) {
+    const reason = stderr.trim() || stdout.trim() || `codex \u9000\u51FA\u7801 ${code}`;
+    return [
+      reason,
+      `cwd=${dirPath || "-"}`,
+      `command=${execConfig.displayCommand || "codex"}`,
+      `resolved=${execConfig.resolvedPath || "-"}`,
+      `fallback=${execConfig.fallback || "-"}`
+    ].join("\n");
+  }
+  buildExecutionLog(prefix, execConfig) {
+    return `${prefix}: ${execConfig.displayCommand} (resolved=${execConfig.resolvedPath || "-"}, fallback=${execConfig.fallback || "direct"})`;
+  }
   writePromptToChildStdin(child, prompt, traceMessage = "") {
     if (!this.shouldUseStdinPrompt(prompt) || !child?.stdin) {
       return;
@@ -6407,7 +6431,7 @@ var CodexRunner = class {
       this.logger.info(`Codex \u51C6\u5907\u6267\u884C: dir=${dirPath}, thread_key=${threadKey || "-"}, session_id=${resolvedSessionId || "-"}, resume=${isResume}`);
       const childEnv = this.buildChildEnv(resolveTraceId(threadKey, resolvedSessionId, dirPath));
       const execConfig = this.resolveCodexExecution(args, childEnv);
-      this.logger.info(formatTraceLog(resolveTraceId(threadKey, resolvedSessionId, dirPath), `Codex \u6267\u884C\u547D\u4EE4: ${execConfig.displayCommand}`));
+      this.logger.info(formatTraceLog(resolveTraceId(threadKey, resolvedSessionId, dirPath), this.buildExecutionLog("Codex \u6267\u884C\u547D\u4EE4", execConfig)));
       const child = spawn(execConfig.command, execConfig.args, {
         cwd: dirPath,
         shell: execConfig.shell,
@@ -6425,15 +6449,17 @@ var CodexRunner = class {
       const timer = this.createTimeout(child, resolveTraceId(threadKey, resolvedSessionId, dirPath), reject, "Codex \u6267\u884C\u8D85\u65F6", CODEX_EXEC_TIMEOUT_MS);
       child.stdout?.on("data", (chunk) => {
         clearTimeout(startupTimer);
-        stdout += String(chunk);
+        stdout += decodeProcessOutputChunk(chunk);
       });
       child.stderr?.on("data", (chunk) => {
-        stderr += String(chunk);
+        stderr += decodeProcessOutputChunk(chunk);
       });
       child.on("error", (error) => {
         clearTimeout(startupTimer);
         clearTimeout(timer);
-        reject(error);
+        reject(new Error(`${error.message}
+cwd=${dirPath || "-"}
+command=${execConfig.displayCommand}`));
       });
       child.on("close", (code) => {
         clearTimeout(startupTimer);
@@ -6451,8 +6477,7 @@ var CodexRunner = class {
           this.stateManager.markCodexRun(dirPath);
         }
         if (code !== 0) {
-          const err = stderr.trim() || stdout.trim() || `codex \u9000\u51FA\u7801 ${code}`;
-          reject(new Error(err));
+          reject(new Error(this.buildFailureMessage(stderr, stdout, code, dirPath, execConfig)));
           return;
         }
         resolve3({
@@ -6503,7 +6528,7 @@ var CodexRunner = class {
       let notifiedSessionId = false;
       const childEnv = this.buildChildEnv(logTraceId);
       const execConfig = this.resolveCodexExecution(args, childEnv);
-      this.logger.info(formatTraceLog(logTraceId, `Codex \u6267\u884C\u547D\u4EE4(\u6D41\u5F0F): ${execConfig.displayCommand}`));
+      this.logger.info(formatTraceLog(logTraceId, this.buildExecutionLog("Codex \u6267\u884C\u547D\u4EE4(\u6D41\u5F0F)", execConfig)));
       const child = spawn(execConfig.command, execConfig.args, {
         cwd: dirPath,
         shell: execConfig.shell,
@@ -6558,13 +6583,13 @@ var CodexRunner = class {
       };
       child.stdout?.on("data", (chunk) => {
         clearTimeout(startupTimer);
-        const text = String(chunk);
+        const text = decodeProcessOutputChunk(chunk);
         stdout += text;
         pending += text;
         consumeLines();
       });
       child.stderr?.on("data", (chunk) => {
-        const text = String(chunk);
+        const text = decodeProcessOutputChunk(chunk);
         stderr += text;
         text.split(/\r?\n/).forEach((line) => {
           if (line.trim() && !shouldIgnoreStderrLine(line)) {
@@ -6578,7 +6603,9 @@ var CodexRunner = class {
         if (taskKey) {
           this.activeChildrenByTaskId.delete(taskKey);
         }
-        reject(error);
+        reject(new Error(`${error.message}
+cwd=${dirPath || "-"}
+command=${execConfig.displayCommand}`));
       });
       child.on("close", (code) => {
         clearTimeout(startupTimer);
@@ -6631,8 +6658,7 @@ var CodexRunner = class {
           this.stateManager.markCodexRun(dirPath);
         }
         if (code !== 0) {
-          const err = stderr.trim() || stdout.trim() || `codex \u9000\u51FA\u7801 ${code}`;
-          reject(new Error(err));
+          reject(new Error(this.buildFailureMessage(stderr, stdout, code, dirPath, execConfig)));
           return;
         }
         resolve3({
@@ -6649,10 +6675,10 @@ var CodexRunner = class {
 import fs12 from "fs";
 import os5 from "os";
 import path11 from "path";
-var VOPS_USER_CACHE_PATH2 = path11.join(os5.homedir(), "ops", "vops_user.json");
-var CHAT_CACHE_TYPE = "__chat_cache__";
-function normalize6(value) {
-  if (value == null) {
+
+// src/hook/display-name.ts
+function normalizeText(value) {
+  if (value === null || value === void 0) {
     return "";
   }
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
@@ -6660,24 +6686,15 @@ function normalize6(value) {
   }
   return "";
 }
-function lower(value) {
-  return normalize6(value).toLowerCase();
-}
-function extractUserFromEmail(email) {
-  const normalizedEmail = lower(email);
-  if (!normalizedEmail.includes("@")) {
-    return "";
-  }
-  return normalizedEmail.split("@")[0] || "";
-}
 function resolveDisplayName(value) {
-  const direct = normalize6(value);
+  const direct = normalizeText(value);
   if (direct) {
     return direct;
   }
   if (!value || typeof value !== "object") {
     return "";
   }
+  const record = value;
   const candidateKeys = [
     "zh_cn",
     "zh-CN",
@@ -6689,15 +6706,30 @@ function resolveDisplayName(value) {
     "name",
     "display_name",
     "full_name",
-    "value"
+    "value",
+    "default_value"
   ];
   for (const key of candidateKeys) {
-    const text = normalize6(value[key]);
+    const text = normalizeText(record[key]);
     if (text) {
       return text;
     }
   }
-  return "";
+  return resolveDisplayName(record.i18n_value) || resolveDisplayName(record.i18nValue) || resolveDisplayName(record.text);
+}
+
+// src/hook/context/identity-resolver.ts
+var VOPS_USER_CACHE_PATH2 = path11.join(os5.homedir(), "ops", "vops_user.json");
+var CHAT_CACHE_TYPE = "__chat_cache__";
+function lower(value) {
+  return normalizeText(value).toLowerCase();
+}
+function extractUserFromEmail(email) {
+  const normalizedEmail = lower(email);
+  if (!normalizedEmail.includes("@")) {
+    return "";
+  }
+  return normalizedEmail.split("@")[0] || "";
 }
 function pickUserData(response) {
   const data = response?.data || {};
@@ -6721,7 +6753,7 @@ function hasUserProfileData(entry) {
   if (!entry || typeof entry !== "object") {
     return false;
   }
-  return Boolean(normalize6(entry.name) || normalize6(entry.user) || normalize6(entry.email));
+  return Boolean(normalizeText(entry.name) || normalizeText(entry.user) || normalizeText(entry.email));
 }
 var IdentityResolver = class {
   logger;
@@ -6735,36 +6767,36 @@ var IdentityResolver = class {
     this.cachePath = VOPS_USER_CACHE_PATH2;
   }
   setTraceId(traceId = "") {
-    this.currentTraceId = normalize6(traceId) || "-";
+    this.currentTraceId = normalizeText(traceId) || "-";
   }
   trace(message) {
     return formatTraceLog(this.currentTraceId, message);
   }
   scoreUserRecord(record) {
     let score = 0;
-    if (normalize6(record?.user || "")) score += 100;
-    if (normalize6(record?.email || "")) score += 40;
-    if (normalize6(record?.feishuUserId || "")) score += 30;
-    if (normalize6(record?.feishuOpenId || "")) score += 20;
-    if (normalize6(record?.name || "")) score += 10;
-    if (normalize6(record?.uId || "")) score += 5;
+    if (normalizeText(record?.user || "")) score += 100;
+    if (normalizeText(record?.email || "")) score += 40;
+    if (normalizeText(record?.feishuUserId || "")) score += 30;
+    if (normalizeText(record?.feishuOpenId || "")) score += 20;
+    if (normalizeText(record?.name || "")) score += 10;
+    if (normalizeText(record?.uId || "")) score += 5;
     return score;
   }
   mergeUserRecord(base, extra) {
     const merged = { ...base };
     const fields = ["uId", "name", "feishuUserId", "feishuOpenId", "feishuProjectUser", "user", "email"];
     for (const field of fields) {
-      const baseValue = normalize6(merged[field]);
-      const extraValue = normalize6(extra?.[field]);
+      const baseValue = normalizeText(merged[field]);
+      const extraValue = normalizeText(extra?.[field]);
       if (!baseValue && extraValue) {
         merged[field] = extraValue;
       }
     }
-    const baseUpdated = normalize6(base?.updatedAt);
-    const extraUpdated = normalize6(extra?.updatedAt);
+    const baseUpdated = normalizeText(base?.updatedAt);
+    const extraUpdated = normalizeText(extra?.updatedAt);
     merged.updatedAt = baseUpdated && extraUpdated ? baseUpdated >= extraUpdated ? baseUpdated : extraUpdated : baseUpdated || extraUpdated || (/* @__PURE__ */ new Date()).toISOString();
     const emailUser = extractUserFromEmail(merged.email);
-    if (!normalize6(merged.user) && emailUser) {
+    if (!normalizeText(merged.user) && emailUser) {
       merged.user = emailUser;
     }
     return merged;
@@ -6782,8 +6814,8 @@ var IdentityResolver = class {
         chatEntries.push(row);
         continue;
       }
-      const normalizedEmail = normalize6(row.email);
-      const normalizedUser = normalize6(row.user) || extractUserFromEmail(normalizedEmail);
+      const normalizedEmail = normalizeText(row.email);
+      const normalizedUser = normalizeText(row.user) || extractUserFromEmail(normalizedEmail);
       row.email = normalizedEmail;
       row.user = lower(normalizedUser);
       userEntries.push(row);
@@ -6808,28 +6840,28 @@ var IdentityResolver = class {
     const userRecords = Array.from(byUser.values());
     const userNameCount = /* @__PURE__ */ new Map();
     userRecords.forEach((item) => {
-      const nameKey = normalize6(item.name);
+      const nameKey = normalizeText(item.name);
       if (nameKey) {
         userNameCount.set(nameKey, (userNameCount.get(nameKey) || 0) + 1);
       }
     });
     const uniqueNameToUser = /* @__PURE__ */ new Map();
     userRecords.forEach((item) => {
-      const nameKey = normalize6(item.name);
+      const nameKey = normalizeText(item.name);
       if (nameKey && userNameCount.get(nameKey) === 1) {
         uniqueNameToUser.set(nameKey, item);
       }
     });
     const byNoUserKey = /* @__PURE__ */ new Map();
     for (const record of noUser) {
-      const nameKey = normalize6(record.name);
+      const nameKey = normalizeText(record.name);
       const uniqueNameTarget = uniqueNameToUser.get(nameKey);
       if (uniqueNameTarget) {
         const merged = this.mergeUserRecord(uniqueNameTarget, record);
         byUser.set(lower(merged.user || uniqueNameTarget.user || ""), merged);
         continue;
       }
-      const idKey = normalize6(record.feishuUserId) || normalize6(record.feishuOpenId) || normalize6(record.uId) || `${nameKey}#${normalize6(record.updatedAt)}`;
+      const idKey = normalizeText(record.feishuUserId) || normalizeText(record.feishuOpenId) || normalizeText(record.uId) || `${nameKey}#${normalizeText(record.updatedAt)}`;
       const existed = byNoUserKey.get(idKey);
       if (!existed) {
         byNoUserKey.set(idKey, record);
@@ -6874,25 +6906,25 @@ var IdentityResolver = class {
     }
   }
   findUserEntries(cache, { userId, openId }) {
-    const uid = normalize6(userId);
-    const oid = normalize6(openId);
+    const uid = normalizeText(userId);
+    const oid = normalizeText(openId);
     return (cache || []).filter((item) => {
       if (!item || typeof item !== "object" || item.__cacheType === CHAT_CACHE_TYPE) {
         return false;
       }
-      return uid && normalize6(item.feishuUserId) === uid || oid && normalize6(item.feishuOpenId) === oid;
+      return uid && normalizeText(item.feishuUserId) === uid || oid && normalizeText(item.feishuOpenId) === oid;
     });
   }
   findChatCache(cache, chatId) {
-    const cid = normalize6(chatId);
+    const cid = normalizeText(chatId);
     if (!cid) {
       return null;
     }
-    return cache.find((item) => item.__cacheType === CHAT_CACHE_TYPE && normalize6(item.chatId) === cid) || null;
+    return cache.find((item) => item.__cacheType === CHAT_CACHE_TYPE && normalizeText(item.chatId) === cid) || null;
   }
   patchRequesterOpenId(cache, { userId = "", openId = "" } = {}) {
-    const uid = normalize6(userId);
-    const oid = normalize6(openId);
+    const uid = normalizeText(userId);
+    const oid = normalizeText(openId);
     if (!uid || !oid) {
       return false;
     }
@@ -6901,7 +6933,7 @@ var IdentityResolver = class {
       if (!item || typeof item !== "object" || item.__cacheType === CHAT_CACHE_TYPE) {
         return;
       }
-      if (normalize6(item.feishuUserId) === uid && !normalize6(item.feishuOpenId)) {
+      if (normalizeText(item.feishuUserId) === uid && !normalizeText(item.feishuOpenId)) {
         item.feishuOpenId = oid;
         item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         changed = true;
@@ -6910,8 +6942,8 @@ var IdentityResolver = class {
     return changed;
   }
   async fetchUserFromLark(userId, openId) {
-    const targetUserId = normalize6(userId);
-    const targetOpenId = normalize6(openId);
+    const targetUserId = normalizeText(userId);
+    const targetOpenId = normalizeText(openId);
     const userApi = this.larkClient?.contact?.v3?.user?.get;
     if (typeof userApi !== "function") {
       return null;
@@ -6940,7 +6972,7 @@ var IdentityResolver = class {
     return null;
   }
   async fetchEmployeeFromDirectory(openId) {
-    const oid = normalize6(openId);
+    const oid = normalizeText(openId);
     const request = this.larkClient?.request;
     if (!oid || typeof request !== "function") {
       return null;
@@ -6966,10 +6998,10 @@ var IdentityResolver = class {
     if (!larkUser || typeof larkUser !== "object") {
       return;
     }
-    const userId = normalize6(larkUser.user_id || larkUser.userId || fallbackUserId);
-    const openId = normalize6(larkUser.open_id || larkUser.openId || fallbackOpenId);
+    const userId = normalizeText(larkUser.user_id || larkUser.userId || fallbackUserId);
+    const openId = normalizeText(larkUser.open_id || larkUser.openId || fallbackOpenId);
     const name = resolveDisplayName(larkUser.name) || resolveDisplayName(larkUser.display_name) || resolveDisplayName(larkUser.en_name) || resolveDisplayName(larkUser.full_name);
-    const email = normalize6(larkUser.email);
+    const email = normalizeText(larkUser.email);
     const emailUser = extractUserFromEmail(email);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (!userId && !openId && !name) {
@@ -6983,7 +7015,7 @@ var IdentityResolver = class {
       existing = cache.find((item) => item.__cacheType !== CHAT_CACHE_TYPE && (lower(item.user) === lower(emailUser) || lower(item.email) === lower(email))) || null;
     }
     if (!existing && name) {
-      existing = cache.find((item) => item.__cacheType !== CHAT_CACHE_TYPE && normalize6(item.name) === name && normalize6(item.user)) || null;
+      existing = cache.find((item) => item.__cacheType !== CHAT_CACHE_TYPE && normalizeText(item.name) === name && normalizeText(item.user)) || null;
     }
     if (existing) {
       existing.name = name || existing.name || "";
@@ -7010,7 +7042,7 @@ var IdentityResolver = class {
     });
   }
   async fetchChatNameFromLark(chatId) {
-    const cid = normalize6(chatId);
+    const cid = normalizeText(chatId);
     const chatApi = this.larkClient?.im?.v1?.chat?.get;
     if (!cid || typeof chatApi !== "function") {
       return "";
@@ -7033,7 +7065,7 @@ var IdentityResolver = class {
     return "";
   }
   async fetchChatMembersFromLark(chatId) {
-    const cid = normalize6(chatId);
+    const cid = normalizeText(chatId);
     const api = this.larkClient?.im?.v1?.chatMembers?.get;
     if (!cid || typeof api !== "function") {
       return [];
@@ -7058,8 +7090,8 @@ var IdentityResolver = class {
     }
     let changed = false;
     for (const member of members) {
-      const userId = normalize6(member.member_id || member.user_id || member.userId);
-      const openId = normalize6(member.open_id || member.openId);
+      const userId = normalizeText(member.member_id || member.user_id || member.userId);
+      const openId = normalizeText(member.open_id || member.openId);
       const name = resolveDisplayName(member.name) || resolveDisplayName(member.display_name) || resolveDisplayName(member.en_name);
       if (!userId && !openId && !name) {
         continue;
@@ -7074,8 +7106,8 @@ var IdentityResolver = class {
     return changed;
   }
   upsertChatCache(cache, chatId, chatName) {
-    const cid = normalize6(chatId);
-    const cname = normalize6(chatName);
+    const cid = normalizeText(chatId);
+    const cname = normalizeText(chatName);
     if (!cid) {
       return;
     }
@@ -7094,7 +7126,7 @@ var IdentityResolver = class {
   }
   async resolveRequester({ userId = "", openId = "", chatId = "" } = {}) {
     const cache = this.loadCache();
-    this.logger.info(this.trace(`\u8EAB\u4EFD\u89E3\u6790\u5F00\u59CB: user_id=${normalize6(userId) || "-"}, open_id=${normalize6(openId) || "-"}, chat_id=${normalize6(chatId) || "-"}`));
+    this.logger.info(this.trace(`\u8EAB\u4EFD\u89E3\u6790\u5F00\u59CB: user_id=${normalizeText(userId) || "-"}, open_id=${normalizeText(openId) || "-"}, chat_id=${normalizeText(chatId) || "-"}`));
     if (this.patchRequesterOpenId(cache, { userId, openId })) {
       this.saveCache();
     }
@@ -7102,12 +7134,12 @@ var IdentityResolver = class {
     if (matchedEntries.length > 0) {
       const first = matchedEntries[0] || {};
       if (hasUserProfileData(first)) {
-        this.logger.info(this.trace(`\u8EAB\u4EFD\u89E3\u6790\u547D\u4E2D\u7F13\u5B58: matched=${matchedEntries.length}, name=${resolveDisplayName(first.name) || "-"}, user=${normalize6(first.user) || "-"}, email=${normalize6(first.email) || "-"}`));
+        this.logger.info(this.trace(`\u8EAB\u4EFD\u89E3\u6790\u547D\u4E2D\u7F13\u5B58: matched=${matchedEntries.length}, name=${resolveDisplayName(first.name) || "-"}, user=${normalizeText(first.user) || "-"}, email=${normalizeText(first.email) || "-"}`));
         return {
-          userId: normalize6(userId) || normalize6(first.feishuUserId),
-          openId: normalize6(openId) || normalize6(first.feishuOpenId),
-          name: resolveDisplayName(first.name) || normalize6(first.user) || normalize6(userId),
-          email: normalize6(first.email),
+          userId: normalizeText(userId) || normalizeText(first.feishuUserId),
+          openId: normalizeText(openId) || normalizeText(first.feishuOpenId),
+          name: resolveDisplayName(first.name) || normalizeText(first.user) || normalizeText(userId),
+          email: normalizeText(first.email),
           matchedEntries,
           from: "cache"
         };
@@ -7117,14 +7149,14 @@ var IdentityResolver = class {
     if (directoryEmployee) {
       const base = directoryEmployee.base_info || directoryEmployee.baseInfo || {};
       const dirName = resolveDisplayName(base.name) || resolveDisplayName(directoryEmployee.name);
-      const dirEmail = normalize6(base.email || directoryEmployee.email);
+      const dirEmail = normalizeText(base.email || directoryEmployee.email);
       if (dirName || dirEmail) {
-        this.updateUserCache(cache, { user_id: normalize6(userId), open_id: normalize6(openId), name: dirName, email: dirEmail }, userId, openId);
+        this.updateUserCache(cache, { user_id: normalizeText(userId), open_id: normalizeText(openId), name: dirName, email: dirEmail }, userId, openId);
         this.saveCache();
         return {
-          userId: normalize6(userId),
-          openId: normalize6(openId),
-          name: dirName || normalize6(userId) || "-",
+          userId: normalizeText(userId),
+          openId: normalizeText(openId),
+          name: dirName || normalizeText(userId) || "-",
           email: dirEmail,
           matchedEntries: this.findUserEntries(cache, { userId, openId }),
           from: "directory"
@@ -7136,21 +7168,21 @@ var IdentityResolver = class {
       this.updateUserCache(cache, larkUser, userId, openId);
       this.saveCache();
       const refreshedMatches = this.findUserEntries(cache, {
-        userId: normalize6(larkUser.user_id || userId),
-        openId: normalize6(larkUser.open_id || openId)
+        userId: normalizeText(larkUser.user_id || userId),
+        openId: normalizeText(larkUser.open_id || openId)
       });
       return {
-        userId: normalize6(larkUser.user_id || userId),
-        openId: normalize6(larkUser.open_id || openId),
-        name: resolveDisplayName(larkUser.name) || normalize6(userId),
-        email: normalize6(larkUser.email),
+        userId: normalizeText(larkUser.user_id || userId),
+        openId: normalizeText(larkUser.open_id || openId),
+        name: resolveDisplayName(larkUser.name) || normalizeText(userId),
+        email: normalizeText(larkUser.email),
         matchedEntries: refreshedMatches,
         from: "lark"
       };
     }
     const members = await this.fetchChatMembersFromLark(chatId);
     if (members.length > 0) {
-      this.logger.info(this.trace(`\u8EAB\u4EFD\u89E3\u6790\u7FA4\u6210\u5458\u515C\u5E95: chat_id=${normalize6(chatId) || "-"}, members=${members.length}`));
+      this.logger.info(this.trace(`\u8EAB\u4EFD\u89E3\u6790\u7FA4\u6210\u5458\u515C\u5E95: chat_id=${normalizeText(chatId) || "-"}, members=${members.length}`));
       this.syncChatMembersToCache(cache, members);
       this.patchRequesterOpenId(cache, { userId, openId });
       this.saveCache();
@@ -7158,19 +7190,19 @@ var IdentityResolver = class {
       if (memberMatches.length > 0) {
         const first = memberMatches[0] || {};
         return {
-          userId: normalize6(userId) || normalize6(first.feishuUserId),
-          openId: normalize6(openId) || normalize6(first.feishuOpenId),
-          name: resolveDisplayName(first.name) || normalize6(first.user) || normalize6(userId),
-          email: normalize6(first.email),
+          userId: normalizeText(userId) || normalizeText(first.feishuUserId),
+          openId: normalizeText(openId) || normalizeText(first.feishuOpenId),
+          name: resolveDisplayName(first.name) || normalizeText(first.user) || normalizeText(userId),
+          email: normalizeText(first.email),
           matchedEntries: memberMatches,
           from: "chat_members"
         };
       }
     }
     return {
-      userId: normalize6(userId),
-      openId: normalize6(openId),
-      name: normalize6(userId) || "-",
+      userId: normalizeText(userId),
+      openId: normalizeText(openId),
+      name: normalizeText(userId) || "-",
       email: "",
       matchedEntries: [],
       from: "id"
@@ -7179,16 +7211,16 @@ var IdentityResolver = class {
   async resolveChat({ chatId = "" } = {}) {
     const cache = this.loadCache();
     const cached = this.findChatCache(cache, chatId);
-    if (normalize6(cached?.chatName)) {
-      return { chatId: normalize6(chatId), chatName: normalize6(cached?.chatName), from: "cache" };
+    if (normalizeText(cached?.chatName)) {
+      return { chatId: normalizeText(chatId), chatName: normalizeText(cached?.chatName), from: "cache" };
     }
     const chatName = await this.fetchChatNameFromLark(chatId);
     if (chatName) {
       this.upsertChatCache(cache, chatId, chatName);
       this.saveCache();
-      return { chatId: normalize6(chatId), chatName, from: "lark" };
+      return { chatId: normalizeText(chatId), chatName, from: "lark" };
     }
-    return { chatId: normalize6(chatId), chatName: normalize6(chatId) || "-", from: "id" };
+    return { chatId: normalizeText(chatId), chatName: normalizeText(chatId) || "-", from: "id" };
   }
   async resolveConversationIdentity({ senderUserId = "", senderOpenId = "", chatId = "" } = {}) {
     const requester = await this.resolveRequester({ userId: senderUserId, openId: senderOpenId, chatId });
@@ -7251,7 +7283,7 @@ var REQUESTER_PERSONA_RULES = Object.freeze({
 var OPS_DIR = path12.join(os6.homedir(), "ops");
 var NIKOU_PROMPTS_DIR = path12.join(OPS_DIR, "nikou-prompts");
 var NIKOU_ROLE_PROMPTS_DIR = path12.join(NIKOU_PROMPTS_DIR, "roles");
-function normalizeText(value) {
+function normalizeText2(value) {
   return String(value || "").trim();
 }
 function ensureDir(dirPath) {
@@ -7319,12 +7351,12 @@ function buildPromptDefinitions() {
   const roleDefinitions = Object.entries(REQUESTER_PERSONA_RULES.roles).map(([roleKey, roleConfig]) => ({
     id: roleKey,
     kind: "role",
-    title: `${normalizeText(roleConfig.label) || roleKey}\u89D2\u8272\u63D0\u793A\u8BCD`,
+    title: `${normalizeText2(roleConfig.label) || roleKey}\u89D2\u8272\u63D0\u793A\u8BCD`,
     path: path12.join(NIKOU_ROLE_PROMPTS_DIR, `${roleKey}.md`),
     legacyPaths: [],
     defaultContent: Array.isArray(roleConfig.promptLines) ? roleConfig.promptLines.join("\n") : "",
     roleKey,
-    roleLabel: normalizeText(roleConfig.label) || roleKey
+    roleLabel: normalizeText2(roleConfig.label) || roleKey
   }));
   return [
     {
@@ -7459,7 +7491,7 @@ var NikouPromptStore = class {
     });
   }
   readRolePrompt(roleKey) {
-    const normalizedRoleKey = normalizeText(roleKey);
+    const normalizedRoleKey = normalizeText2(roleKey);
     if (!normalizedRoleKey || !this.definitions.has(normalizedRoleKey)) {
       return "";
     }
@@ -7590,9 +7622,9 @@ var MessageReceiveStrategy = class {
     const message = event?.message || {};
     const senderId = this.resolveSenderUserId(eventPayload);
     const senderOpenId = this.resolveSenderOpenId(eventPayload);
-    const chatId = String(message?.chat_id || "").trim();
-    const chatType = String(message?.chat_type || "").trim();
-    const messageId = String(message?.message_id || "").trim();
+    const chatId = normalizeText(message?.chat_id || message?.chatId);
+    const chatType = normalizeText(message?.chat_type || message?.chatType);
+    const messageId = normalizeText(message?.message_id || message?.messageId);
     if (!chatId || !messageId) {
       return null;
     }
@@ -7602,12 +7634,12 @@ var MessageReceiveStrategy = class {
       messageId,
       senderId,
       senderOpenId,
-      messageType: String(message?.message_type || "text").trim(),
-      content: String(message?.content || "").trim(),
-      rootId: String(message?.root_id || "").trim(),
-      parentId: String(message?.parent_id || "").trim(),
-      threadId: String(message?.thread_id || "").trim(),
-      createTime: Number.parseInt(String(message?.create_time || 0), 10) || 0,
+      messageType: normalizeText(message?.message_type || message?.messageType || "text"),
+      content: normalizeText(message?.content),
+      rootId: normalizeText(message?.root_id || message?.rootId),
+      parentId: normalizeText(message?.parent_id || message?.parentId),
+      threadId: normalizeText(message?.thread_id || message?.threadId),
+      createTime: Number.parseInt(normalizeText(message?.create_time || message?.createTime || 0), 10) || 0,
       mentions: Array.isArray(message?.mentions) ? message.mentions : []
     };
   }
@@ -7677,7 +7709,8 @@ var MessageReceiveStrategy = class {
       lines.push(`\u6267\u884C\u8EAB\u4EFD: ${resolveOpsUserName()}`);
     }
     if (includeRequester && identity?.requester) {
-      lines.push(`\u63D0\u95EE\u8005: ${identity.requester.name || "-"}(${identity.requester.userId || "-"})`);
+      const requesterName = resolveDisplayName(identity.requester.name) || normalizeText(identity.requester.user) || "-";
+      lines.push(`\u63D0\u95EE\u8005: ${requesterName}(${normalizeText(identity.requester.userId) || "-"})`);
       if (includeRequesterEmail && identity.requester.email) {
         lines.push(`\u63D0\u95EE\u8005\u90AE\u7BB1: ${identity.requester.email}`);
       }
@@ -7686,7 +7719,7 @@ var MessageReceiveStrategy = class {
       }
     }
     if (includeChat && identity?.chat) {
-      lines.push(`\u63D0\u95EE\u7FA4\u804A: ${identity.chat.chatName || "-"}(${identity.chat.chatId || "-"})`);
+      lines.push(`\u63D0\u95EE\u7FA4\u804A: ${resolveDisplayName(identity.chat.chatName) || "-"}(${normalizeText(identity.chat.chatId) || "-"})`);
     }
     return lines;
   }
@@ -11087,7 +11120,7 @@ var LocalBrowserWsServer = class {
 import fs17 from "fs";
 import os10 from "os";
 import path16 from "path";
-function normalize7(value) {
+function normalize6(value) {
   if (value === null || value === void 0) {
     return "";
   }
@@ -11100,8 +11133,8 @@ var HostProfileService = class {
   cachePath;
   constructor(options) {
     this.logger = options.logger;
-    this.ownerUserId = normalize7(options.ownerUserId);
-    this.opsUserName = normalize7(options.opsUserName);
+    this.ownerUserId = normalize6(options.ownerUserId);
+    this.opsUserName = normalize6(options.opsUserName);
     this.cachePath = path16.join(os10.homedir(), "ops", "vops_user.json");
   }
   /**
@@ -11111,12 +11144,12 @@ var HostProfileService = class {
   getProfile() {
     const cacheEntry = this.findCacheEntry();
     return {
-      name: normalize7(cacheEntry?.name),
-      feishuUserId: this.ownerUserId || normalize7(cacheEntry?.feishuUserId),
-      feishuOpenId: normalize7(cacheEntry?.feishuOpenId),
-      employeeNo: normalize7(cacheEntry?.user || cacheEntry?.uId),
-      email: normalize7(cacheEntry?.email),
-      user: normalize7(cacheEntry?.user),
+      name: normalize6(cacheEntry?.name),
+      feishuUserId: this.ownerUserId || normalize6(cacheEntry?.feishuUserId),
+      feishuOpenId: normalize6(cacheEntry?.feishuOpenId),
+      employeeNo: normalize6(cacheEntry?.user || cacheEntry?.uId),
+      email: normalize6(cacheEntry?.email),
+      user: normalize6(cacheEntry?.user),
       opsUserName: this.opsUserName,
       source: cacheEntry ? "cache" : "fallback"
     };
@@ -11128,11 +11161,11 @@ var HostProfileService = class {
     try {
       const parsed = JSON.parse(fs17.readFileSync(this.cachePath, "utf-8"));
       const list = Array.isArray(parsed) ? parsed : [];
-      const byUserId = list.find((item) => normalize7(item.feishuUserId) === this.ownerUserId);
+      const byUserId = list.find((item) => normalize6(item.feishuUserId) === this.ownerUserId);
       if (byUserId) {
         return byUserId;
       }
-      const byOpsUser = list.find((item) => normalize7(item.user) === this.opsUserName);
+      const byOpsUser = list.find((item) => normalize6(item.user) === this.opsUserName);
       if (byOpsUser) {
         return byOpsUser;
       }
@@ -11151,7 +11184,7 @@ import os11 from "os";
 import path17 from "path";
 
 // src/hook/profile/codex-account-utils.ts
-function normalize8(value) {
+function normalize7(value) {
   if (value === null || value === void 0) {
     return "";
   }
@@ -11164,7 +11197,7 @@ function compactLine(line) {
   return stripAnsi2(line).replace(/[│╭╮╰╯]/g, " ").replace(/\s+/g, " ").trim();
 }
 function pickLine(lines, prefix) {
-  const lowerPrefix = normalize8(prefix).toLowerCase();
+  const lowerPrefix = normalize7(prefix).toLowerCase();
   return lines.find((item) => compactLine(item).toLowerCase().startsWith(lowerPrefix)) || "";
 }
 function extractValue(line) {
@@ -11262,7 +11295,7 @@ function normalizeMonth(monthText) {
   return monthMap[String(monthText || "").trim().toLowerCase()] || "";
 }
 function normalizeResetText(raw) {
-  const text = normalize8(raw);
+  const text = normalize7(raw);
   if (!text) {
     return "";
   }
@@ -11309,7 +11342,7 @@ function normalizeUsageText(rawText) {
   return text;
 }
 function normalizePlan(plan) {
-  const raw = normalize8(plan).toLowerCase();
+  const raw = normalize7(plan).toLowerCase();
   if (!raw) {
     return "";
   }
@@ -11329,10 +11362,10 @@ function extractAuthState(auth) {
   }
   const tokens = auth.tokens || {};
   return {
-    accessToken: normalize8(tokens.access_token),
-    idToken: normalize8(tokens.id_token),
-    accountId: normalize8(tokens.account_id || auth.account_id),
-    authMode: normalize8(auth.auth_mode)
+    accessToken: normalize7(tokens.access_token),
+    idToken: normalize7(tokens.id_token),
+    accountId: normalize7(tokens.account_id || auth.account_id),
+    authMode: normalize7(auth.auth_mode)
   };
 }
 function extractAccountInfo(auth) {
@@ -11340,10 +11373,10 @@ function extractAccountInfo(auth) {
   const payload = decodeJwtPayload(authState.accessToken || authState.idToken || "");
   const profileInfo = payload["https://api.openai.com/profile"] || {};
   const authInfo = payload["https://api.openai.com/auth"] || {};
-  const email = normalize8(profileInfo.email || payload.email);
-  const planType = normalize8(authInfo.chatgpt_plan_type);
-  const accountId = normalize8(authInfo.chatgpt_account_id || authState.accountId);
-  const userId = normalize8(authInfo.chatgpt_user_id || authInfo.user_id);
+  const email = normalize7(profileInfo.email || payload.email);
+  const planType = normalize7(authInfo.chatgpt_plan_type);
+  const accountId = normalize7(authInfo.chatgpt_account_id || authState.accountId);
+  const userId = normalize7(authInfo.chatgpt_user_id || authInfo.user_id);
   const planLabel = normalizePlan(planType);
   return {
     email,
@@ -11361,8 +11394,8 @@ function pickRealtimeLimits(payload) {
   const secondary = rateLimit.secondary_window || null;
   const additional = Array.isArray(payload.additional_rate_limits) ? payload.additional_rate_limits : [];
   const weeklyCandidate = additional.find((item) => {
-    const feature = normalize8(item.metered_feature).toLowerCase();
-    const name = normalize8(item.limit_name).toLowerCase();
+    const feature = normalize7(item.metered_feature).toLowerCase();
+    const name = normalize7(item.limit_name).toLowerCase();
     return feature.includes("weekly") || name.includes("weekly");
   }) || additional[0] || null;
   const weeklyRateLimit = weeklyCandidate ? (weeklyCandidate.rate_limit || {}).primary_window : secondary;
@@ -11504,7 +11537,7 @@ var CodexStatusService = class {
 import fs19 from "fs";
 import os12 from "os";
 import path18 from "path";
-function normalize9(value) {
+function normalize8(value) {
   return String(value || "").trim();
 }
 function ensureStoreShape(store) {
@@ -11554,7 +11587,7 @@ function compareProfiles(left, right) {
   return String(left.alias || "").localeCompare(String(right.alias || ""), "zh-Hans-CN");
 }
 function isSameAccount(profile, targetAccount, targetState) {
-  const profileAccountId = normalize9(profile.account?.accountId);
+  const profileAccountId = normalize8(profile.account?.accountId);
   if (profileAccountId && targetAccount.accountId && profileAccountId === targetAccount.accountId) {
     return true;
   }
@@ -11742,11 +11775,11 @@ var CodexAccountService = class {
     const profiles = refreshedProfiles.sort(compareProfiles).map((profile) => ({
       alias: profile.alias,
       current: profile.alias === store.current,
-      account: normalize9(profile.account?.displayText || profile.account?.email),
-      planLabel: normalize9(profile.account?.planLabel),
-      fiveHourLimit: normalize9(profile.usage?.fiveHourLimit),
-      weeklyLimit: normalize9(profile.usage?.weeklyLimit),
-      updatedAt: normalize9(profile.usage?.updatedAt || profile.updatedAt),
+      account: normalize8(profile.account?.displayText || profile.account?.email),
+      planLabel: normalize8(profile.account?.planLabel),
+      fiveHourLimit: normalize8(profile.usage?.fiveHourLimit),
+      weeklyLimit: normalize8(profile.usage?.weeklyLimit),
+      updatedAt: normalize8(profile.usage?.updatedAt || profile.updatedAt),
       fetchOk: Boolean(profile.usage?.fiveHourLimit || profile.usage?.weeklyLimit)
     }));
     return {
@@ -11758,7 +11791,7 @@ var CodexAccountService = class {
    * 按别名切换当前 ~/.codex/auth.json。
    */
   async switchAlias(alias) {
-    const normalizedAlias = normalize9(alias);
+    const normalizedAlias = normalize8(alias);
     const store = await this.ensureCurrentAuthProfile(this.loadStore());
     const target = normalizedAlias ? store.profiles[normalizedAlias] : void 0;
     if (!target) {
@@ -11781,10 +11814,10 @@ var CodexAccountService = class {
     return {
       ok: true,
       alias: normalizedAlias,
-      account: normalize9(refreshed.account?.displayText || refreshed.account?.email),
-      planLabel: normalize9(refreshed.account?.planLabel),
-      fiveHourLimit: normalize9(refreshed.usage?.fiveHourLimit),
-      weeklyLimit: normalize9(refreshed.usage?.weeklyLimit),
+      account: normalize8(refreshed.account?.displayText || refreshed.account?.email),
+      planLabel: normalize8(refreshed.account?.planLabel),
+      fiveHourLimit: normalize8(refreshed.usage?.fiveHourLimit),
+      weeklyLimit: normalize8(refreshed.usage?.weeklyLimit),
       message: ""
     };
   }
@@ -11793,7 +11826,7 @@ var CodexAccountService = class {
 // src/hook/bind/bind-chat-profile-service.ts
 import os13 from "os";
 import path19 from "path";
-function normalize10(value) {
+function normalize9(value) {
   if (value === null || value === void 0) {
     return "";
   }
@@ -11817,7 +11850,7 @@ var BindChatProfileService = class {
         path: { chat_id: chatId }
       });
       const data = response?.data || response || {};
-      return normalize10(data.name || data.chat_name || data.chat?.name);
+      return normalize9(data.name || data.chat_name || data.chat?.name);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger.warn(`\u7FA4\u804A\u540D\u79F0\u89E3\u6790\u5931\u8D25: chat_id=${chatId}, error=${message}`);
@@ -11833,21 +11866,21 @@ var BindChatProfileService = class {
     const items = [];
     for (const [dirPath, binding] of Object.entries(bindings)) {
       const chatIds = Array.isArray(binding?.chat_ids) ? binding.chat_ids.filter(Boolean) : [];
-      const dirName = path19.basename(dirPath || "") || normalize10(dirPath);
+      const dirName = path19.basename(dirPath || "") || normalize9(dirPath);
       for (const chatId of chatIds) {
         const chatName = await this.resolveChatName(chatId);
         items.push({
-          chatId: normalize10(chatId),
-          chatName: chatName || normalize10(chatId),
+          chatId: normalize9(chatId),
+          chatName: chatName || normalize9(chatId),
           dirName,
-          dirPath: normalize10(dirPath),
-          bindAt: normalize10(binding?.bindAt)
+          dirPath: normalize9(dirPath),
+          bindAt: normalize9(binding?.bindAt)
         });
       }
     }
     items.sort((left, right) => right.bindAt.localeCompare(left.bindAt));
     return {
-      hostName: normalize10(os13.hostname()),
+      hostName: normalize9(os13.hostname()),
       count: items.length,
       items
     };
@@ -11859,7 +11892,7 @@ import fs20 from "fs";
 import os14 from "os";
 import path20 from "path";
 var LATEST_SESSION_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-function normalize11(value) {
+function normalize10(value) {
   return String(value || "").trim();
 }
 function isSameLocalDate(leftDate, rightDate) {
@@ -11936,10 +11969,10 @@ var P2PSessionService = class {
   }
   buildSessionKey(input) {
     return [
-      normalize11(input.ownerUserId),
-      normalize11(input.requesterUserId),
-      normalize11(input.chatId),
-      normalize11(input.anchorMessageId)
+      normalize10(input.ownerUserId),
+      normalize10(input.requesterUserId),
+      normalize10(input.chatId),
+      normalize10(input.anchorMessageId)
     ].join("::");
   }
   parseNewConversationCommand(text = "") {
@@ -11976,9 +12009,9 @@ var P2PSessionService = class {
    * 解析当前单聊应该复用哪个会话。
    */
   resolveSessionContext(input) {
-    const ownerUserId = normalize11(this.stateManager.getState()?.ownerUserId || "");
+    const ownerUserId = normalize10(this.stateManager.getState()?.ownerUserId || "");
     if (!input.forceNew) {
-      const candidates = Array.from(new Set([normalize11(input.rootId), normalize11(input.parentId)].filter(Boolean)));
+      const candidates = Array.from(new Set([normalize10(input.rootId), normalize10(input.parentId)].filter(Boolean)));
       for (const referencedId of candidates) {
         const matched = this.stateManager.getP2PSessionByMessageId(referencedId);
         if (!matched) {
@@ -11986,13 +12019,13 @@ var P2PSessionService = class {
         }
         return {
           ownerUserId,
-          requesterUserId: normalize11(input.requesterUserId),
-          chatId: normalize11(input.chatId),
-          dirPath: normalize11(input.dirPath),
-          anchorMessageId: normalize11(matched.anchorMessageId || referencedId || input.messageId),
-          existingSessionId: normalize11(matched.sessionId),
-          sessionKey: normalize11(matched.sessionKey),
-          messageIds: Array.isArray(matched.messageIds) ? matched.messageIds.map((item) => normalize11(item)).filter(Boolean) : [],
+          requesterUserId: normalize10(input.requesterUserId),
+          chatId: normalize10(input.chatId),
+          dirPath: normalize10(input.dirPath),
+          anchorMessageId: normalize10(matched.anchorMessageId || referencedId || input.messageId),
+          existingSessionId: normalize10(matched.sessionId),
+          sessionKey: normalize10(matched.sessionKey),
+          messageIds: Array.isArray(matched.messageIds) ? matched.messageIds.map((item) => normalize10(item)).filter(Boolean) : [],
           matchedBy: "reference"
         };
       }
@@ -12001,26 +12034,26 @@ var P2PSessionService = class {
         requesterUserId: input.requesterUserId,
         chatId: input.chatId
       });
-      if (latest && normalize11(latest.sessionId)) {
+      if (latest && normalize10(latest.sessionId)) {
         return {
           ownerUserId,
-          requesterUserId: normalize11(input.requesterUserId),
-          chatId: normalize11(input.chatId),
-          dirPath: normalize11(input.dirPath || latest.dirPath),
-          anchorMessageId: normalize11(latest.anchorMessageId),
-          existingSessionId: normalize11(latest.sessionId),
-          sessionKey: normalize11(latest.sessionKey),
-          messageIds: Array.isArray(latest.messageIds) ? latest.messageIds.map((item) => normalize11(item)).filter(Boolean) : [],
+          requesterUserId: normalize10(input.requesterUserId),
+          chatId: normalize10(input.chatId),
+          dirPath: normalize10(input.dirPath || latest.dirPath),
+          anchorMessageId: normalize10(latest.anchorMessageId),
+          existingSessionId: normalize10(latest.sessionId),
+          sessionKey: normalize10(latest.sessionKey),
+          messageIds: Array.isArray(latest.messageIds) ? latest.messageIds.map((item) => normalize10(item)).filter(Boolean) : [],
           matchedBy: "latest"
         };
       }
     }
-    const anchorMessageId = normalize11(input.rootId || input.parentId || input.messageId);
+    const anchorMessageId = normalize10(input.rootId || input.parentId || input.messageId);
     return {
       ownerUserId,
-      requesterUserId: normalize11(input.requesterUserId),
-      chatId: normalize11(input.chatId),
-      dirPath: normalize11(input.dirPath),
+      requesterUserId: normalize10(input.requesterUserId),
+      chatId: normalize10(input.chatId),
+      dirPath: normalize10(input.dirPath),
       anchorMessageId,
       existingSessionId: "",
       sessionKey: this.buildSessionKey({
@@ -12039,12 +12072,12 @@ var P2PSessionService = class {
     }
     this.stateManager.upsertP2PSession({
       sessionKey: input.sessionKey,
-      ownerUserId: normalize11(input.ownerUserId),
-      requesterUserId: normalize11(input.requesterUserId),
-      chatId: normalize11(input.chatId),
-      anchorMessageId: normalize11(input.anchorMessageId),
-      dirPath: normalize11(input.dirPath),
-      sessionId: normalize11(input.sessionId)
+      ownerUserId: normalize10(input.ownerUserId),
+      requesterUserId: normalize10(input.requesterUserId),
+      chatId: normalize10(input.chatId),
+      anchorMessageId: normalize10(input.anchorMessageId),
+      dirPath: normalize10(input.dirPath),
+      sessionId: normalize10(input.sessionId)
     }, input.messageIds);
   }
 };
@@ -12052,11 +12085,11 @@ var P2PSessionService = class {
 // src/hook/memory/memory-bucket-resolver.ts
 import fs21 from "fs";
 import path21 from "path";
-function normalize12(value) {
+function normalize11(value) {
   return String(value || "").trim();
 }
 function buildSafeSegment(value, fallback = "unknown") {
-  const normalized = normalize12(value).replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_");
+  const normalized = normalize11(value).replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_");
   return normalized || fallback;
 }
 function buildTodayString(offsetDays = 0) {
@@ -12082,8 +12115,8 @@ var MemoryBucketResolver = class {
     const requester = buildSafeSegment(requesterUserId, "requester");
     const baseDir = path21.join(this.getRootDir(), "p2p", owner, requester);
     return this.buildBucket({
-      bucketKey: `p2p::${normalize12(ownerUserId)}::${normalize12(requesterUserId)}`,
-      bucketLabel: `\u5355\u804A(${normalize12(requesterUserId) || requester})`,
+      bucketKey: `p2p::${normalize11(ownerUserId)}::${normalize11(requesterUserId)}`,
+      bucketLabel: `\u5355\u804A(${normalize11(requesterUserId) || requester})`,
       bucketType: "p2p",
       baseDir,
       chatId
@@ -12093,8 +12126,8 @@ var MemoryBucketResolver = class {
     const chat = buildSafeSegment(chatId, "chat");
     const baseDir = path21.join(this.getRootDir(), "group", chat);
     return this.buildBucket({
-      bucketKey: `group::${normalize12(chatId)}`,
-      bucketLabel: `\u7FA4\u804A(${normalize12(chatId) || chat})`,
+      bucketKey: `group::${normalize11(chatId)}`,
+      bucketLabel: `\u7FA4\u804A(${normalize11(chatId) || chat})`,
       bucketType: "group",
       baseDir,
       chatId
@@ -12108,7 +12141,7 @@ var MemoryBucketResolver = class {
       bucketKey,
       bucketLabel,
       bucketType,
-      chatId: normalize12(chatId),
+      chatId: normalize11(chatId),
       baseDir,
       memoryDir,
       longTermPath: path21.join(baseDir, "MEMORY.md"),
@@ -12138,11 +12171,11 @@ var MemoryBucketResolver = class {
 };
 
 // src/hook/memory/memory-extract-service.ts
-function normalize13(value) {
+function normalize12(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 function extractSummary(text = "") {
-  const normalized = normalize13(text).replace(/^\/new\s*/i, "").replace(/^(记住|记一下|写入记忆|更新记忆|记到长期记忆)\s*/i, "").trim();
+  const normalized = normalize12(text).replace(/^\/new\s*/i, "").replace(/^(记住|记一下|写入记忆|更新记忆|记到长期记忆)\s*/i, "").trim();
   if (!normalized) {
     return "";
   }
@@ -12150,7 +12183,7 @@ function extractSummary(text = "") {
 }
 var MemoryExtractService = class {
   extractExplicit(text = "") {
-    const normalized = normalize13(text);
+    const normalized = normalize12(text);
     if (!normalized) {
       return { matched: false, target: "DAILY", summary: "" };
     }
@@ -12166,8 +12199,8 @@ var MemoryExtractService = class {
     if (String(chatType || "").trim() !== "p2p") {
       return { shouldWrite: false, target: "DAILY", summary: "" };
     }
-    const normalized = normalize13(questionText);
-    if (!normalized || !normalize13(resultText)) {
+    const normalized = normalize12(questionText);
+    if (!normalized || !normalize12(resultText)) {
       return { shouldWrite: false, target: "DAILY", summary: "" };
     }
     const likelyMemory = /(以后|默认|偏好|习惯|优先|总是|不要|回答时|称呼我|风格|长期|固定规则)/i.test(normalized);
@@ -12184,7 +12217,7 @@ var MemoryExtractService = class {
 };
 
 // src/hook/memory/memory-index-service.ts
-function normalize14(value) {
+function normalize13(value) {
   return String(value || "").trim();
 }
 function toSnippet(text = "", maxLength = 220) {
@@ -12207,7 +12240,7 @@ var MemoryIndexService = class {
     this.docsByBucket.set(String(bucket.bucketKey || ""), docs);
   }
   async search(bucket, query, limit = 5) {
-    const text = normalize14(query);
+    const text = normalize13(query);
     if (!text) {
       return [];
     }
@@ -12243,7 +12276,7 @@ ${content}`.toLowerCase();
 // src/hook/memory/memory-service.ts
 import fs22 from "fs";
 import path22 from "path";
-function normalize15(value) {
+function normalize14(value) {
   return String(value || "").trim();
 }
 function nowIso() {
@@ -12369,7 +12402,7 @@ ${nextLine}`;
     return { longTermText, dailyText, searchResults };
   }
   resolveCommand(text = "") {
-    const normalized = normalize15(text);
+    const normalized = normalize14(text);
     if (!normalized) {
       return { matched: false };
     }
@@ -12380,7 +12413,7 @@ ${nextLine}`;
     if (/^确认重置长期记忆$/i.test(normalized)) return { matched: true, type: "confirm_reset_memory" };
     const searchMatch = normalized.match(/^搜索记忆\s+([\s\S]+)$/i);
     if (searchMatch) {
-      return { matched: true, type: "search_memory", query: normalize15(searchMatch[1]) };
+      return { matched: true, type: "search_memory", query: normalize14(searchMatch[1]) };
     }
     const explicit = this.extractService.extractExplicit(normalized);
     if (explicit.matched) {
@@ -12432,7 +12465,7 @@ ${item.snippet}`);
 ${lines.join("\n\n")}` };
       }
       case "write_memory": {
-        const summary = normalize15(command.summary);
+        const summary = normalize14(command.summary);
         if (!summary) {
           return { handled: true, text: "\u8BB0\u5FC6\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u5DF2\u5FFD\u7565" };
         }
@@ -12465,7 +12498,7 @@ ${lines.join("\n\n")}` };
 };
 
 // src/hook/reminder/reminder-action-classifier.ts
-function normalize16(value) {
+function normalize15(value) {
   return String(value || "").replace(/[\u200B-\u200D\uFEFF]/g, "").trim();
 }
 var NOTIFY_PATTERNS = [
@@ -12500,7 +12533,7 @@ var AGENT_PATTERNS = [
 ];
 var ReminderActionClassifier = class {
   classify(rawText = "") {
-    const text = normalize16(rawText);
+    const text = normalize15(rawText);
     if (!text) {
       return { ok: false, reason: "empty_action" };
     }
@@ -12517,7 +12550,7 @@ var ReminderActionClassifier = class {
 
 // src/hook/reminder/reminder-agent-executor.ts
 import fs23 from "fs";
-function normalize17(value) {
+function normalize16(value) {
   return String(value || "").trim();
 }
 var ReminderAgentExecutor = class {
@@ -12540,16 +12573,16 @@ var ReminderAgentExecutor = class {
     this.isExecutionBusy = typeof isExecutionBusy === "function" ? isExecutionBusy : () => false;
   }
   resolveSessionKey(job) {
-    const ownerUserId = normalize17(job?.ownerUserId);
-    const chatType = normalize17(job?.delivery?.chatType || job?.chatType);
-    const chatId = normalize17(job?.delivery?.chatId || job?.chatId);
-    const rootId = normalize17(job?.rootId || job?.delivery?.rootId);
+    const ownerUserId = normalize16(job?.ownerUserId);
+    const chatType = normalize16(job?.delivery?.chatType || job?.chatType);
+    const chatId = normalize16(job?.delivery?.chatId || job?.chatId);
+    const rootId = normalize16(job?.rootId || job?.delivery?.rootId);
     if (chatType === "p2p") return `p2p::${ownerUserId || "unknown"}`;
     if (chatType === "group") return rootId ? `group::${chatId || "unknown"}::${rootId}` : `group::${chatId || "unknown"}`;
     return "";
   }
   loadAiHookPrompt(requesterUserId = "") {
-    const promptPath = requesterUserId ? requesterUserId === normalize17(process.env.AGENT_BLOCK_OWNER_USER_ID) ? resolveAiHookPath() : resolveAiHookGuestPath() : resolveAiHookGuestPath();
+    const promptPath = requesterUserId ? requesterUserId === normalize16(process.env.AGENT_BLOCK_OWNER_USER_ID) ? resolveAiHookPath() : resolveAiHookGuestPath() : resolveAiHookGuestPath();
     if (!fs23.existsSync(promptPath)) {
       return "";
     }
@@ -12569,8 +12602,8 @@ var ReminderAgentExecutor = class {
     if (!dirResolved.ok || !dirResolved.dirPath) {
       return { ok: false, retryLater: false, error: dirResolved.error || "\u9ED8\u8BA4\u76EE\u5F55\u672A\u521D\u59CB\u5316" };
     }
-    const requesterUserId = normalize17(job?.requesterUserId || job?.delivery?.requesterUserId);
-    const actionPrompt = normalize17(job?.action?.prompt || job?.action?.text);
+    const requesterUserId = normalize16(job?.requesterUserId || job?.delivery?.requesterUserId);
+    const actionPrompt = normalize16(job?.action?.prompt || job?.action?.text);
     if (!actionPrompt) {
       return { ok: false, retryLater: false, error: "\u7F3A\u5C11\u5B9A\u65F6\u6267\u884C\u5185\u5BB9" };
     }
@@ -12580,9 +12613,9 @@ var ReminderAgentExecutor = class {
 ${actionPrompt}` : actionPrompt;
     const memoryBucket = this.memoryService?.resolveBucket({
       chatType: "p2p",
-      ownerUserId: normalize17(job?.ownerUserId),
+      ownerUserId: normalize16(job?.ownerUserId),
       requesterUserId,
-      chatId: normalize17(job?.delivery?.chatId)
+      chatId: normalize16(job?.delivery?.chatId)
     }) || null;
     this.logger.info(formatTraceLog(traceId, `\u5B9A\u65F6\u4EFB\u52A1\u5F00\u59CB\u6267\u884C: job_id=${job?.id || "-"}, dir=${dirResolved.dirPath}, action=agent_turn, session_key=${sessionKey || "-"}`));
     const result = await this.codexRunner.run(prompt, dirResolved.dirPath, {
@@ -12710,7 +12743,7 @@ var ReminderMessageBuilder = class {
 };
 
 // src/hook/reminder/reminder-parser.ts
-function normalize18(value) {
+function normalize17(value) {
   return String(value || "").replace(/[\u200B-\u200D\uFEFF]/g, "").trim();
 }
 function pad23(value) {
@@ -12724,7 +12757,7 @@ function buildTodayOrTomorrow(baseDate, daysOffset, hour, minute) {
   return next;
 }
 function toMinutes(amount, unit) {
-  const normalized = normalize18(unit).toLowerCase();
+  const normalized = normalize17(unit).toLowerCase();
   if (["\u5206\u949F", "\u5206", "m", "min", "mins", "minute", "minutes"].includes(normalized)) {
     return amount;
   }
@@ -12736,7 +12769,7 @@ var ReminderParser = class {
     this.actionClassifier = actionClassifier;
   }
   parse(rawText, now = /* @__PURE__ */ new Date(), context = {}) {
-    const text = normalize18(rawText);
+    const text = normalize17(rawText);
     if (!text) {
       return { matched: false };
     }
@@ -12751,7 +12784,7 @@ var ReminderParser = class {
     if (/^清空提醒$/i.test(text)) return { matched: true, type: "clear_jobs" };
     const cancelMatch = text.match(/^取消提醒\s+([A-Za-z0-9_-]+)$/i);
     if (cancelMatch) {
-      return { matched: true, type: "cancel_job", jobId: normalize18(cancelMatch[1]) };
+      return { matched: true, type: "cancel_job", jobId: normalize17(cancelMatch[1]) };
     }
     return { matched: false };
   }
@@ -12765,12 +12798,12 @@ var ReminderParser = class {
   parseSlashRemind(text, now) {
     const match = text.match(/^\/remind\s+(\d+)\s*(分钟|分|min|mins|minute|minutes|m|小时|时|hour|hours|h)\s+(.+)$/i);
     if (!match) return { matched: false };
-    return this.buildCreateResult(Number.parseInt(match[1] || "0", 10), normalize18(match[2]).toLowerCase(), normalize18(match[3]), now, { forceKind: "notify" });
+    return this.buildCreateResult(Number.parseInt(match[1] || "0", 10), normalize17(match[2]).toLowerCase(), normalize17(match[3]), now, { forceKind: "notify" });
   }
   parseRelativeReminder(text, now, context) {
     const match = text.match(/^(\d+)\s*(分钟|分|min|mins|minute|minutes|m|小时|时|hour|hours|h)\s*后\s*(.+)$/i);
     if (!match) return { matched: false };
-    return this.buildCreateResult(Number.parseInt(match[1] || "0", 10), normalize18(match[2]).toLowerCase(), normalize18(match[3]), now, context);
+    return this.buildCreateResult(Number.parseInt(match[1] || "0", 10), normalize17(match[2]).toLowerCase(), normalize17(match[3]), now, context);
   }
   buildCreateResult(amount, unit, content, now, context = {}) {
     if (!Number.isFinite(amount) || amount <= 0) {
@@ -12797,10 +12830,10 @@ var ReminderParser = class {
   parseFixedReminder(text, now, context) {
     const match = text.match(/^(今天|明天)\s*(\d{1,2})[:：](\d{2})\s*(.+)$/i);
     if (!match) return { matched: false };
-    const dayToken = normalize18(match[1]);
+    const dayToken = normalize17(match[1]);
     const hour = Number.parseInt(match[2] || "0", 10);
     const minute = Number.parseInt(match[3] || "0", 10);
-    const content = normalize18(match[4]);
+    const content = normalize17(match[4]);
     if (!Number.isFinite(hour) || hour < 0 || hour > 23 || !Number.isFinite(minute) || minute < 0 || minute > 59) {
       return { matched: true, type: "invalid", error: "\u63D0\u9192\u65F6\u95F4\u683C\u5F0F\u4E0D\u6B63\u786E\uFF0C\u8BF7\u4F7F\u7528 HH:mm" };
     }
@@ -12826,7 +12859,7 @@ var ReminderParser = class {
     };
   }
   resolveAction(content, context = {}, forceKind = "") {
-    const normalizedContent = normalize18(content);
+    const normalizedContent = normalize17(content);
     if (!normalizedContent) {
       return { ok: false, reason: "empty_action" };
     }
@@ -12891,16 +12924,16 @@ var ReminderStore = class {
 };
 
 // src/hook/reminder/reminder-service.ts
-function normalize19(value) {
+function normalize18(value) {
   return String(value || "").trim();
 }
 function normalizeTargets2(items = []) {
   const seen = /* @__PURE__ */ new Set();
   const targets = [];
   (Array.isArray(items) ? items : []).forEach((item) => {
-    const userId = normalize19(item?.userId || item?.user_id);
-    const openId = normalize19(item?.openId || item?.open_id);
-    const name = normalize19(item?.name);
+    const userId = normalize18(item?.userId || item?.user_id);
+    const openId = normalize18(item?.openId || item?.open_id);
+    const name = normalize18(item?.name);
     if (!userId && !openId) {
       return;
     }
@@ -13026,27 +13059,27 @@ var ReminderService = class {
     const nowMs = Date.now();
     return {
       id: createJobId(),
-      ownerUserId: normalize19(context.ownerUserId),
-      requesterUserId: normalize19(context.requesterUserId),
-      requesterOpenId: normalize19(context.requesterOpenId),
-      chatType: normalize19(context.chatType),
-      messageId: normalize19(context.messageId),
-      rootId: normalize19(context.rootId),
-      parentId: normalize19(context.parentId),
-      traceId: normalize19(context.traceId),
+      ownerUserId: normalize18(context.ownerUserId),
+      requesterUserId: normalize18(context.requesterUserId),
+      requesterOpenId: normalize18(context.requesterOpenId),
+      chatType: normalize18(context.chatType),
+      messageId: normalize18(context.messageId),
+      rootId: normalize18(context.rootId),
+      parentId: normalize18(context.parentId),
+      traceId: normalize18(context.traceId),
       schedule: { kind: "at", runAtMs: Number(command?.schedule?.runAtMs || 0) },
       action: {
-        kind: normalize19(command?.action?.kind || "notify"),
-        text: normalize19(command?.action?.content || command?.action?.text || command?.sourceText),
-        prompt: normalize19(command?.action?.content || command?.action?.prompt || command?.sourceText)
+        kind: normalize18(command?.action?.kind || "notify"),
+        text: normalize18(command?.action?.content || command?.action?.text || command?.sourceText),
+        prompt: normalize18(command?.action?.content || command?.action?.prompt || command?.sourceText)
       },
       delivery: {
         mode: "feishu_message",
         target: "origin_chat",
-        chatType: normalize19(context.chatType),
-        chatId: normalize19(context.chatId),
-        requesterUserId: normalize19(context.requesterUserId),
-        requesterOpenId: normalize19(context.requesterOpenId),
+        chatType: normalize18(context.chatType),
+        chatId: normalize18(context.chatId),
+        requesterUserId: normalize18(context.requesterUserId),
+        requesterOpenId: normalize18(context.requesterOpenId),
         notifyTargets: normalizeTargets2(context.reminderTargets)
       },
       state: {
@@ -13062,20 +13095,20 @@ var ReminderService = class {
     return this.store.readAll().filter((job) => this.isVisibleForContext(job, context) && job?.state?.status === "pending");
   }
   findPendingJobForContext(context, jobId = "") {
-    const normalized = normalize19(jobId);
+    const normalized = normalize18(jobId);
     if (!normalized) {
       return null;
     }
-    return this.listPendingJobs(context).find((job) => normalize19(job?.id) === normalized) || null;
+    return this.listPendingJobs(context).find((job) => normalize18(job?.id) === normalized) || null;
   }
   isVisibleForContext(job, context) {
-    const requesterUserId = normalize19(context.requesterUserId);
-    const chatId = normalize19(context.chatId);
-    const chatType = normalize19(context.chatType).toLowerCase();
+    const requesterUserId = normalize18(context.requesterUserId);
+    const chatId = normalize18(context.chatId);
+    const chatType = normalize18(context.chatType).toLowerCase();
     if (chatType === "p2p") {
-      return normalize19(job?.requesterUserId) === requesterUserId && normalize19(job?.delivery?.chatId) === chatId;
+      return normalize18(job?.requesterUserId) === requesterUserId && normalize18(job?.delivery?.chatId) === chatId;
     }
-    return normalize19(job?.requesterUserId) === requesterUserId && normalize19(job?.delivery?.chatId) === chatId;
+    return normalize18(job?.requesterUserId) === requesterUserId && normalize18(job?.delivery?.chatId) === chatId;
   }
   scheduleNext() {
     if (!this.running) {
@@ -13111,9 +13144,9 @@ var ReminderService = class {
     this.scheduleNext();
   }
   async executeJob(job) {
-    const traceId = normalize19(job?.traceId || job?.messageId || job?.id);
+    const traceId = normalize18(job?.traceId || job?.messageId || job?.id);
     try {
-      const actionKind = normalize19(job?.action?.kind);
+      const actionKind = normalize18(job?.action?.kind);
       if (actionKind === "notify") {
         await this.sendNotify(job);
       } else if (actionKind === "agent_turn") {
@@ -13137,7 +13170,7 @@ var ReminderService = class {
       this.logger.info(formatTraceLog(traceId, `\u63D0\u9192\u5DF2\u89E6\u53D1: job_id=${job.id}, chat_id=${job?.delivery?.chatId || "-"}, chat_type=${job?.delivery?.chatType || "-"}`));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (normalize19(job?.action?.kind) === "agent_turn") {
+      if (normalize18(job?.action?.kind) === "agent_turn") {
         try {
           await this.sendAgentTurnFailure(job, message);
         } catch (notifyError) {
@@ -13161,7 +13194,7 @@ var ReminderService = class {
     });
   }
   async sendNotify(job) {
-    const chatId = normalize19(job?.delivery?.chatId);
+    const chatId = normalize18(job?.delivery?.chatId);
     if (!chatId) {
       throw new Error("\u63D0\u9192\u7F3A\u5C11 chat_id");
     }
@@ -13175,7 +13208,7 @@ var ReminderService = class {
     });
   }
   async sendAgentTurnResult(job, resultText = "") {
-    const chatId = normalize19(job?.delivery?.chatId);
+    const chatId = normalize18(job?.delivery?.chatId);
     if (!chatId) {
       throw new Error("\u5B9A\u65F6\u4EFB\u52A1\u7F3A\u5C11 chat_id");
     }
@@ -13189,7 +13222,7 @@ var ReminderService = class {
     });
   }
   async sendAgentTurnFailure(job, error = "") {
-    const chatId = normalize19(job?.delivery?.chatId);
+    const chatId = normalize18(job?.delivery?.chatId);
     if (!chatId) {
       throw new Error("\u5B9A\u65F6\u4EFB\u52A1\u7F3A\u5C11 chat_id");
     }
@@ -13207,32 +13240,6 @@ var ReminderService = class {
 // src/hook/persona/requester-persona-service.ts
 import fs25 from "fs";
 import path24 from "path";
-function normalize20(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return String(value).trim();
-  }
-  return "";
-}
-function resolveDisplayName2(value) {
-  const direct = normalize20(value);
-  if (direct) {
-    return direct;
-  }
-  if (!value || typeof value !== "object") {
-    return "";
-  }
-  const candidateKeys = ["zh_cn", "zh-CN", "zh_hans", "zh", "en_us", "en-US", "en", "name", "value"];
-  for (const key of candidateKeys) {
-    const text = normalize20(value?.[key]);
-    if (text) {
-      return text;
-    }
-  }
-  return "";
-}
 function pickUserData2(response) {
   const data = response?.data || {};
   const user = data?.user || data?.data?.user || data?.items?.[0] || data?.item || {};
@@ -13310,8 +13317,8 @@ var RequesterPersonaService = class {
     }
   }
   buildCacheKey(userId = "", openId = "") {
-    const normalizedUserId = normalize20(userId);
-    const normalizedOpenId = normalize20(openId);
+    const normalizedUserId = normalizeText(userId);
+    const normalizedOpenId = normalizeText(openId);
     if (normalizedUserId) {
       return `user_id:${normalizedUserId}`;
     }
@@ -13350,8 +13357,8 @@ var RequesterPersonaService = class {
       return null;
     }
     const attempts = [];
-    const normalizedUserId = normalize20(userId);
-    const normalizedOpenId = normalize20(openId);
+    const normalizedUserId = normalizeText(userId);
+    const normalizedOpenId = normalizeText(openId);
     if (normalizedUserId) {
       attempts.push({
         path: { user_id: normalizedUserId },
@@ -13387,7 +13394,7 @@ var RequesterPersonaService = class {
     return null;
   }
   async tryFetchJobLevelName(jobLevelId = "") {
-    const normalizedJobLevelId = normalize20(jobLevelId);
+    const normalizedJobLevelId = normalizeText(jobLevelId);
     if (!normalizedJobLevelId || !this.jobLevelNameLookupEnabled) {
       return "";
     }
@@ -13403,7 +13410,7 @@ var RequesterPersonaService = class {
         return "";
       }
       const jobLevel = pickJobLevelData(response);
-      return resolveDisplayName2(jobLevel.name) || resolveDisplayName2(jobLevel.i18n_name) || normalize20(jobLevel.code || "");
+      return resolveDisplayName(jobLevel.name) || resolveDisplayName(jobLevel.i18n_name) || normalizeText(jobLevel.code || "");
     } catch (error) {
       const errorCode = error?.response?.data?.code || error?.code || "";
       if ((String(errorCode) === "99991672" || String(error?.message || "").includes("Access denied")) && !this.jobLevelPermissionDeniedLogged) {
@@ -13415,14 +13422,14 @@ var RequesterPersonaService = class {
     }
   }
   resolveRoleConfig(jobLevelId = "") {
-    const normalizedJobLevelId = normalize20(jobLevelId);
+    const normalizedJobLevelId = normalizeText(jobLevelId);
     if (!normalizedJobLevelId) {
       return { roleKey: "", roleConfig: null };
     }
     const roles = this.rules?.roles || {};
     for (const [roleKey, roleConfig] of Object.entries(roles)) {
       const ids = Array.isArray(roleConfig?.jobLevelIds) ? roleConfig.jobLevelIds : [];
-      if (ids.map((item) => normalize20(item)).includes(normalizedJobLevelId)) {
+      if (ids.map((item) => normalizeText(item)).includes(normalizedJobLevelId)) {
         return { roleKey, roleConfig };
       }
     }
@@ -13438,12 +13445,12 @@ var RequesterPersonaService = class {
       return "";
     }
     const lines = [
-      `- \u63D0\u95EE\u8005\u89D2\u8272: ${normalize20(roleConfig.label) || roleKey}`,
-      `- \u63D0\u95EE\u8005 user_id: ${normalize20(record.userId) || "-"}`,
-      `- \u63D0\u95EE\u8005\u59D3\u540D: ${normalize20(record.name) || "-"}`,
-      `- \u63D0\u95EE\u8005\u804C\u7EA7ID: ${normalize20(record.jobLevelId) || "-"}`
+      `- \u63D0\u95EE\u8005\u89D2\u8272: ${normalizeText(roleConfig.label) || roleKey}`,
+      `- \u63D0\u95EE\u8005 user_id: ${normalizeText(record.userId) || "-"}`,
+      `- \u63D0\u95EE\u8005\u59D3\u540D: ${normalizeText(record.name) || "-"}`,
+      `- \u63D0\u95EE\u8005\u804C\u7EA7ID: ${normalizeText(record.jobLevelId) || "-"}`
     ];
-    const jobLevelName = normalize20(record.jobLevelName);
+    const jobLevelName = normalizeText(record.jobLevelName);
     if (jobLevelName) {
       lines.push(`- \u63D0\u95EE\u8005\u804C\u7EA7\u540D\u79F0: ${jobLevelName}`);
     }
@@ -13457,12 +13464,12 @@ var RequesterPersonaService = class {
   }
   buildRecord({ cached = null, user = null, identity = null, jobLevelName = "" } = {}) {
     const requester = identity?.requester || {};
-    const userId = normalize20(user?.user_id || cached?.userId || requester?.userId || "");
-    const openId = normalize20(user?.open_id || cached?.openId || requester?.openId || "");
-    const name = resolveDisplayName2(user?.name) || resolveDisplayName2(user?.en_name) || normalize20(cached?.name || requester?.name || "");
-    const email = normalize20(user?.email || cached?.email || requester?.email || "");
-    const jobLevelId = normalize20(user?.job_level_id || cached?.jobLevelId || "");
-    const nextJobLevelName = normalize20(jobLevelName || cached?.jobLevelName || "");
+    const userId = normalizeText(user?.user_id || cached?.userId || requester?.userId || "");
+    const openId = normalizeText(user?.open_id || cached?.openId || requester?.openId || "");
+    const name = resolveDisplayName(user?.name) || resolveDisplayName(user?.en_name) || normalizeText(cached?.name || requester?.name || "");
+    const email = normalizeText(user?.email || cached?.email || requester?.email || "");
+    const jobLevelId = normalizeText(user?.job_level_id || cached?.jobLevelId || "");
+    const nextJobLevelName = normalizeText(jobLevelName || cached?.jobLevelName || "");
     const { roleKey, roleConfig } = this.resolveRoleConfig(jobLevelId);
     const now = Date.now();
     return {
@@ -13473,18 +13480,18 @@ var RequesterPersonaService = class {
       jobLevelId,
       jobLevelName: nextJobLevelName,
       personaRole: roleKey,
-      personaLabel: normalize20(roleConfig?.label || ""),
+      personaLabel: normalizeText(roleConfig?.label || ""),
       updatedAt: now,
       expiresAt: now + this.cacheTtlMs
     };
   }
   logUnmatchedJobLevel(jobLevelId = "", userId = "") {
-    const normalizedJobLevelId = normalize20(jobLevelId);
+    const normalizedJobLevelId = normalizeText(jobLevelId);
     if (!normalizedJobLevelId || this.loggedUnknownJobLevelIds.has(normalizedJobLevelId)) {
       return;
     }
     this.loggedUnknownJobLevelIds.add(normalizedJobLevelId);
-    this.logger.info(`\u63D0\u95EE\u8005\u753B\u50CF\u672A\u547D\u4E2D\u6620\u5C04: user_id=${normalize20(userId) || "-"}, job_level_id=${normalizedJobLevelId}`);
+    this.logger.info(`\u63D0\u95EE\u8005\u753B\u50CF\u672A\u547D\u4E2D\u6620\u5C04: user_id=${normalizeText(userId) || "-"}, job_level_id=${normalizedJobLevelId}`);
   }
   async resolveRequesterPersona({
     chatType = "",
@@ -13492,11 +13499,11 @@ var RequesterPersonaService = class {
     senderOpenId = "",
     identity = null
   } = {}) {
-    if (normalize20(chatType).toLowerCase() !== "group") {
+    if (normalizeText(chatType).toLowerCase() !== "group") {
       return null;
     }
-    const normalizedUserId = normalize20(senderUserId);
-    const normalizedOpenId = normalize20(senderOpenId);
+    const normalizedUserId = normalizeText(senderUserId);
+    const normalizedOpenId = normalizeText(senderOpenId);
     if (!normalizedUserId && !normalizedOpenId) {
       return null;
     }
@@ -13522,7 +13529,7 @@ var RequesterPersonaService = class {
     if (!user) {
       return null;
     }
-    const jobLevelId = normalize20(user?.job_level_id || "");
+    const jobLevelId = normalizeText(user?.job_level_id || "");
     let jobLevelName = "";
     if (jobLevelId) {
       jobLevelName = await this.tryFetchJobLevelName(jobLevelId);
@@ -13687,17 +13694,8 @@ function buildWorkerState(options) {
 }
 
 // src/hook/worker/worker-owner-resolver.ts
-function normalize21(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return String(value).trim();
-  }
-  return "";
-}
 function lower2(value) {
-  return normalize21(value).toLowerCase();
+  return normalizeText(value).toLowerCase();
 }
 function buildEmailFromUser(user = "") {
   const normalizedUser = lower2(user);
@@ -13706,42 +13704,13 @@ function buildEmailFromUser(user = "") {
   }
   return normalizedUser.includes("@") ? normalizedUser : `${normalizedUser}@hstong.com`;
 }
-function resolveDisplayName3(value) {
-  const direct = normalize21(value);
-  if (direct) {
-    return direct;
-  }
-  if (!value || typeof value !== "object") {
-    return "";
-  }
-  const candidateKeys = [
-    "zh_cn",
-    "zh-CN",
-    "zh_hans",
-    "zh",
-    "en_us",
-    "en-US",
-    "en",
-    "name",
-    "display_name",
-    "full_name",
-    "value"
-  ];
-  for (const key of candidateKeys) {
-    const text = normalize21(value[key]);
-    if (text) {
-      return text;
-    }
-  }
-  return "";
-}
 function scoreEntry(entry) {
   let score = 0;
-  if (normalize21(entry.feishuUserId)) score += 100;
-  if (normalize21(entry.feishuOpenId)) score += 30;
-  if (normalize21(entry.email)) score += 20;
-  if (normalize21(entry.user)) score += 10;
-  if (normalize21(entry.name)) score += 5;
+  if (normalizeText(entry.feishuUserId)) score += 100;
+  if (normalizeText(entry.feishuOpenId)) score += 30;
+  if (normalizeText(entry.email)) score += 20;
+  if (normalizeText(entry.user)) score += 10;
+  if (normalizeText(entry.name)) score += 5;
   return score;
 }
 var WorkerOwnerResolver = class {
@@ -13750,7 +13719,7 @@ var WorkerOwnerResolver = class {
   identityResolver;
   constructor({ logger: logger3, larkClient, opsUserName = "" }) {
     this.logger = logger3;
-    this.opsUserName = normalize21(opsUserName);
+    this.opsUserName = normalizeText(opsUserName);
     this.identityResolver = new IdentityResolver({ logger: logger3, larkClient });
   }
   pickBestEntry(entries = []) {
@@ -13768,7 +13737,7 @@ var WorkerOwnerResolver = class {
       if (!item || typeof item !== "object" || item.__cacheType) {
         return false;
       }
-      return lower2(item.user) === ownerKey || normalize21(item.name) === this.opsUserName;
+      return lower2(item.user) === ownerKey || normalizeText(item.name) === this.opsUserName;
     });
     return this.pickBestEntry(candidates);
   }
@@ -13796,10 +13765,10 @@ var WorkerOwnerResolver = class {
         return null;
       }
       return {
-        user_id: normalize21(user.user_id),
-        open_id: normalize21(user.open_id),
-        name: normalize21(user.name),
-        email: normalize21(user.email || normalizedEmail)
+        user_id: normalizeText(user.user_id),
+        open_id: normalizeText(user.open_id),
+        name: normalizeText(user.name),
+        email: normalizeText(user.email || normalizedEmail)
       };
     } catch (error) {
       const detail = error?.response?.data ? JSON.stringify(error.response.data) : error instanceof Error ? error.message : String(error);
@@ -13808,8 +13777,8 @@ var WorkerOwnerResolver = class {
     }
   }
   async enrichEntryFromEmail(cache, entry) {
-    const baseUser = normalize21(entry?.user) || this.opsUserName;
-    const candidateEmail = normalize21(entry?.email) || buildEmailFromUser(baseUser);
+    const baseUser = normalizeText(entry?.user) || this.opsUserName;
+    const candidateEmail = normalizeText(entry?.email) || buildEmailFromUser(baseUser);
     if (!candidateEmail) {
       return null;
     }
@@ -13818,19 +13787,19 @@ var WorkerOwnerResolver = class {
       return null;
     }
     let detailedUser = null;
-    if (!normalize21(larkUser.open_id)) {
+    if (!normalizeText(larkUser.open_id)) {
       detailedUser = await this.identityResolver.fetchUserFromLark(larkUser.user_id, "");
     }
     this.identityResolver.updateUserCache(cache, {
-      user_id: normalize21(detailedUser?.user_id || larkUser.user_id),
-      open_id: normalize21(detailedUser?.open_id || larkUser.open_id),
-      name: normalize21(detailedUser?.name || larkUser.name || entry?.name),
-      email: normalize21(detailedUser?.email || larkUser.email || candidateEmail)
-    }, normalize21(detailedUser?.user_id || larkUser.user_id), normalize21(detailedUser?.open_id || larkUser.open_id));
+      user_id: normalizeText(detailedUser?.user_id || larkUser.user_id),
+      open_id: normalizeText(detailedUser?.open_id || larkUser.open_id),
+      name: normalizeText(detailedUser?.name || larkUser.name || entry?.name),
+      email: normalizeText(detailedUser?.email || larkUser.email || candidateEmail)
+    }, normalizeText(detailedUser?.user_id || larkUser.user_id), normalizeText(detailedUser?.open_id || larkUser.open_id));
     this.identityResolver.saveCache();
     const refreshed = this.findOwnerEntry(cache);
     if (refreshed) {
-      this.logger.info(`\u4ECE\u8282\u70B9\u5F52\u5C5E\u8EAB\u4EFD\u5DF2\u6309\u90AE\u7BB1\u8865\u9F50: ops_user=${this.opsUserName}, email=${candidateEmail}, owner_user_id=${normalize21(refreshed.feishuUserId) || "-"}`);
+      this.logger.info(`\u4ECE\u8282\u70B9\u5F52\u5C5E\u8EAB\u4EFD\u5DF2\u6309\u90AE\u7BB1\u8865\u9F50: ops_user=${this.opsUserName}, email=${candidateEmail}, owner_user_id=${normalizeText(refreshed.feishuUserId) || "-"}`);
     }
     return refreshed;
   }
@@ -13841,30 +13810,30 @@ var WorkerOwnerResolver = class {
     }
     const cache = this.identityResolver.loadCache();
     let entry = this.findOwnerEntry(cache);
-    if (!normalize21(entry?.feishuUserId) || !normalize21(entry?.feishuOpenId)) {
+    if (!normalizeText(entry?.feishuUserId) || !normalizeText(entry?.feishuOpenId)) {
       entry = await this.enrichEntryFromEmail(cache, entry);
     }
-    const ownerUserId = normalize21(entry?.feishuUserId);
+    const ownerUserId = normalizeText(entry?.feishuUserId);
     if (!ownerUserId) {
       this.logger.warn(`\u4ECE\u8282\u70B9\u5F52\u5C5E\u8EAB\u4EFD\u89E3\u6790\u5931\u8D25: ops_user=${this.opsUserName}, reason=missing_feishu_user_id`);
       return {
         ...this.emptyProfile(entry ? "cache_incomplete" : "cache_miss"),
-        ownerDisplayName: resolveDisplayName3(entry?.name),
-        ownerOpenId: normalize21(entry?.feishuOpenId),
-        employeeNo: normalize21(entry?.uId),
-        email: normalize21(entry?.email),
-        user: normalize21(entry?.user)
+        ownerDisplayName: resolveDisplayName(entry?.name),
+        ownerOpenId: normalizeText(entry?.feishuOpenId),
+        employeeNo: normalizeText(entry?.uId),
+        email: normalizeText(entry?.email),
+        user: normalizeText(entry?.user)
       };
     }
-    const ownerDisplayName = resolveDisplayName3(entry?.name) || normalize21(entry?.user) || this.opsUserName;
+    const ownerDisplayName = resolveDisplayName(entry?.name) || normalizeText(entry?.user) || this.opsUserName;
     this.logger.info(`\u4ECE\u8282\u70B9\u5F52\u5C5E\u8EAB\u4EFD\u89E3\u6790\u6210\u529F: ops_user=${this.opsUserName}, owner_user_id=${ownerUserId}, owner_name=${ownerDisplayName}`);
     return {
       ownerUserId,
       ownerDisplayName,
-      ownerOpenId: normalize21(entry?.feishuOpenId),
-      employeeNo: normalize21(entry?.uId),
-      email: normalize21(entry?.email),
-      user: normalize21(entry?.user),
+      ownerOpenId: normalizeText(entry?.feishuOpenId),
+      employeeNo: normalizeText(entry?.uId),
+      email: normalizeText(entry?.email),
+      user: normalizeText(entry?.user),
       opsUserName: this.opsUserName,
       source: "cache"
     };
@@ -13890,28 +13859,11 @@ var PERSPECTIVE_RULES = [
   { key: "product", label: "\u4EA7\u54C1\u89C6\u89D2", pattern: /产品经理|产品/i },
   { key: "backend", label: "\u540E\u7AEF\u7814\u53D1\u89C6\u89D2", pattern: /java/i }
 ];
-function normalize22(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return String(value).trim();
-  }
-  return "";
-}
 function resolveLocalizedText(value) {
-  const direct = normalize22(value);
-  if (direct) {
-    return direct;
-  }
-  if (!value || typeof value !== "object") {
-    return "";
-  }
-  const record = value;
-  return normalize22(record.default_value) || normalize22(record.i18n_value?.zh_cn) || normalize22(record.i18n_value?.en_us);
+  return resolveDisplayName(value);
 }
 function resolvePerspectiveByJobTitle(jobTitle = "") {
-  const matched = PERSPECTIVE_RULES.find((rule) => rule.pattern.test(normalize22(jobTitle)));
+  const matched = PERSPECTIVE_RULES.find((rule) => rule.pattern.test(normalizeText(jobTitle)));
   return matched ? { perspectiveKey: matched.key, perspectiveLabel: matched.label } : { perspectiveKey: "general", perspectiveLabel: "\u901A\u7528\u89C6\u89D2" };
 }
 var WorkerPerspectiveResolver = class {
@@ -13922,7 +13874,7 @@ var WorkerPerspectiveResolver = class {
     this.larkClient = larkClient;
   }
   async resolve(ownerProfile) {
-    const ownerOpenId = normalize22(ownerProfile.ownerOpenId);
+    const ownerOpenId = normalizeText(ownerProfile.ownerOpenId);
     if (!ownerOpenId || typeof this.larkClient?.request !== "function") {
       return this.buildResult();
     }
@@ -13946,9 +13898,9 @@ var WorkerPerspectiveResolver = class {
       const jobTitle = employee?.work_info?.job_title || {};
       const result = this.buildResult(
         resolveLocalizedText(jobTitle.job_title_name),
-        normalize22(jobTitle.job_title_id)
+        normalizeText(jobTitle.job_title_id)
       );
-      this.logger.info(`\u5BBF\u4E3B\u804C\u52A1\u89E3\u6790\u5B8C\u6210: owner=${normalize22(ownerProfile.ownerDisplayName) || "-"}, job_title=${result.jobTitle || "-"}, perspective=${result.perspectiveLabel}`);
+      this.logger.info(`\u5BBF\u4E3B\u804C\u52A1\u89E3\u6790\u5B8C\u6210: owner=${normalizeText(ownerProfile.ownerDisplayName) || "-"}, job_title=${result.jobTitle || "-"}, perspective=${result.perspectiveLabel}`);
       return result;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -13958,15 +13910,15 @@ var WorkerPerspectiveResolver = class {
   }
   buildResult(jobTitle = "", jobTitleId = "") {
     return {
-      jobTitle: normalize22(jobTitle),
-      jobTitleId: normalize22(jobTitleId),
+      jobTitle: normalizeText(jobTitle),
+      jobTitleId: normalizeText(jobTitleId),
       ...resolvePerspectiveByJobTitle(jobTitle)
     };
   }
 };
 
 // src/hook/worker/owner-notify-service.ts
-function normalize23(value) {
+function normalize19(value) {
   return String(value || "").trim();
 }
 var OwnerNotifyService = class {
@@ -13980,12 +13932,12 @@ var OwnerNotifyService = class {
     this.ownerProfile = ownerProfile;
   }
   hasTarget() {
-    return Boolean(normalize23(this.ownerProfile.ownerUserId) || normalize23(this.ownerProfile.ownerOpenId));
+    return Boolean(normalize19(this.ownerProfile.ownerUserId) || normalize19(this.ownerProfile.ownerOpenId));
   }
   async sendText(text) {
     const content = JSON.stringify({ text: String(text || "").trim() });
-    const userId = normalize23(this.ownerProfile.ownerUserId);
-    const openId = normalize23(this.ownerProfile.ownerOpenId);
+    const userId = normalize19(this.ownerProfile.ownerUserId);
+    const openId = normalize19(this.ownerProfile.ownerOpenId);
     if (userId) {
       return await this.larkClient.im.v1.message.create({
         params: { receive_id_type: "user_id" },