@yoooclaw/phone-notifications 1.11.5 → 1.11.7

package/dist/index.cjs

@@ -251,6 +251,18 @@ function writeDotEnv(key, value) {
   }
   (0, import_node_fs7.writeFileSync)(path2, lines.join("\n"), "utf-8");
 }
+function buildEnvUrls(host) {
+  const https = `https://${host}`;
+  const wss = `wss://${host}`;
+  return {
+    lightApiUrl: `${https}/api/message/tob/sendMessage`,
+    relayTunnelUrl: `${wss}/message/messages/ws/plugin`,
+    appNameMapUrl: `${https}/api/application-config/app-package/config-all`,
+    modelProxyLongRecordingSubmitTaskUrl: `${https}/api/model-proxy/long-recording/submit-task`,
+    modelProxyLongRecordingQueryTaskResultBaseUrl: `${https}/api/model-proxy/long-recording/query-task-result`,
+    accountFileDeleteUrl: `${https}/api/account/file/delete`
+  };
+}
 function readDotEnv() {
   const path2 = resolveStateFile(".env");
   if (!(0, import_node_fs7.existsSync)(path2)) return {};
@@ -290,7 +302,7 @@ function getEnvUrls(env) {
 function getAvailableEnvs() {
   return Object.keys(ENV_CONFIG);
 }
-var import_node_fs7, import_node_path6, ENV_CONFIG, VALID_ENVS;
+var import_node_fs7, import_node_path6, ENV_HOSTS, ENV_CONFIG, VALID_ENVS;
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
@@ -298,31 +310,15 @@ var init_env = __esm({
     import_node_path6 = require("path");
     init_credentials();
     init_host();
+    ENV_HOSTS = {
+      development: "openclaw-service-dev.yoooclaw.com",
+      test: "openclaw-service-test.yoooclaw.com",
+      production: "openclaw-service.yoooclaw.com"
+    };
     ENV_CONFIG = {
-      development: {
-        lightApiUrl: "https://openclaw-service-dev.yoooclaw.com/api/message/tob/sendMessage",
-        relayTunnelUrl: "wss://openclaw-service-dev.yoooclaw.com/message/messages/ws/plugin",
-        appNameMapUrl: "https://openclaw-service-dev.yoooclaw.com/api/application-config/app-package/config-all",
-        modelProxyLongRecordingSubmitTaskUrl: "https://openclaw-service-dev.yoooclaw.com/api/model-proxy/long-recording/submit-task",
-        modelProxyLongRecordingQueryTaskResultBaseUrl: "https://openclaw-service-dev.yoooclaw.com/api/model-proxy/long-recording/query-task-result",
-        accountFileDeleteUrl: "https://openclaw-service-dev.yoooclaw.com/api/account/file/delete"
-      },
-      test: {
-        lightApiUrl: "https://openclaw-service-test.yoooclaw.com/api/message/tob/sendMessage",
-        relayTunnelUrl: "wss://openclaw-service-test.yoooclaw.com/message/messages/ws/plugin",
-        appNameMapUrl: "https://openclaw-service-test.yoooclaw.com/api/application-config/app-package/config-all",
-        modelProxyLongRecordingSubmitTaskUrl: "https://openclaw-service-test.yoooclaw.com/api/model-proxy/long-recording/submit-task",
-        modelProxyLongRecordingQueryTaskResultBaseUrl: "https://openclaw-service-test.yoooclaw.com/api/model-proxy/long-recording/query-task-result",
-        accountFileDeleteUrl: "https://openclaw-service-test.yoooclaw.com/api/account/file/delete"
-      },
-      production: {
-        lightApiUrl: "https://openclaw-service.yoooclaw.com/api/message/tob/sendMessage",
-        relayTunnelUrl: "wss://openclaw-service.yoooclaw.com/message/messages/ws/plugin",
-        appNameMapUrl: "https://openclaw-service.yoooclaw.com/api/application-config/app-package/config-all",
-        modelProxyLongRecordingSubmitTaskUrl: "https://openclaw-service.yoooclaw.com/api/model-proxy/long-recording/submit-task",
-        modelProxyLongRecordingQueryTaskResultBaseUrl: "https://openclaw-service.yoooclaw.com/api/model-proxy/long-recording/query-task-result",
-        accountFileDeleteUrl: "https://openclaw-service.yoooclaw.com/api/account/file/delete"
-      }
+      development: buildEnvUrls(ENV_HOSTS.development),
+      test: buildEnvUrls(ENV_HOSTS.test),
+      production: buildEnvUrls(ENV_HOSTS.production)
     };
     VALID_ENVS = new Set(Object.keys(ENV_CONFIG));
   }
@@ -5578,7 +5574,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.11.5".trim();
+  const version = "1.11.7".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -5598,6 +5594,78 @@ var PLUGIN_VERSION = readBuildInjectedVersion() ?? readPluginVersionFromPackageJ
 // src/logger.ts
 var DEFAULT_LOG_RETENTION_DAYS = 30;
 var DAY_MS = 24 * 60 * 60 * 1e3;
+var REDACTED = "[redacted]";
+var REDACTED_SECRET = "[redacted-secret]";
+var REDACTED_URL = "[redacted-url]";
+var SECRET_KEYS = [
+  "apiKey",
+  "api_key",
+  "appKey",
+  "authorization",
+  "password",
+  "secret",
+  "token",
+  "accessToken",
+  "refreshToken",
+  "gatewayToken",
+  "gatewayPassword",
+  "apnsToken",
+  "deviceToken",
+  "X-Api-Key-Id",
+  "x-api-key-id",
+  "x-openclaw-password"
+];
+var USER_TEXT_KEYS = [
+  "accountId",
+  "body",
+  "content",
+  "conversationName",
+  "deviceId",
+  "loginAccount",
+  "metadata",
+  "name",
+  "raw",
+  "rawResponse",
+  "reason",
+  "recordResult",
+  "recordingName",
+  "resBody",
+  "response",
+  "senderName",
+  "sourceText",
+  "sourceTextList",
+  "summary",
+  "summaryResult",
+  "summaryText",
+  "text",
+  "title",
+  "transcript",
+  "transcriptData",
+  "userId"
+];
+var USER_URL_KEYS = [
+  "audio",
+  "audioOssUrl",
+  "fileUrl",
+  "oss_audio_url",
+  "oss_srt_url",
+  "srt",
+  "url"
+];
+var SENSITIVE_QUERY_KEYS = [
+  "access_token",
+  "api_key",
+  "apikey",
+  "authorization",
+  "fileUrl",
+  "password",
+  "refresh_token",
+  "secret",
+  "signature",
+  "token",
+  "x-api-key-id",
+  "x-oss-security-token"
+];
 function isBetaPluginVersion(version = PLUGIN_VERSION) {
   return /\bbeta\b/i.test(version);
 }
@@ -5606,13 +5674,14 @@ function createVersionAwareLogger(upstream, options = {}) {
     return upstream;
   }
   return {
-    info() {
+    info(msg) {
+      upstream.info(redactLogMessage(msg));
     },
     warn(msg) {
-      upstream.warn(msg);
+      upstream.warn(redactLogMessage(msg));
     },
     error(msg) {
-      upstream.error(msg);
+      upstream.error(redactLogMessage(msg));
     }
   };
 }
@@ -5620,7 +5689,7 @@ var PluginFileLogger = class {
   constructor(upstream, stateDir, options = {}) {
     this.upstream = upstream;
     this.logsDir = (0, import_node_path.join)(stateDir, "plugins", "phone-notifications", "logs");
-    this.infoEnabled = isBetaPluginVersion(options.version ?? PLUGIN_VERSION);
+    this.redactLogs = !isBetaPluginVersion(options.version ?? PLUGIN_VERSION);
     this.retentionDays = Number.isFinite(options.retentionDays) && (options.retentionDays ?? 0) > 0 ? options.retentionDays : DEFAULT_LOG_RETENTION_DAYS;
     (0, import_node_fs2.mkdirSync)(this.logsDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
@@ -5628,24 +5697,27 @@ var PluginFileLogger = class {
     this.lastPruneDateKey = formatDate(now);
   }
   logsDir;
-  infoEnabled;
+  redactLogs;
   retentionDays;
   lastPruneDateKey = null;
   info(msg) {
     this.prepareLogDate(/* @__PURE__ */ new Date());
-    if (!this.infoEnabled) {
-      return;
-    }
-    this.upstream.info(msg);
-    this.append("INFO", msg);
+    const safeMsg = this.formatLogMessage(msg);
+    this.upstream.info(safeMsg);
+    this.append("INFO", safeMsg);
   }
   warn(msg) {
-    this.upstream.warn(msg);
-    this.append("WARN", msg);
+    const safeMsg = this.formatLogMessage(msg);
+    this.upstream.warn(safeMsg);
+    this.append("WARN", safeMsg);
   }
   error(msg) {
-    this.upstream.error(msg);
-    this.append("ERROR", msg);
+    const safeMsg = this.formatLogMessage(msg);
+    this.upstream.error(safeMsg);
+    this.append("ERROR", safeMsg);
+  }
+  formatLogMessage(msg) {
+    return this.redactLogs ? redactLogMessage(msg) : msg;
   }
   append(level, msg) {
     const now = /* @__PURE__ */ new Date();
@@ -5681,6 +5753,188 @@ var PluginFileLogger = class {
     }
   }
 };
+function redactLogMessage(msg) {
+  let redacted = String(msg);
+  redacted = redactQuotedObjectFields(redacted, SECRET_KEYS, REDACTED_SECRET);
+  redacted = redactQuotedObjectFields(redacted, USER_TEXT_KEYS, REDACTED);
+  redacted = redactQuotedObjectFields(redacted, USER_URL_KEYS, REDACTED_URL);
+  redacted = redactStructuredKeyValueFields(
+    redacted,
+    SECRET_KEYS,
+    REDACTED_SECRET
+  );
+  redacted = redactStructuredKeyValueFields(redacted, USER_TEXT_KEYS, REDACTED);
+  redacted = redactStructuredKeyValueFields(redacted, USER_URL_KEYS, REDACTED_URL);
+  redacted = redactKeyValueFields(redacted, SECRET_KEYS, REDACTED_SECRET);
+  redacted = redactKeyValueFields(redacted, USER_TEXT_KEYS, REDACTED);
+  redacted = redactKeyValueFields(redacted, USER_URL_KEYS, REDACTED_URL);
+  redacted = redactColonTextFields(redacted, SECRET_KEYS, REDACTED_SECRET);
+  redacted = redactColonTextFields(redacted, USER_TEXT_KEYS, REDACTED);
+  redacted = redactQueryParams(redacted, SENSITIVE_QUERY_KEYS);
+  redacted = redactBearerTokens(redacted);
+  redacted = redactLikelyUserUrls(redacted);
+  redacted = redactEmails(redacted);
+  redacted = redactPhoneNumbers(redacted);
+  redacted = redactJwtTokens(redacted);
+  redacted = redactLongHexTokens(redacted);
+  return redacted;
+}
+function redactQuotedObjectFields(input, keys, placeholder) {
+  const keyPattern = buildKeyPattern(keys);
+  return input.replace(
+    new RegExp(
+      `(["'])(${keyPattern})\\1\\s*:\\s*(?:"(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|[^,}\\]]+)`,
+      "gi"
+    ),
+    (_match, quote, key) => `${quote}${key}${quote}: "${placeholder}"`
+  );
+}
+function redactKeyValueFields(input, keys, placeholder) {
+  const keyPattern = buildKeyPattern(keys);
+  return input.replace(
+    new RegExp(
+      `(?<![?&])\\b(${keyPattern})\\s*=\\s*(?:Bearer\\s+[^,\\s)]+|"(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|[^,\\s)]+)`,
+      "gi"
+    ),
+    (_match, key) => `${key}=${placeholder}`
+  );
+}
+function redactStructuredKeyValueFields(input, keys, placeholder) {
+  const keyPattern = buildKeyPattern(keys);
+  const regex = new RegExp(`\\b(${keyPattern})\\s*=\\s*([\\[{])`, "gi");
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while (match = regex.exec(input)) {
+    const valueStart = regex.lastIndex - 1;
+    const valueEnd = findStructuredValueEnd(input, valueStart);
+    if (valueEnd === null) {
+      continue;
+    }
+    result += input.slice(lastIndex, match.index);
+    result += `${match[1]}=${placeholder}`;
+    lastIndex = valueEnd;
+    regex.lastIndex = valueEnd;
+  }
+  if (lastIndex === 0) {
+    return input;
+  }
+  return result + input.slice(lastIndex);
+}
+function findStructuredValueEnd(input, start) {
+  const open = input[start];
+  const close = open === "{" ? "}" : "]";
+  const stack = [close];
+  let quote = null;
+  let escaped = false;
+  for (let i = start + 1; i < input.length; i++) {
+    const ch = input[i];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      stack.push(ch === "{" ? "}" : "]");
+      continue;
+    }
+    if (ch === stack[stack.length - 1]) {
+      stack.pop();
+      if (stack.length === 0) {
+        return i + 1;
+      }
+    }
+  }
+  return null;
+}
+function redactColonTextFields(input, keys, placeholder) {
+  const keyPattern = buildKeyPattern(keys);
+  return input.replace(
+    new RegExp(`\\b(${keyPattern})\\s*:\\s*([^,\\n]+)`, "gi"),
+    (_match, key) => `${key}: ${placeholder}`
+  );
+}
+function redactQueryParams(input, keys) {
+  const keyPattern = buildKeyPattern(keys);
+  return input.replace(
+    new RegExp(`([?&](${keyPattern})=)([^&#\\s]+)`, "gi"),
+    (_match, prefix) => `${prefix}${encodeURIComponent(REDACTED)}`
+  );
+}
+function redactBearerTokens(input) {
+  return input.replace(
+    /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi,
+    `$1${REDACTED_SECRET}`
+  );
+}
+function redactJwtTokens(input) {
+  return input.replace(
+    /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
+    REDACTED_SECRET
+  );
+}
+function redactLongHexTokens(input) {
+  return input.replace(/\b[a-f0-9]{32,}\b/gi, REDACTED_SECRET);
+}
+function redactEmails(input) {
+  return input.replace(
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
+    "[redacted-email]"
+  );
+}
+function redactPhoneNumbers(input) {
+  return input.replace(
+    /\b1[3-9]\d{9}\b/g,
+    (phone) => `${phone.slice(0, 3)}****${phone.slice(-4)}`
+  );
+}
+function redactLikelyUserUrls(input) {
+  return input.replace(
+    /https?:\/\/[^\s"',)]+/gi,
+    (rawUrl) => redactUrl(rawUrl)
+  );
+}
+function redactUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    for (const key of Array.from(url.searchParams.keys())) {
+      if (SENSITIVE_QUERY_KEYS.some(
+        (sensitiveKey) => sensitiveKey.toLowerCase() === key.toLowerCase()
+      )) {
+        url.searchParams.set(key, REDACTED);
+      }
+    }
+    if (shouldRedactUrlPath(url)) {
+      return `${url.origin}/${REDACTED_URL}`;
+    }
+    return url.toString();
+  } catch {
+    return rawUrl;
+  }
+}
+function shouldRedactUrlPath(url) {
+  const host = url.hostname.toLowerCase();
+  const path2 = decodeURIComponent(url.pathname).toLowerCase();
+  if (/(^|\.)((oss|cos|s3|storage|cdn)[.-])/.test(host) || /(aliyuncs|myqcloud|amazonaws|oss|storage|cdn)/.test(host)) {
+    return true;
+  }
+  return /\/(audio|avatar|feedback|log|logs|recording|recordings)\//.test(path2) || /\.(aac|flac|json|m4a|md|mp3|ogg|opus|srt|wav|zip)$/i.test(path2);
+}
+function buildKeyPattern(keys) {
+  return keys.map(escapeRegExp).join("|");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function formatDate(d) {
   const y = d.getFullYear();
   const m = String(d.getMonth() + 1).padStart(2, "0");
@@ -7215,10 +7469,21 @@ var InlineLightRuleEvaluator = class {
    */
   async evaluate(notifications) {
     if (notifications.length === 0) return true;
+    this.reloadRegistry("before evaluation");
     const rules = this.registry.getEnabled();
-    if (rules.length === 0) return true;
+    if (rules.length === 0) {
+      this.logger.info(
+        `lightrules: no enabled rules (notifications=${notifications.length})`
+      );
+      return true;
+    }
     const matches = await this.invoker.matchNotifications(notifications, rules);
-    if (matches === null) return false;
+    if (matches === null) {
+      this.logger.warn(
+        `lightrules: match failed (notifications=${notifications.length}, rules=${rules.length})`
+      );
+      return false;
+    }
     if (matches.length === 0) {
       this.logger.info(
         `lightrules: 0 matches (notifications=${notifications.length}, rules=${rules.length})`
@@ -7226,12 +7491,19 @@ var InlineLightRuleEvaluator = class {
       return true;
     }
     const firedRules = /* @__PURE__ */ new Set();
+    this.reloadRegistry("before triggering");
     for (const match of matches) {
       if (firedRules.has(match.ruleName)) continue;
       const rule = this.registry.get(match.ruleName);
       if (!rule) {
         this.logger.warn(
-          `lightrules: matched rule '${match.ruleName}' not found in registry`
+          `lightrules: matched rule '${match.ruleName}' skipped - not found after reload`
+        );
+        continue;
+      }
+      if (!rule.enabled) {
+        this.logger.info(
+          `lightrules: matched rule '${match.ruleName}' skipped - disabled after reload`
         );
         continue;
       }
@@ -7244,6 +7516,15 @@ var InlineLightRuleEvaluator = class {
     );
     return true;
   }
+  reloadRegistry(stage) {
+    try {
+      this.registry.reload();
+    } catch (err2) {
+      this.logger.warn(
+        `lightrules: registry reload failed ${stage}: ${err2?.message ?? err2}`
+      );
+    }
+  }
   async triggerLight(rule, notification) {
     let apiKey;
     try {
@@ -7302,6 +7583,74 @@ function summarizeContent(content) {
   return `${trimmed.slice(0, REASON_CONTENT_MAX)}\u2026`;
 }
 
+// src/light-rules/evaluation-scheduler.ts
+var DEFAULT_LIGHT_RULE_EVALUATION_DEBOUNCE_MS = 1e3;
+var LightRuleEvaluationScheduler = class {
+  evaluator;
+  logger;
+  debounceMs;
+  pending = [];
+  timer = null;
+  running = false;
+  flushRequestedWhileRunning = false;
+  constructor(deps) {
+    this.evaluator = deps.evaluator;
+    this.logger = deps.logger;
+    const debounceMs = deps.options?.debounceMs ?? DEFAULT_LIGHT_RULE_EVALUATION_DEBOUNCE_MS;
+    this.debounceMs = Number.isFinite(debounceMs) && debounceMs >= 0 ? debounceMs : DEFAULT_LIGHT_RULE_EVALUATION_DEBOUNCE_MS;
+  }
+  enqueue(notifications) {
+    if (notifications.length === 0) return;
+    this.pending.push(...notifications);
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.timer !== null) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.drain().catch((err2) => {
+        this.logger.warn(
+          `lightrules: scheduled evaluation failed: ${err2?.message ?? err2}`
+        );
+      });
+    }, this.debounceMs);
+    const maybeNodeTimer = this.timer;
+    maybeNodeTimer.unref?.();
+  }
+  async drain() {
+    if (this.running) {
+      this.flushRequestedWhileRunning = true;
+      return;
+    }
+    const batch = this.pending.splice(0);
+    if (batch.length === 0) return;
+    this.running = true;
+    try {
+      await this.evaluator.evaluate(batch);
+    } catch (err2) {
+      this.logger.warn(
+        `lightrules: evaluation failed (notifications=${batch.length}): ${err2?.message ?? err2}`
+      );
+    } finally {
+      this.running = false;
+      if (this.pending.length > 0) {
+        if (this.flushRequestedWhileRunning) {
+          this.flushRequestedWhileRunning = false;
+          void this.drain().catch((err2) => {
+            this.logger.warn(
+              `lightrules: queued evaluation failed: ${err2?.message ?? err2}`
+            );
+          });
+        } else {
+          this.scheduleFlush();
+        }
+      } else {
+        this.flushRequestedWhileRunning = false;
+      }
+    }
+  }
+};
+
 // src/light-rules/pi-invoker.ts
 var import_agent_runtime = require("openclaw/plugin-sdk/agent-runtime");
 var DEFAULT_PROVIDER = "anthropic";
@@ -7325,7 +7674,16 @@ var PiAiInvoker = class {
    */
   async matchNotifications(notifications, rules) {
     if (notifications.length === 0 || rules.length === 0) return [];
-    const { label, prepared } = await this.prepareCompletionModel();
+    let label;
+    let prepared;
+    try {
+      ({ label, prepared } = await this.prepareCompletionModel());
+    } catch (err2) {
+      this.logger.warn(
+        `PiAiInvoker: prepare failed: ${err2?.message ?? String(err2)}`
+      );
+      return null;
+    }
     if ("error" in prepared) {
       this.logger.warn(
         `PiAiInvoker: prepare ${label} failed: ${prepared.error}`
@@ -11203,6 +11561,12 @@ var RecordingStorage = class {
           if (typeof entry.lastError === "string" && entry.lastError.trim()) {
             compacted.lastError = entry.lastError.trim();
           }
+          if (compacted.status === "transcribing") {
+            compacted.status = "transcribe_failed";
+            compacted.lastError = compacted.lastError ?? "\u8F6C\u5199\u4EFB\u52A1\u5DF2\u4E2D\u65AD\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u8F6C\u5199";
+            compacted.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            needsRewrite = true;
+          }
           return compacted;
         });
         const hadLargeFields = raw.recordings.some(
@@ -11545,20 +11909,27 @@ async function triggerTranscription(recordingId, storage, asrConfig, logger, opt
   storage.setLastError(recordingId, void 0);
   emitRecordingStatus(recordingId, storage, logger, options.notifyStatus);
   const audioFilePath = storage.getAudioFilePath(recordingId);
-  const result = await runTranscriptionWorkflow({
-    audioFilePath,
-    audioOssUrl: entry.metadata.oss_audio_url,
-    config: asrConfig,
-    markers: entry.metadata.markers ?? [],
-    recordingName: entry.metadata.name,
-    durationSec: entry.metadata.duration_sec,
-    createdAt: entry.metadata.created_at,
-    transcriptDataDir: storage.getTranscriptDataDir(),
-    transcriptsDir: storage.getTranscriptsDir(),
-    summariesDir: storage.getSummariesDir(),
-    recordingId,
-    logger
-  });
+  let result;
+  try {
+    result = await runTranscriptionWorkflow({
+      audioFilePath,
+      audioOssUrl: entry.metadata.oss_audio_url,
+      config: asrConfig,
+      markers: entry.metadata.markers ?? [],
+      recordingName: entry.metadata.name,
+      durationSec: entry.metadata.duration_sec,
+      createdAt: entry.metadata.created_at,
+      transcriptDataDir: storage.getTranscriptDataDir(),
+      transcriptsDir: storage.getTranscriptsDir(),
+      summariesDir: storage.getSummariesDir(),
+      recordingId,
+      logger
+    });
+  } catch (err2) {
+    const error = `\u8F6C\u5199\u4EFB\u52A1\u5F02\u5E38: ${err2?.message ?? err2}`;
+    logger.error(`[asr-trigger] ${error}: ${recordingId}`);
+    result = { ok: false, error };
+  }
   if (result.ok && result.transcriptFilename) {
     if (result.transcriptDataFilename) {
       storage.setTranscriptDataFile(recordingId, result.transcriptDataFilename);
@@ -11593,17 +11964,18 @@ async function triggerTranscription(recordingId, storage, asrConfig, logger, opt
       });
     }
   } else {
+    const error = result.error ?? "ASR \u8F6C\u5199\u5931\u8D25";
     storage.updateStatus(recordingId, "transcribe_failed");
-    storage.setLastError(recordingId, result.error);
+    storage.setLastError(recordingId, error);
     emitRecordingStatus(
       recordingId,
       storage,
       logger,
       options.notifyStatus,
-      result.error
+      error
     );
     logger.error(
-      `[asr-trigger] \u8F6C\u5199\u5931\u8D25: ${recordingId}, error=${result.error}`
+      `[asr-trigger] \u8F6C\u5199\u5931\u8D25: ${recordingId}, error=${error}`
     );
   }
 }
@@ -14077,6 +14449,10 @@ var index_default = {
       registry: lightRuleRegistry,
       invoker: lightRuleInvoker
     });
+    const lightRuleEvaluationScheduler = new LightRuleEvaluationScheduler({
+      evaluator: inlineLightRuleEvaluator,
+      logger
+    });
     registerStorageLifecycle({
       api,
       config,
@@ -14105,8 +14481,8 @@ var index_default = {
       filterNotifications,
       registerGatewayMethod: registerGatewayMethodWithBroadcastCapture,
       tunnelService,
-      onAfterIngest: (inserted) => {
-        void inlineLightRuleEvaluator.evaluate(inserted);
+      onAfterIngest(inserted) {
+        lightRuleEvaluationScheduler.enqueue(inserted);
       }
     });
     registerLightControlTool(api, logger);