@yoooclaw/phone-notifications 1.12.3 → 1.12.4

package/dist/index.cjs

@@ -1719,7 +1719,7 @@ var require_websocket = __commonJS((exports2, module2) => {
   var EventEmitter = require("events");
   var https = require("https");
   var http = require("http");
-  var net = require("net");
+  var net2 = require("net");
   var tls = require("tls");
   var { randomBytes: randomBytes2, createHash: createHash2 } = require("crypto");
   var { Duplex, Readable: Readable2 } = require("stream");
@@ -2339,12 +2339,12 @@ var require_websocket = __commonJS((exports2, module2) => {
   }
   function netConnect(options) {
     options.path = options.socketPath;
-    return net.connect(options);
+    return net2.connect(options);
   }
   function tlsConnect(options) {
     options.path = undefined;
     if (!options.servername && options.servername !== "") {
-      options.servername = net.isIP(options.host) ? "" : options.host;
+      options.servername = net2.isIP(options.host) ? "" : options.host;
     }
     return tls.connect(options);
   }
@@ -2959,7 +2959,7 @@ var import_node_path = require("node:path");
 var import_node_fs = require("node:fs");
 function readBuildInjectedVersion() {
   if (false) {}
-  const version = "1.12.3".trim();
+  const version = "1.12.4".trim();
   return version || undefined;
 }
 function readPluginVersionFromPackageJson() {
@@ -3086,7 +3086,6 @@ class PluginFileLogger {
     this.lastPruneDateKey = formatDate(now);
   }
   info(msg) {
-    this.prepareLogDate(new Date);
     const safeMsg = this.formatLogMessage(msg);
     this.upstream.info(safeMsg);
     this.append("INFO", safeMsg);
@@ -3137,20 +3136,48 @@ class PluginFileLogger {
     } catch {}
   }
 }
+function quotedObjectFieldRegex(keys) {
+  return new RegExp(`(["'])(${buildKeyPattern(keys)})\\1\\s*:\\s*(?:"(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|[^,}\\]]+)`, "gi");
+}
+function keyValueFieldRegex(keys) {
+  return new RegExp(`(?<![?&])\\b(${buildKeyPattern(keys)})\\s*=\\s*(?:Bearer\\s+[^,\\s)]+|"(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|[^,\\s)]+)`, "gi");
+}
+function structuredKeyValueFieldRegex(keys) {
+  return new RegExp(`\\b(${buildKeyPattern(keys)})\\s*=\\s*([\\[{])`, "gi");
+}
+function colonTextFieldRegex(keys) {
+  return new RegExp(`\\b(${buildKeyPattern(keys)})\\s*:\\s*([^,\\n]+)`, "gi");
+}
+function buildRules(build) {
+  return [
+    { regex: build(SECRET_KEYS), placeholder: REDACTED_SECRET },
+    { regex: build(USER_TEXT_KEYS), placeholder: REDACTED },
+    { regex: build(USER_URL_KEYS), placeholder: REDACTED_URL }
+  ];
+}
+var QUOTED_OBJECT_FIELD_RULES = buildRules(quotedObjectFieldRegex);
+var KEY_VALUE_FIELD_RULES = buildRules(keyValueFieldRegex);
+var STRUCTURED_KEY_VALUE_FIELD_RULES = buildRules(structuredKeyValueFieldRegex);
+var COLON_TEXT_FIELD_RULES = [
+  { regex: colonTextFieldRegex(SECRET_KEYS), placeholder: REDACTED_SECRET },
+  { regex: colonTextFieldRegex(USER_TEXT_KEYS), placeholder: REDACTED }
+];
+var SENSITIVE_QUERY_PARAM_REGEX = new RegExp(`([?&](${SENSITIVE_QUERY_KEYS.map(escapeRegExp).join("|")})=)([^&#\\s]+)`, "gi");
 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);
+  for (const rule of QUOTED_OBJECT_FIELD_RULES) {
+    redacted = redactQuotedObjectFields(redacted, rule);
+  }
+  for (const rule of STRUCTURED_KEY_VALUE_FIELD_RULES) {
+    redacted = redactStructuredKeyValueFields(redacted, rule);
+  }
+  for (const rule of KEY_VALUE_FIELD_RULES) {
+    redacted = redactKeyValueFields(redacted, rule);
+  }
+  for (const rule of COLON_TEXT_FIELD_RULES) {
+    redacted = redactColonTextFields(redacted, rule);
+  }
+  redacted = redactQueryParams(redacted);
   redacted = redactBearerTokens(redacted);
   redacted = redactLikelyUserUrls(redacted);
   redacted = redactEmails(redacted);
@@ -3159,17 +3186,14 @@ function redactLogMessage(msg) {
   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 redactQuotedObjectFields(input, { regex, placeholder }) {
+  return input.replace(regex, (_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 redactKeyValueFields(input, { regex, placeholder }) {
+  return input.replace(regex, (_match, key) => `${key}=${placeholder}`);
 }
-function redactStructuredKeyValueFields(input, keys, placeholder) {
-  const keyPattern = buildKeyPattern(keys);
-  const regex = new RegExp(`\\b(${keyPattern})\\s*=\\s*([\\[{])`, "gi");
+function redactStructuredKeyValueFields(input, { regex, placeholder }) {
+  regex.lastIndex = 0;
   let result = "";
   let lastIndex = 0;
   let match;
@@ -3224,13 +3248,11 @@ function findStructuredValueEnd(input, start) {
   }
   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 redactColonTextFields(input, { regex, placeholder }) {
+  return input.replace(regex, (_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 redactQueryParams(input) {
+  return input.replace(SENSITIVE_QUERY_PARAM_REGEX, (_match, prefix) => `${prefix}${encodeURIComponent(REDACTED)}`);
 }
 function redactBearerTokens(input) {
   return input.replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, `$1${REDACTED_SECRET}`);
@@ -4036,9 +4058,28 @@ async function runNotificationSummary(params) {
 }
 
 // src/notification/storage.ts
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var import_node_crypto = require("node:crypto");
+var import_node_path4 = require("node:path");
+
+// src/fs-atomic.ts
+var import_node_fs4 = require("node:fs");
 var import_node_path3 = require("node:path");
+function writeFileAtomic(path, data) {
+  import_node_fs4.mkdirSync(import_node_path3.dirname(path), { recursive: true });
+  const tmpPath = `${path}.tmp.${process.pid}.${Date.now()}`;
+  import_node_fs4.writeFileSync(tmpPath, data, "utf-8");
+  import_node_fs4.renameSync(tmpPath, path);
+}
+function quarantineCorruptFile(path) {
+  const quarantinePath = `${path}.corrupt.${Date.now()}`;
+  try {
+    import_node_fs4.renameSync(path, quarantinePath);
+    return quarantinePath;
+  } catch {
+    return null;
+  }
+}
 
 // src/notification/feishu-normalize.ts
 function normalizeOptionalText(value) {
@@ -4180,7 +4221,7 @@ var NOTIFICATION_DIR_NAME = "notifications";
 var ID_INDEX_DIR_NAME = ".ids";
 var CONTENT_KEY_INDEX_DIR_NAME = ".keys";
 function getStateFallbackNotificationDir(stateDir) {
-  return import_node_path3.join(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
+  return import_node_path4.join(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
 }
 function computeLagMs(timestamp) {
   if (!timestamp)
@@ -4206,8 +4247,8 @@ function buildFallbackContent(n) {
 }
 function ensureWritableDirectory(dir) {
   try {
-    import_node_fs4.mkdirSync(dir, { recursive: true });
-    import_node_fs4.accessSync(dir, import_node_fs4.constants.R_OK | import_node_fs4.constants.W_OK);
+    import_node_fs5.mkdirSync(dir, { recursive: true });
+    import_node_fs5.accessSync(dir, import_node_fs5.constants.R_OK | import_node_fs5.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -4220,7 +4261,7 @@ function resolveNotificationStorageDir(ctx, logger) {
     return stateNotifDir;
   }
   if (ctx.workspaceDir) {
-    const workspaceDir = import_node_path3.join(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
+    const workspaceDir = import_node_path4.join(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
     if (ensureWritableDirectory(workspaceDir)) {
       logger.warn(`stateDir 不可用，通知已回退到 workspace 路径: ${workspaceDir}`);
       return workspaceDir;
@@ -4228,6 +4269,7 @@ function resolveNotificationStorageDir(ctx, logger) {
   }
   throw new Error(`通知存储目录不可用: ${stateNotifDir}`);
 }
+var DAY_ENTRIES_CACHE_MAX = 4;
 
 class NotificationStorage {
   logger;
@@ -4236,23 +4278,24 @@ class NotificationStorage {
   contentKeyIndexDir;
   idCache = new Map;
   contentKeyCache = new Map;
+  dayEntriesCache = new Map;
   dateWriteChains = new Map;
   resolveDisplayName;
   constructor(dir, logger, resolveDisplayName) {
     this.logger = logger;
     this.dir = dir;
-    this.idIndexDir = import_node_path3.join(dir, ID_INDEX_DIR_NAME);
-    this.contentKeyIndexDir = import_node_path3.join(dir, CONTENT_KEY_INDEX_DIR_NAME);
+    this.idIndexDir = import_node_path4.join(dir, ID_INDEX_DIR_NAME);
+    this.contentKeyIndexDir = import_node_path4.join(dir, CONTENT_KEY_INDEX_DIR_NAME);
     this.resolveDisplayName = resolveDisplayName;
   }
   getStorageDir() {
     return this.dir;
   }
   async init() {
-    import_node_fs4.mkdirSync(this.dir, { recursive: true });
-    import_node_fs4.mkdirSync(this.idIndexDir, { recursive: true });
-    import_node_fs4.rmSync(this.contentKeyIndexDir, { recursive: true, force: true });
-    import_node_fs4.mkdirSync(this.contentKeyIndexDir, { recursive: true });
+    import_node_fs5.mkdirSync(this.dir, { recursive: true });
+    import_node_fs5.mkdirSync(this.idIndexDir, { recursive: true });
+    import_node_fs5.rmSync(this.contentKeyIndexDir, { recursive: true, force: true });
+    import_node_fs5.mkdirSync(this.contentKeyIndexDir, { recursive: true });
   }
   async ingest(items, ingestId) {
     const result = {
@@ -4264,8 +4307,7 @@ class NotificationStorage {
       inserted: []
     };
     const traceTag = ingestId ? `[${ingestId}]` : "";
-    for (const n of items) {
-      const outcome = await this.writeNotification(n);
+    const recordOutcome = (n, outcome) => {
       const lagMs = computeLagMs(n.timestamp);
       const lagPart = lagMs === null ? "lag=?" : `lag=${lagMs}ms`;
       this.logger.info(`ingest${traceTag}: app=${n.app ?? "Unknown"} id=${n.id ?? "-"} ts=${n.timestamp} ${lagPart} outcome=${outcome.kind}`);
@@ -4284,41 +4326,108 @@ class NotificationStorage {
           result.invalid += 1;
           break;
       }
+    };
+    const groups = new Map;
+    for (const n of items) {
+      const ts = new Date(n.timestamp);
+      if (Number.isNaN(ts.getTime())) {
+        this.logger.warn(`忽略非法 timestamp 的通知: ${n.id}`);
+        recordOutcome(n, { kind: "invalid" });
+        continue;
+      }
+      const dateKey = this.formatDate(ts);
+      const group = groups.get(dateKey);
+      if (group) {
+        group.push(n);
+      } else {
+        groups.set(dateKey, [n]);
+      }
+    }
+    for (const [dateKey, group] of groups) {
+      await this.writeDayNotifications(dateKey, group, recordOutcome);
     }
     return result;
   }
-  async writeNotification(n) {
-    const ts = new Date(n.timestamp);
-    if (Number.isNaN(ts.getTime())) {
-      this.logger.warn(`忽略非法 timestamp 的通知: ${n.id}`);
-      return { kind: "invalid" };
-    }
-    const dateKey = this.formatDate(ts);
-    const filePath = import_node_path3.join(this.dir, `${dateKey}.json`);
-    const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
-    const entry = this.buildStoredNotification(n);
-    return this.withDateWriteLock(dateKey, async () => {
-      if (normalizedId && this.hasNotificationId(dateKey, entry.clientLabel ?? "legacy", normalizedId)) {
-        return { kind: "dedupedById" };
-      }
-      if (this.hasNotificationContentKey(dateKey, filePath, entry)) {
-        return { kind: "dedupedByContent" };
-      }
-      const appDisplayName = this.resolveDisplayName ? await this.resolveDisplayName(entry.appName) : entry.appName;
-      const storedEntry = {
-        ...entry,
-        appDisplayName
-      };
-      const arr = this.readStoredNotifications(filePath);
-      arr.push(storedEntry);
-      import_node_fs4.writeFileSync(filePath, JSON.stringify(arr, null, 2), "utf-8");
-      if (normalizedId) {
-        this.recordNotificationId(dateKey, storedEntry.clientLabel ?? "legacy", normalizedId);
-      }
-      this.recordNotificationContentKey(dateKey, filePath, storedEntry);
-      return { kind: "ingested", entry: storedEntry };
+  async writeDayNotifications(dateKey, group, recordOutcome) {
+    const filePath = import_node_path4.join(this.dir, `${dateKey}.json`);
+    await this.withDateWriteLock(dateKey, async () => {
+      const entries = this.getDayEntries(dateKey, filePath);
+      const ids = this.getIdSet(dateKey);
+      const contentKeys = this.getContentKeySet(dateKey, filePath);
+      const pendingIdKeys = [];
+      const pendingContentKeys = [];
+      let insertedCount = 0;
+      const outcomes = [];
+      for (const n of group) {
+        const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
+        const entry = this.buildStoredNotification(n);
+        const clientLabel = entry.clientLabel ?? "legacy";
+        if (normalizedId && this.hasNotificationId(dateKey, clientLabel, normalizedId)) {
+          outcomes.push({ n, outcome: { kind: "dedupedById" } });
+          continue;
+        }
+        if (this.hasNotificationContentKey(dateKey, filePath, entry)) {
+          outcomes.push({ n, outcome: { kind: "dedupedByContent" } });
+          continue;
+        }
+        let appDisplayName = entry.appName;
+        if (this.resolveDisplayName) {
+          try {
+            appDisplayName = await this.resolveDisplayName(entry.appName);
+          } catch {
+            appDisplayName = entry.appName;
+          }
+        }
+        const storedEntry = { ...entry, appDisplayName };
+        entries.push(storedEntry);
+        insertedCount += 1;
+        if (normalizedId) {
+          const idKey = this.buildNotificationIdKey(clientLabel, normalizedId);
+          if (!ids.has(idKey)) {
+            ids.add(idKey);
+            pendingIdKeys.push(idKey);
+          }
+        }
+        const contentKey = this.buildNotificationContentKey(storedEntry);
+        if (!contentKeys.has(contentKey)) {
+          contentKeys.add(contentKey);
+          pendingContentKeys.push(contentKey);
+        }
+        outcomes.push({ n, outcome: { kind: "ingested", entry: storedEntry } });
+      }
+      if (insertedCount > 0) {
+        writeFileAtomic(filePath, JSON.stringify(entries, null, 2));
+        if (pendingIdKeys.length > 0) {
+          import_node_fs5.appendFileSync(this.getIdIndexPath(dateKey), `${pendingIdKeys.join(`
+`)}
+`, "utf-8");
+        }
+        if (pendingContentKeys.length > 0) {
+          import_node_fs5.appendFileSync(this.getContentKeyIndexPath(dateKey), `${pendingContentKeys.join(`
+`)}
+`, "utf-8");
+        }
+      }
+      for (const { n, outcome } of outcomes) {
+        recordOutcome(n, outcome);
+      }
     });
   }
+  getDayEntries(dateKey, filePath) {
+    const cached = this.dayEntriesCache.get(dateKey);
+    if (cached) {
+      return cached;
+    }
+    const entries = this.readStoredNotifications(filePath);
+    this.dayEntriesCache.set(dateKey, entries);
+    while (this.dayEntriesCache.size > DAY_ENTRIES_CACHE_MAX) {
+      const oldest = this.dayEntriesCache.keys().next().value;
+      if (oldest === undefined)
+        break;
+      this.dayEntriesCache.delete(oldest);
+    }
+    return entries;
+  }
   buildStoredNotification(n) {
     const appName = typeof n.app === "string" && n.app ? n.app : "Unknown";
     const clientLabel = currentClientLabel("default");
@@ -4348,7 +4457,7 @@ class NotificationStorage {
     return `${year}-${month}-${day}`;
   }
   getIdIndexPath(dateKey) {
-    return import_node_path3.join(this.idIndexDir, `${dateKey}.ids`);
+    return import_node_path4.join(this.idIndexDir, `${dateKey}.ids`);
   }
   getIdSet(dateKey) {
     const cached = this.idCache.get(dateKey);
@@ -4357,8 +4466,8 @@ class NotificationStorage {
     }
     const idPath = this.getIdIndexPath(dateKey);
     const ids = new Set;
-    if (import_node_fs4.existsSync(idPath)) {
-      const lines = import_node_fs4.readFileSync(idPath, "utf-8").split(/\r?\n/);
+    if (import_node_fs5.existsSync(idPath)) {
+      const lines = import_node_fs5.readFileSync(idPath, "utf-8").split(/\r?\n/);
       for (const line of lines) {
         const id = line.trim();
         if (id) {
@@ -4383,7 +4492,7 @@ class NotificationStorage {
     return ids.has(this.buildNotificationIdKey(clientLabel, id)) || this.usesLegacyIdKey(clientLabel) && ids.has(id);
   }
   getContentKeyIndexPath(dateKey) {
-    return import_node_path3.join(this.contentKeyIndexDir, `${dateKey}.keys`);
+    return import_node_path4.join(this.contentKeyIndexDir, `${dateKey}.keys`);
   }
   getContentKeySet(dateKey, filePath) {
     const cached = this.contentKeyCache.get(dateKey);
@@ -4392,17 +4501,15 @@ class NotificationStorage {
     }
     const keyPath = this.getContentKeyIndexPath(dateKey);
     const keys = new Set;
-    if (import_node_fs4.existsSync(filePath)) {
-      for (const item of this.readStoredNotifications(filePath)) {
-        keys.add(this.buildNotificationContentKey(item));
-      }
+    for (const item of this.getDayEntries(dateKey, filePath)) {
+      keys.add(this.buildNotificationContentKey(item));
     }
     if (keys.size > 0) {
-      import_node_fs4.writeFileSync(keyPath, `${Array.from(keys).join(`
+      writeFileAtomic(keyPath, `${Array.from(keys).join(`
 `)}
-`, "utf-8");
-    } else if (import_node_fs4.existsSync(keyPath)) {
-      import_node_fs4.rmSync(keyPath, { force: true });
+`);
+    } else if (import_node_fs5.existsSync(keyPath)) {
+      import_node_fs5.rmSync(keyPath, { force: true });
     }
     this.contentKeyCache.set(dateKey, keys);
     return keys;
@@ -4411,26 +4518,6 @@ class NotificationStorage {
     const keys = this.getContentKeySet(dateKey, filePath);
     return this.contentKeyLabels(entry.clientLabel).some((clientLabel) => keys.has(this.buildNotificationContentKey({ ...entry, clientLabel })));
   }
-  recordNotificationId(dateKey, clientLabel, id) {
-    const ids = this.getIdSet(dateKey);
-    const key = this.buildNotificationIdKey(clientLabel, id);
-    if (ids.has(key)) {
-      return;
-    }
-    import_node_fs4.appendFileSync(this.getIdIndexPath(dateKey), `${key}
-`, "utf-8");
-    ids.add(key);
-  }
-  recordNotificationContentKey(dateKey, filePath, entry) {
-    const keys = this.getContentKeySet(dateKey, filePath);
-    const key = this.buildNotificationContentKey(entry);
-    if (keys.has(key)) {
-      return;
-    }
-    import_node_fs4.appendFileSync(this.getContentKeyIndexPath(dateKey), `${key}
-`, "utf-8");
-    keys.add(key);
-  }
   buildNotificationContentKey(entry) {
     return import_node_crypto.createHash("sha256").update(entry.clientLabel ?? "legacy").update("\x1F").update(entry.appName).update("\x1F").update(entry.title).update("\x1F").update(entry.content).update("\x1F").update(entry.timestamp).digest("hex");
   }
@@ -4439,13 +4526,15 @@ class NotificationStorage {
     return label === "default" ? ["default", "legacy"] : [label];
   }
   readStoredNotifications(filePath) {
-    if (!import_node_fs4.existsSync(filePath)) {
+    if (!import_node_fs5.existsSync(filePath)) {
       return [];
     }
     try {
-      const parsed = JSON.parse(import_node_fs4.readFileSync(filePath, "utf-8"));
+      const parsed = JSON.parse(import_node_fs5.readFileSync(filePath, "utf-8"));
       return Array.isArray(parsed) ? parsed : [];
     } catch {
+      const quarantinePath = quarantineCorruptFile(filePath);
+      this.logger.warn(quarantinePath ? `通知文件损坏，已隔离到 ${quarantinePath}，当日通知从空文件重新累积` : `通知文件损坏且隔离失败，后续写入可能覆盖原文件: ${filePath}`);
       return [];
     }
   }
@@ -4470,6 +4559,7 @@ class NotificationStorage {
   async close() {
     this.idCache.clear();
     this.contentKeyCache.clear();
+    this.dayEntriesCache.clear();
     this.dateWriteChains.clear();
   }
 }
@@ -4790,31 +4880,31 @@ var LIGHT_RULE_TOOL_NAME_LIST = [
 ];
 
 // src/light-rules/storage.ts
-var import_node_fs5 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path5 = require("node:path");
 function addUniquePath(paths, path) {
   if (!path)
     return;
-  const normalized = import_node_path4.resolve(path);
+  const normalized = import_node_path5.resolve(path);
   if (!paths.includes(normalized)) {
     paths.push(normalized);
   }
 }
 function inferSiblingWorkspaceDir(stateDir) {
-  const stateDirName = import_node_path4.basename(stateDir);
+  const stateDirName = import_node_path5.basename(stateDir);
   if (!stateDirName.startsWith("."))
     return;
-  const siblingStateDir = import_node_path4.join(import_node_path4.dirname(stateDir), stateDirName.slice(1));
-  const siblingWorkspaceDir = import_node_path4.join(siblingStateDir, "workspace");
-  return import_node_fs5.existsSync(siblingWorkspaceDir) ? siblingWorkspaceDir : undefined;
+  const siblingStateDir = import_node_path5.join(import_node_path5.dirname(stateDir), stateDirName.slice(1));
+  const siblingWorkspaceDir = import_node_path5.join(siblingStateDir, "workspace");
+  return import_node_fs6.existsSync(siblingWorkspaceDir) ? siblingWorkspaceDir : undefined;
 }
 function resolveBaseDirs(ctx) {
   const dirs = [];
   addUniquePath(dirs, ctx.workspaceDir);
   if (ctx.stateDir) {
     addUniquePath(dirs, inferSiblingWorkspaceDir(ctx.stateDir));
-    const inferredWorkspaceDir = import_node_path4.join(ctx.stateDir, "workspace");
-    if (import_node_fs5.existsSync(inferredWorkspaceDir)) {
+    const inferredWorkspaceDir = import_node_path5.join(ctx.stateDir, "workspace");
+    if (import_node_fs6.existsSync(inferredWorkspaceDir)) {
       addUniquePath(dirs, inferredWorkspaceDir);
     }
     addUniquePath(dirs, ctx.stateDir);
@@ -4828,10 +4918,10 @@ function resolveWriteBaseDir(ctx) {
   return resolveBaseDirs(ctx)[0];
 }
 function tasksDirs(ctx) {
-  return resolveBaseDirs(ctx).map((baseDir) => import_node_path4.join(baseDir, "tasks"));
+  return resolveBaseDirs(ctx).map((baseDir) => import_node_path5.join(baseDir, "tasks"));
 }
 function writeTasksDir(ctx) {
-  return import_node_path4.join(resolveWriteBaseDir(ctx), "tasks");
+  return import_node_path5.join(resolveWriteBaseDir(ctx), "tasks");
 }
 function normalizeLightRuleLookupName(name) {
   return name.trim().replace(/\.json$/i, "");
@@ -4842,7 +4932,7 @@ function resolveLightRuleTask(ctx, name) {
     return null;
   const dirs = tasksDirs(ctx);
   for (const dir of dirs) {
-    const directTaskDir = import_node_path4.join(dir, normalizedName);
+    const directTaskDir = import_node_path5.join(dir, normalizedName);
     const directMeta = readMeta(directTaskDir);
     if (directMeta) {
       return {
@@ -4852,12 +4942,12 @@ function resolveLightRuleTask(ctx, name) {
     }
   }
   for (const dir of dirs) {
-    if (!import_node_fs5.existsSync(dir))
+    if (!import_node_fs6.existsSync(dir))
       continue;
-    for (const entry of import_node_fs5.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs6.readdirSync(dir, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const taskDir = import_node_path4.join(dir, entry.name);
+      const taskDir = import_node_path5.join(dir, entry.name);
       const meta = readMeta(taskDir);
       if (meta?.name === normalizedName) {
         return {
@@ -4876,21 +4966,21 @@ function readOptionalString(value) {
   return trimmed || undefined;
 }
 function readMeta(taskDir) {
-  const metaPath = import_node_path4.join(taskDir, "meta.json");
-  if (!import_node_fs5.existsSync(metaPath))
+  const metaPath = import_node_path5.join(taskDir, "meta.json");
+  if (!import_node_fs6.existsSync(metaPath))
     return null;
   try {
-    const raw = JSON.parse(import_node_fs5.readFileSync(metaPath, "utf-8"));
+    const raw = JSON.parse(import_node_fs6.readFileSync(metaPath, "utf-8"));
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
       return null;
     if (raw.type !== "light-rule")
       return null;
     if (!Array.isArray(raw.segments))
       return null;
-    const name = readOptionalString(raw.name) ?? import_node_path4.basename(taskDir);
+    const name = readOptionalString(raw.name) ?? import_node_path5.basename(taskDir);
     const title = readOptionalString(raw.title) ?? name;
     const description = readOptionalString(raw.description) ?? name;
-    const createdAt = readOptionalString(raw.createdAt) ?? import_node_fs5.statSync(metaPath).birthtime.toISOString();
+    const createdAt = readOptionalString(raw.createdAt) ?? import_node_fs6.statSync(metaPath).birthtime.toISOString();
     const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
     const repeatTimes = normalizeRepeatTimes({
       repeat: raw.repeat,
@@ -4913,18 +5003,18 @@ function readMeta(taskDir) {
   }
 }
 function writeMeta(taskDir, meta) {
-  import_node_fs5.writeFileSync(import_node_path4.join(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  import_node_fs6.writeFileSync(import_node_path5.join(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function listLightRules(ctx) {
   const rules = [];
   const seenNames = new Set;
   for (const dir of tasksDirs(ctx)) {
-    if (!import_node_fs5.existsSync(dir))
+    if (!import_node_fs6.existsSync(dir))
       continue;
-    for (const entry of import_node_fs5.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs6.readdirSync(dir, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const meta = readMeta(import_node_path4.join(dir, entry.name));
+      const meta = readMeta(import_node_path5.join(dir, entry.name));
       if (!meta || seenNames.has(meta.name))
         continue;
       rules.push(meta);
@@ -4939,11 +5029,11 @@ function createLightRule(ctx, params) {
     throw new LightRuleError("ALREADY_EXISTS", `灯效规则 '${params.name}' 已存在`);
   }
   const dir = writeTasksDir(ctx);
-  const taskDir = import_node_path4.join(dir, params.name);
-  if (import_node_fs5.existsSync(taskDir)) {
+  const taskDir = import_node_path5.join(dir, params.name);
+  if (import_node_fs6.existsSync(taskDir)) {
     throw new LightRuleError("ALREADY_EXISTS", `灯效规则 '${params.name}' 已存在`);
   }
-  import_node_fs5.mkdirSync(taskDir, { recursive: true });
+  import_node_fs6.mkdirSync(taskDir, { recursive: true });
   const repeatTimes = normalizeRepeatTimes({
     repeat: params.repeat,
     repeat_times: params.repeat_times
@@ -4999,7 +5089,7 @@ function deleteLightRule(ctx, name) {
   if (!taskDir || !meta) {
     throw new LightRuleError("NOT_FOUND", `灯效规则 '${name}' 不存在`);
   }
-  import_node_fs5.rmSync(taskDir, { recursive: true, force: true });
+  import_node_fs6.rmSync(taskDir, { recursive: true, force: true });
   return { name: meta.name };
 }
 
@@ -5435,16 +5525,16 @@ function quantizeWindow(value) {
 }
 
 // src/auth/credentials.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path9 = require("node:path");
 
 // src/profile/detect.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path7 = require("node:path");
 
 // src/profile/paths.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path6 = require("node:path");
 var DEFAULT_JVSCLAW_STATE_DIR = "/home/admin/.openclaw";
 var PHONE_NOTIFICATIONS_STATE_DIR_ENV = "PHONE_NOTIFICATIONS_STATE_DIR";
 var PHONE_NOTIFICATIONS_CONFIG_PATH_ENV = "PHONE_NOTIFICATIONS_CONFIG_PATH";
@@ -5466,24 +5556,24 @@ function expandUserPath(value) {
     return homeDir();
   }
   if (value.startsWith("~/")) {
-    return import_node_path5.join(homeDir(), value.slice(2));
+    return import_node_path6.join(homeDir(), value.slice(2));
   }
   return value;
 }
 function candidateMetaPaths() {
   const home = homeDir();
   return [
-    import_node_path5.join(home, ".qclaw", "qclaw.json"),
-    import_node_path5.join(home, ".qclow", "qclaw.json")
+    import_node_path6.join(home, ".qclaw", "qclaw.json"),
+    import_node_path6.join(home, ".qclow", "qclaw.json")
   ];
 }
 function loadQClawMeta() {
   for (const metaPath of candidateMetaPaths()) {
-    if (!import_node_fs6.existsSync(metaPath)) {
+    if (!import_node_fs7.existsSync(metaPath)) {
       continue;
     }
     try {
-      const parsed = JSON.parse(import_node_fs6.readFileSync(metaPath, "utf-8"));
+      const parsed = JSON.parse(import_node_fs7.readFileSync(metaPath, "utf-8"));
       return {
         stateDir: expandUserPath(trimToUndefined(parsed?.stateDir)),
         configPath: expandUserPath(trimToUndefined(parsed?.configPath))
@@ -5505,12 +5595,12 @@ function resolveConfigPathFromEnv() {
   return expandUserPath(trimToUndefined(process.env.JVSCLAW_CONFIG_PATH) ?? trimToUndefined(process.env.OPENCLAW_CONFIG_PATH) ?? trimToUndefined(process.env.QCLAW_CONFIG_PATH));
 }
 function hasOpenClawMarkers() {
-  const baseDir = import_node_path5.join(homeDir(), ".openclaw");
+  const baseDir = import_node_path6.join(homeDir(), ".openclaw");
   return [
-    import_node_path5.join(baseDir, "openclaw.json"),
-    import_node_path5.join(baseDir, "credentials.json"),
-    import_node_path5.join(baseDir, "extensions")
-  ].some((candidate) => import_node_fs6.existsSync(candidate));
+    import_node_path6.join(baseDir, "openclaw.json"),
+    import_node_path6.join(baseDir, "credentials.json"),
+    import_node_path6.join(baseDir, "extensions")
+  ].some((candidate) => import_node_fs7.existsSync(candidate));
 }
 function resolveHostStateDir(stateDir) {
   const explicitDir = expandUserPath(trimToUndefined(stateDir));
@@ -5522,16 +5612,16 @@ function resolveHostStateDir(stateDir) {
     return envDir;
   }
   if (hasOpenClawMarkers()) {
-    return import_node_path5.join(homeDir(), ".openclaw");
+    return import_node_path6.join(homeDir(), ".openclaw");
   }
   const meta = loadQClawMeta();
   if (meta?.stateDir) {
     return meta.stateDir;
   }
   if (meta?.configPath) {
-    return import_node_path5.dirname(meta.configPath);
+    return import_node_path6.dirname(meta.configPath);
   }
-  return import_node_path5.join(homeDir(), ".openclaw");
+  return import_node_path6.join(homeDir(), ".openclaw");
 }
 function resolveHostConfigPath(stateDir = resolveHostStateDir()) {
   const envConfigPath = resolveConfigPathFromEnv();
@@ -5542,7 +5632,7 @@ function resolveHostConfigPath(stateDir = resolveHostStateDir()) {
   if (meta?.configPath && (!meta.stateDir || !stateDir || meta.stateDir === stateDir)) {
     return meta.configPath;
   }
-  return import_node_path5.join(stateDir, "openclaw.json");
+  return import_node_path6.join(stateDir, "openclaw.json");
 }
 function resolvePersistedProfileStateDirs() {
   const dirs = [];
@@ -5597,7 +5687,7 @@ function readPersistedClawProfile() {
   for (const stateDir of resolvePersistedProfileStateDirs()) {
     let content;
     try {
-      content = import_node_fs7.readFileSync(import_node_path6.join(stateDir, ".env"), "utf-8");
+      content = import_node_fs8.readFileSync(import_node_path7.join(stateDir, ".env"), "utf-8");
     } catch {
       continue;
     }
@@ -5621,7 +5711,7 @@ function readPluginLinkSecret(configPath) {
     return;
   let config;
   try {
-    config = JSON.parse(import_node_fs7.readFileSync(configPath, "utf-8"));
+    config = JSON.parse(import_node_fs8.readFileSync(configPath, "utf-8"));
   } catch {
     return;
   }
@@ -5635,7 +5725,7 @@ function hasJvsclawLinkSecret() {
   const paths = [
     resolvePluginConfigPathOverrideFromEnv(),
     resolveConfigPathFromEnv(),
-    import_node_path6.join(DEFAULT_JVSCLAW_STATE_DIR, "openclaw.json")
+    import_node_path7.join(DEFAULT_JVSCLAW_STATE_DIR, "openclaw.json")
   ].filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
   return paths.some((configPath) => Boolean(readPluginLinkSecret(configPath)));
 }
@@ -5661,7 +5751,7 @@ function resolveClawKind() {
   return "openclaw";
 }
 // src/profile/runtime-paths.ts
-var import_node_path7 = require("node:path");
+var import_node_path8 = require("node:path");
 function resolveStateDir(hostStateDir) {
   const override = resolvePluginStateDirOverrideFromEnv();
   if (override) {
@@ -5678,12 +5768,12 @@ function resolveConfigPath(hostStateDir) {
     return override;
   }
   if (resolveClawKind() === "jvsclaw") {
-    return import_node_path7.join(resolveStateDir(hostStateDir), "openclaw.json");
+    return import_node_path8.join(resolveStateDir(hostStateDir), "openclaw.json");
   }
   return resolveHostConfigPath(resolveHostStateDir(hostStateDir));
 }
 function resolveStateFile(filename, hostStateDir) {
-  return import_node_path7.join(resolveStateDir(hostStateDir), filename);
+  return import_node_path8.join(resolveStateDir(hostStateDir), filename);
 }
 // src/auth/credentials.ts
 var API_KEY_ENV = "YOOOCLAW_API_KEY";
@@ -5692,18 +5782,18 @@ function credentialsPath() {
 }
 function readCredentials() {
   const path = credentialsPath();
-  if (!import_node_fs8.existsSync(path))
+  if (!import_node_fs9.existsSync(path))
     return {};
   try {
-    return JSON.parse(import_node_fs8.readFileSync(path, "utf-8"));
+    return JSON.parse(import_node_fs9.readFileSync(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCredentials(creds) {
   const path = credentialsPath();
-  import_node_fs8.mkdirSync(import_node_path8.dirname(path), { recursive: true, mode: 448 });
-  import_node_fs8.writeFileSync(path, JSON.stringify(creds, null, 2), {
+  import_node_fs9.mkdirSync(import_node_path9.dirname(path), { recursive: true, mode: 448 });
+  import_node_fs9.writeFileSync(path, JSON.stringify(creds, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
@@ -5751,8 +5841,8 @@ function requireApiKey() {
 }
 function watchCredentials(onChange) {
   const path = credentialsPath();
-  const dir = import_node_path8.dirname(path);
-  const filename = import_node_path8.basename(path);
+  const dir = import_node_path9.dirname(path);
+  const filename = import_node_path9.basename(path);
   let debounceTimer = null;
   const delayMs = 200;
   const listener = (_event, changedName) => {
@@ -5767,7 +5857,7 @@ function watchCredentials(onChange) {
   };
   let watcher = null;
   try {
-    watcher = import_node_fs8.watch(dir, { persistent: false }, listener);
+    watcher = import_node_fs9.watch(dir, { persistent: false }, listener);
   } catch {}
   return () => {
     if (debounceTimer)
@@ -5778,8 +5868,8 @@ function watchCredentials(onChange) {
 
 // src/env.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs9 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path10 = require("node:path");
 function parseEnvContent(content) {
   const entries = new Map;
   const tokens = content.split(/\r?\n/).flatMap((line) => line.split(/(?<![A-Z0-9_])(?=[A-Z_][A-Z0-9_]*=)/));
@@ -5799,8 +5889,8 @@ function parseEnvContent(content) {
 }
 function writeDotEnv(key, value) {
   const path = resolveStateFile(".env");
-  import_node_fs9.mkdirSync(import_node_path9.dirname(path), { recursive: true });
-  const existing = import_node_fs9.existsSync(path) ? import_node_fs9.readFileSync(path, "utf-8") : "";
+  import_node_fs10.mkdirSync(import_node_path10.dirname(path), { recursive: true });
+  const existing = import_node_fs10.existsSync(path) ? import_node_fs10.readFileSync(path, "utf-8") : "";
   const entries = parseEnvContent(existing);
   entries.set(key, value);
   const output2 = Array.from(entries, ([k, v]) => `${k}=${v}`).join(`
@@ -5808,11 +5898,11 @@ function writeDotEnv(key, value) {
 `;
   const tmpPath = `${path}.tmp.${process.pid}.${import_node_crypto2.randomBytes(4).toString("hex")}`;
   try {
-    import_node_fs9.writeFileSync(tmpPath, output2, { encoding: "utf-8", mode: 384 });
-    import_node_fs9.renameSync(tmpPath, path);
+    import_node_fs10.writeFileSync(tmpPath, output2, { encoding: "utf-8", mode: 384 });
+    import_node_fs10.renameSync(tmpPath, path);
   } catch (error) {
     try {
-      import_node_fs9.rmSync(tmpPath, { force: true });
+      import_node_fs10.rmSync(tmpPath, { force: true });
     } catch {}
     throw error;
   }
@@ -5823,6 +5913,7 @@ var DEFAULT_ENV_HOSTS = {
   production: "openclaw-service.yoooclaw.com"
 };
 var NOTIFICATION_INTELLIGENCE_LIGHT_RULES_PLUGIN_PATH = "/api/plugin/notification-intelligence/light-rules";
+var NOTIFICATION_INTELLIGENCE_LIGHT_EFFECTS_SEND_PLUGIN_PATH = "/api/plugin/notification-intelligence/light-effects/send";
 var NOTIFICATION_INTELLIGENCE_LIGHT_RULES_APP_PATH = "/api/notification-intelligence/light-rules";
 var NOTIFICATION_INTELLIGENCE_PLUGIN_BASE_PATH = "/api/plugin/notification-intelligence";
 var NOTIFICATION_INTELLIGENCE_APP_BASE_PATH = "/api/notification-intelligence";
@@ -5870,13 +5961,29 @@ function normalizeNotificationIntelligenceLightRulesPluginUrl(url) {
   }
   return trimmed;
 }
+function normalizeNotificationIntelligenceLightEffectsSendUrl(url) {
+  const trimmed = url.trim().replace(/\/+$/, "");
+  if (!trimmed)
+    return trimmed;
+  if (trimmed.endsWith(NOTIFICATION_INTELLIGENCE_LIGHT_EFFECTS_SEND_PLUGIN_PATH)) {
+    return trimmed;
+  }
+  const normalizedRulesUrl = normalizeNotificationIntelligenceLightRulesPluginUrl(trimmed);
+  if (normalizedRulesUrl.endsWith(NOTIFICATION_INTELLIGENCE_LIGHT_RULES_PLUGIN_PATH)) {
+    const origin = normalizedRulesUrl.slice(0, -NOTIFICATION_INTELLIGENCE_LIGHT_RULES_PLUGIN_PATH.length);
+    return `${origin}${NOTIFICATION_INTELLIGENCE_LIGHT_EFFECTS_SEND_PLUGIN_PATH}`;
+  }
+  return `${trimmed}/light-effects/send`;
+}
 function buildEnvUrls(host) {
   const https = `https://${host}`;
   const wss = `wss://${host}`;
   const lightRulesUrl = normalizeNotificationIntelligenceLightRulesPluginUrl(process.env.NOTIFICATION_INTELLIGENCE_LIGHT_RULES_URL || `${https}${NOTIFICATION_INTELLIGENCE_LIGHT_RULES_PLUGIN_PATH}`);
+  const lightEffectsSendUrl = normalizeNotificationIntelligenceLightEffectsSendUrl(process.env.NOTIFICATION_INTELLIGENCE_LIGHT_EFFECTS_SEND_URL || lightRulesUrl);
   return {
     lightApiUrl: `${https}/api/message/tob/sendMessage`,
     notificationIntelligenceLightRulesPluginUrl: lightRulesUrl,
+    notificationIntelligenceLightEffectsSendUrl: lightEffectsSendUrl,
     relayTunnelUrl: `${wss}/message/messages/ws/plugin`,
     appNameMapUrl: `${https}/api/application-config/app-package/config-all`,
     modelProxyLongRecordingSubmitTaskUrl: `${https}/api/model-proxy/long-recording/submit-task`,
@@ -5892,9 +5999,9 @@ var VALID_ENVS = new Set([
 ]);
 function readDotEnv() {
   const path = resolveStateFile(".env");
-  if (!import_node_fs9.existsSync(path))
+  if (!import_node_fs10.existsSync(path))
     return {};
-  return Object.fromEntries(parseEnvContent(import_node_fs9.readFileSync(path, "utf-8")));
+  return Object.fromEntries(parseEnvContent(import_node_fs10.readFileSync(path, "utf-8")));
 }
 function readPersistedEnvName() {
   const fromDotEnv = readDotEnv()["PHONE_NOTIFICATIONS_ENV"]?.trim();
@@ -6251,6 +6358,10 @@ function readTrimmedString(value) {
   const trimmed = value.trim();
   return trimmed || undefined;
 }
+var NOTIFICATION_RULE_SIGNAL = /(?:通知|消息|推送|来电|短信|邮件|微信|飞书|钉钉|notification|message|push|incoming\s+call|sms|e-?mail)/i;
+function isNotificationTriggeredRuleText(ruleText) {
+  return NOTIFICATION_RULE_SIGNAL.test(ruleText);
+}
 function hasAnyPlainUpdateField(params) {
   return [
     "title",
@@ -6366,6 +6477,9 @@ function registerLightRulesTools(api, service, logger) {
       const ruleText = readTrimmedString(params.ruleText);
       if (!ruleText)
         return err("INVALID_PARAMS", "ruleText is required");
+      if (!isNotificationTriggeredRuleText(ruleText)) {
+        return err("INVALID_RULE_SCOPE", "持久灯效规则必须包含通知、消息、来电等触发条件；一次性亮灯请调用 light_control");
+      }
       try {
         const result = await service.create({ ruleText });
         logger.info(`${LIGHT_RULE_TOOL_NAMES.create} tool: created ${result.id}/${result.name}`);
@@ -6483,6 +6597,409 @@ function registerLightRulesTools(api, service, logger) {
   });
 }
 
+// src/light/sender.ts
+var import_node_crypto3 = require("node:crypto");
+async function sendLightEffect(apiKey, segments, logger, repeatInput, reason, title, options) {
+  const resolvedTitle = resolveLightTitle(title, reason, segments);
+  let repeatTimes;
+  try {
+    repeatTimes = normalizeRepeatTimes(repeatInput);
+  } catch (error) {
+    return { ok: false, error: error?.message ?? String(error) };
+  }
+  const intelligence = await sendViaNotificationIntelligence(apiKey, segments, repeatTimes, resolvedTitle, reason, options?.bizUniqueId, logger);
+  if (!intelligence.fallback) {
+    return intelligence.result;
+  }
+  logger?.warn(`Light sender: notification-intelligence entry unavailable (${intelligence.fallbackReason}), falling back to legacy message-service`);
+  return sendViaLegacyMessageService(apiKey, segments, logger, repeatInput, reason, resolvedTitle);
+}
+async function sendViaNotificationIntelligence(apiKey, segments, repeatTimes, title, reason, bizUniqueId, logger) {
+  const url = getEnvUrls().notificationIntelligenceLightEffectsSendUrl;
+  const requestBody = {
+    title,
+    repeat_times: repeatTimes,
+    segments
+  };
+  if (reason?.trim())
+    requestBody.reason = reason;
+  const trimmedBizUniqueId = bizUniqueId?.trim();
+  if (trimmedBizUniqueId)
+    requestBody.bizUniqueId = trimmedBizUniqueId;
+  logger?.info(`Light sender: POST ${url}, bizUniqueId=${trimmedBizUniqueId ?? "(server-generated)"}, ` + `title=${title}, repeat_times=${repeatTimes}, segments_count=${segments.length}`);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Api-Key-Id": stripBearer(apiKey)
+      },
+      body: JSON.stringify(requestBody)
+    });
+  } catch (error) {
+    return {
+      fallback: true,
+      fallbackReason: `network error: ${error?.message ?? String(error)}`,
+      result: { ok: false, error: error?.message ?? String(error) }
+    };
+  }
+  const resBody = await res.text();
+  if (!res.ok) {
+    if (res.status === 404 || res.status === 405 || res.status === 401 && /jwt is missing/i.test(resBody)) {
+      return {
+        fallback: true,
+        fallbackReason: `HTTP ${res.status}`,
+        result: { ok: false, status: res.status, error: resBody }
+      };
+    }
+    logger?.warn(`Light sender: FAILED ${res.status}, url=${url}, resBody=${resBody.substring(0, 500)}`);
+    return {
+      fallback: false,
+      result: {
+        ok: false,
+        status: res.status,
+        error: resBody,
+        via: "notification-intelligence"
+      }
+    };
+  }
+  let parsed = null;
+  try {
+    parsed = resBody.trim() ? JSON.parse(resBody) : null;
+  } catch {}
+  if (!parsed || typeof parsed !== "object") {
+    logger?.warn(`Light sender: invalid JSON from ${url}, resBody=${resBody.substring(0, 200)}`);
+    return {
+      fallback: false,
+      result: {
+        ok: false,
+        error: "invalid JSON response",
+        via: "notification-intelligence"
+      }
+    };
+  }
+  const data = parsed.data ?? null;
+  if (parsed.code && parsed.code !== "000000") {
+    const message = parsed.msg ?? parsed.message ?? `remote code ${parsed.code}`;
+    logger?.warn(`Light sender: FAILED code=${parsed.code}, msg=${message}`);
+    return {
+      fallback: false,
+      result: {
+        ok: false,
+        error: String(message),
+        response: parsed,
+        via: "notification-intelligence"
+      }
+    };
+  }
+  if (data?.success === false) {
+    const message = data.message ?? "remote business request failed";
+    logger?.warn(`Light sender: FAILED business, message=${message}`);
+    return {
+      fallback: false,
+      result: {
+        ok: false,
+        error: String(message),
+        response: parsed,
+        via: "notification-intelligence"
+      }
+    };
+  }
+  const effectiveBizUniqueId = typeof data?.bizUniqueId === "string" && data.bizUniqueId.trim() || trimmedBizUniqueId;
+  logger?.info(`Light sender: OK bizUniqueId=${effectiveBizUniqueId ?? "-"}, resBody=${resBody.substring(0, 200)}`);
+  return {
+    fallback: false,
+    result: {
+      ok: true,
+      bizUniqueId: effectiveBizUniqueId || undefined,
+      response: parsed,
+      via: "notification-intelligence"
+    }
+  };
+}
+async function sendViaLegacyMessageService(apiKey, segments, logger, repeatInput, reason, resolvedTitle) {
+  const apiUrl = getEnvUrls().lightApiUrl;
+  const appKey = "phone-notifications";
+  const templateId = "1990771146010017800";
+  logger?.info(`Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "…" : "UNSET"}, templateId=${templateId ?? "UNSET"}, apiKey=${apiKey ? apiKey.substring(0, 20) + "…" : "EMPTY"}, title=${resolvedTitle}, reason=${reason ?? ""}, segments=${JSON.stringify(segments)}`);
+  if (!apiUrl || !appKey || !templateId) {
+    return {
+      ok: false,
+      error: "灯效 API 未配置，请确认构建时已封装 OPENCLAW_HOST_* / LIGHT_APP_KEY / LIGHT_TEMPLATE_ID"
+    };
+  }
+  let bizContent;
+  try {
+    bizContent = buildLightEffectApnsBody(segments, repeatInput, reason);
+  } catch (error) {
+    return { ok: false, error: error?.message ?? String(error) };
+  }
+  const bizUniqueId = import_node_crypto3.randomUUID();
+  const requestBody = {
+    appKey,
+    bizMap: { noticeType: "APP_NOTIFICATION_IMPORTANT", title: resolvedTitle, reason },
+    bizUniqueId,
+    paramsMap: { bizContent },
+    pushType: "SPECIFY_PUSH",
+    templateId
+  };
+  logger?.info(`Light sender: POST ${apiUrl}, bizUniqueId=${bizUniqueId}, body=${JSON.stringify(requestBody).substring(0, 500)}`);
+  const res = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Api-Key-Id": stripBearer(apiKey)
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const resBody = await res.text();
+  if (!res.ok) {
+    logger?.warn(`Light sender: FAILED ${res.status}, url=${apiUrl}, resBody=${resBody.substring(0, 500)}`);
+    return { ok: false, status: res.status, error: resBody, via: "message-service" };
+  }
+  logger?.info(`Light sender: OK bizUniqueId=${bizUniqueId}, resBody=${resBody.substring(0, 200)}`);
+  return {
+    ok: true,
+    bizUniqueId,
+    response: JSON.parse(resBody),
+    via: "message-service"
+  };
+}
+function stripBearer(apiKey) {
+  return apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
+}
+function resolveLightTitle(title, reason, segments) {
+  const trimmedTitle = title?.trim();
+  if (trimmedTitle)
+    return trimmedTitle;
+  const trimmedReason = reason?.trim();
+  if (trimmedReason)
+    return trimmedReason;
+  const modeDesc = segments.map((segment) => segment.mode).join("+");
+  return `Effect: ${modeDesc || "custom"}`;
+}
+
+// src/plugin/light-control.ts
+var lightControlParameters = {
+  type: "object",
+  required: ["segments", "reason"],
+  additionalProperties: false,
+  properties: {
+    segments: {
+      type: "array",
+      description: "灯效段序列，1–12 段，按顺序播放",
+      minItems: 1,
+      maxItems: MAX_LIGHT_SEGMENTS,
+      items: {
+        type: "object",
+        required: ["mode", "duration_s"],
+        additionalProperties: false,
+        properties: {
+          mode: {
+            type: "string",
+            enum: ["wave", "breath", "strobe", "steady", "color_flow", "pixel_frame"],
+            description: "灯效模式：wave 波浪（单色跑马，前景色+可选底色）/ breath 呼吸 / strobe 频闪 / steady 常亮 / " + "color_flow 流光（调色板沿圆周流动，1~2 个颜色锚点插值；**不是彩虹**，无法生成 7 色彩虹波浪）/ " + "pixel_frame 逐组像素帧。" + '易错对照：用户说"红色/蓝色波浪"等单一颜色波浪 → 必须用 wave，不要用 color_flow；' + '用户说"彩虹/七彩/rainbow" → 固件不支持真正的 7 色彩虹，需告知限制并给出近似方案（双锚点 color_flow 或多段 wave 轮播），' + "禁止静默用 color_flow 单锚点冒充彩虹。"
+          },
+          duration_s: {
+            type: "number",
+            minimum: 0,
+            description: "本段持续时长（秒），0 表示无限时长。推荐离散值：0.5/1/2/3/5/6/8/16/24/32/48，建议单段 ≤8s 省电"
+          },
+          brightness: {
+            type: "number",
+            minimum: 0,
+            maximum: 255,
+            description: "前景亮度 0–255。非 pixel_frame 模式必填；brightness=0 仅 steady 模式有效（显式灭灯）"
+          },
+          color: {
+            type: "object",
+            required: ["r", "g", "b"],
+            additionalProperties: false,
+            properties: {
+              r: { type: "number", minimum: 0, maximum: 255 },
+              g: { type: "number", minimum: 0, maximum: 255 },
+              b: { type: "number", minimum: 0, maximum: 255 }
+            },
+            description: "前景色 RGB。非 pixel_frame 模式必填；color_flow 下作为第一颜色锚点，至少 color/background 其一非零"
+          },
+          interval_ms: {
+            type: "number",
+            minimum: 0,
+            description: "步进间隔（ms），wave/strobe/color_flow 有效，默认 200。量化档位：50/100/200/300/500/600/800/1600/2400/3200/4800"
+          },
+          direction: {
+            type: "string",
+            enum: ["ltr", "rtl"],
+            description: "波浪/流光方向，wave/color_flow 有效，默认 ltr"
+          },
+          window: {
+            type: "number",
+            enum: [1, 2, 3],
+            description: "wave：窗口灯数，默认 2；color_flow：调色板平移步幅（速度）"
+          },
+          breath_timing: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              rise_ms: {
+                type: "number",
+                minimum: 0,
+                description: "上升时间（ms），量化到 1040/1560/2080/2600/3100/4160"
+              },
+              hold_ms: {
+                type: "number",
+                minimum: 0,
+                description: "保持最高亮度时间（ms），支持 0ms"
+              },
+              fall_ms: {
+                type: "number",
+                minimum: 0,
+                description: "下降时间（ms），量化到 1040/1560/2080/2600/3100/4160"
+              },
+              off_ms: {
+                type: "number",
+                minimum: 0,
+                description: "熄灭时间（ms），支持 0ms"
+              }
+            },
+            description: "呼吸四段时间，仅 breath 有效；rise/fall 量化档位：1040/1560/2080/2600/3100/4160，hold/off 额外支持 0ms"
+          },
+          background: {
+            type: "object",
+            required: ["r", "g", "b", "brightness"],
+            additionalProperties: false,
+            properties: {
+              r: { type: "number", minimum: 0, maximum: 255 },
+              g: { type: "number", minimum: 0, maximum: 255 },
+              b: { type: "number", minimum: 0, maximum: 255 },
+              brightness: {
+                type: "number",
+                minimum: 0,
+                maximum: 255,
+                description: "底色亮度，量化档位：0/32/64/96/128/192/255"
+              }
+            },
+            description: "底色 RGB + 亮度，wave 有效为底色层；color_flow 有效为第二颜色锚点（与前景色插值生成多色调色板）"
+          },
+          pixels: {
+            type: "array",
+            minItems: 1,
+            maxItems: 7,
+            items: {
+              type: "object",
+              required: ["index", "color", "brightness"],
+              additionalProperties: false,
+              properties: {
+                index: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 6,
+                  description: "LED 组索引，0–6"
+                },
+                color: {
+                  type: "object",
+                  required: ["r", "g", "b"],
+                  additionalProperties: false,
+                  properties: {
+                    r: { type: "number", minimum: 0, maximum: 255 },
+                    g: { type: "number", minimum: 0, maximum: 255 },
+                    b: { type: "number", minimum: 0, maximum: 255 }
+                  },
+                  description: "该像素的 RGB"
+                },
+                brightness: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 255,
+                  description: "该像素亮度 0–255；0 会编码为像素熄灭"
+                }
+              }
+            },
+            description: "仅 pixel_frame 有效：播放前先清 7 组，再按此列表写入 (Idx,R,G,B,Br)"
+          }
+        }
+      }
+    },
+    reason: {
+      type: "string",
+      description: "结合对话上下文，简要说明为什么要亮灯（例如：用户心情低落想要温暖氛围、庆祝生日、提醒喝水等）。" + "这个字段帮助记录每次亮灯的意图和动机。"
+    },
+    title: {
+      type: "string",
+      description: "对本次亮灯的简短标题/摘要（例如：温暖氛围、生日庆祝、喝水提醒）。不填时默认回退到 reason。"
+    },
+    repeat: {
+      type: "boolean",
+      description: "兼容旧参数。true = 无限循环，false/不填 = 一轮；若同时提供 repeat_times，则以后者为准"
+    },
+    repeat_times: {
+      type: "number",
+      minimum: 0,
+      description: "整条组合重复次数：0 = 无限循环，1 = 播放一轮。当前 ANCS 路径不支持 N>=2"
+    }
+  }
+};
+function registerLightControlTool(api, logger) {
+  api.registerTool({
+    name: "light_control",
+    label: "Light Control",
+    description: "立即控制硬件灯效（一次性执行，不会创建或保存通知触发规则），支持 1–12 段顺序灯效，每段独立参数（6 种模式：波浪/呼吸/频闪/常亮/流光/逐组像素帧）。" + "Tool 内部自动量化为嵌入式协议定义的离散档位，并按模式精简为变长 ANCS 控制序列，通过 HTTP 接口下发灯效指令。" + '当用户说"开灯"、"换个灯效"、"把灯调成红色"、"营造氛围"、"测试/预览灯效"等与当前即时灯光控制相关的表达时调用。' + `如果用户说"收到某类通知/消息时亮灯/闪灯/变灯效"，那是持久灯效规则，改用 ${LIGHT_RULE_TOOL_NAMES.create} 或 ${LIGHT_RULE_TOOL_NAMES.update}。`,
+    parameters: lightControlParameters,
+    async execute(toolCallId, params) {
+      let apiKey;
+      try {
+        apiKey = requireApiKey();
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: e.message }],
+          details: { ok: false, error: { code: "AUTH_REQUIRED", message: e.message } }
+        };
+      }
+      const { segments, title, reason, repeat, repeat_times } = params;
+      const validation = validateSegments(segments);
+      if (!validation.valid) {
+        return {
+          content: [{ type: "text", text: JSON.stringify(validation.errors) }],
+          details: {
+            ok: false,
+            error: { code: "VALIDATION_FAILED", details: validation.errors }
+          }
+        };
+      }
+      let repeatTimes;
+      try {
+        repeatTimes = normalizeRepeatTimes({ repeat, repeat_times });
+        assertAncsRepeatTimes(repeatTimes);
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error?.message ?? String(error) }],
+          details: {
+            ok: false,
+            error: { code: "VALIDATION_FAILED", message: error?.message ?? String(error) }
+          }
+        };
+      }
+      logger.info(`Light control title: ${title ?? ""}, reason: ${reason}`);
+      for (const warning of validation.warnings) {
+        logger.warn(`Light control validation warning [${warning.code}] ${warning.field}: ${warning.message}`);
+      }
+      const bizUniqueId = typeof toolCallId === "string" && toolCallId.trim() ? `plugin-tool-${toolCallId.trim()}` : undefined;
+      const result = await sendLightEffect(apiKey, validation.segments, logger, { repeat_times: repeatTimes }, reason, title, { bizUniqueId });
+      if (!result.ok) {
+        logger.warn(`Light control HTTP request failed: ${result.status} ${result.error}`);
+      } else {
+        logger.info(`Light control sent, bizUniqueId=${result.bizUniqueId}`);
+      }
+      const details = validation.warnings.length > 0 ? { ...result, warnings: validation.warnings } : result;
+      return {
+        content: [{ type: "text", text: JSON.stringify(details) }],
+        details
+      };
+    }
+  });
+}
+
 // src/light-rules/registry.ts
 class LightRuleRegistry {
   ctx;
@@ -6557,7 +7074,7 @@ class LightRuleRegistry {
 }
 
 // src/index.ts
-var import_node_path31 = require("node:path");
+var import_node_path33 = require("node:path");
 
 // src/update/channel.ts
 var PRODUCTION_UPDATE_BASE_URL = "https://artifact.yoooclaw.com/plugin";
@@ -6585,8 +7102,8 @@ function resolveUpdateBaseUrl(params) {
 }
 
 // src/update/index.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path13 = require("node:path");
 
 // src/plugin/shared.ts
 function readBody(req) {
@@ -6782,9 +7299,9 @@ class UpdateChecker {
 }
 
 // src/update/executor.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_node_child_process = require("node:child_process");
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 var import_node_os = require("node:os");
 var VERSION_PATTERN = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 var UPDATE_DIR_NAME = ".phone-notifications-update";
@@ -6800,27 +7317,27 @@ function normalizeBaseUrlAndDeps(baseUrlOrDeps, deps) {
   };
 }
 function updateRootForTarget(targetDir) {
-  return import_node_path10.join(import_node_path10.dirname(targetDir), UPDATE_DIR_NAME);
+  return import_node_path11.join(import_node_path11.dirname(targetDir), UPDATE_DIR_NAME);
 }
 function lastUpdateStatusPath(targetDir) {
-  return import_node_path10.join(updateRootForTarget(targetDir), LAST_UPDATE_FILE);
+  return import_node_path11.join(updateRootForTarget(targetDir), LAST_UPDATE_FILE);
 }
 function writeJsonAtomic(path, value) {
-  import_node_fs10.mkdirSync(import_node_path10.dirname(path), { recursive: true });
+  import_node_fs11.mkdirSync(import_node_path11.dirname(path), { recursive: true });
   const tmpPath = `${path}.tmp.${process.pid}.${Date.now()}`;
-  import_node_fs10.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}
+  import_node_fs11.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}
 `);
-  import_node_fs10.renameSync(tmpPath, path);
+  import_node_fs11.renameSync(tmpPath, path);
 }
 function writeLastUpdateStatus(status) {
   writeJsonAtomic(lastUpdateStatusPath(status.targetDir), status);
 }
 function readLastUpdateStatus(targetDir) {
   const path = lastUpdateStatusPath(targetDir);
-  if (!import_node_fs10.existsSync(path))
+  if (!import_node_fs11.existsSync(path))
     return;
   try {
-    return JSON.parse(import_node_fs10.readFileSync(path, "utf8"));
+    return JSON.parse(import_node_fs11.readFileSync(path, "utf8"));
   } catch {
     return;
   }
@@ -6878,17 +7395,17 @@ function isCrossDeviceError(err2) {
 }
 function movePathSync(source, target) {
   try {
-    import_node_fs10.renameSync(source, target);
+    import_node_fs11.renameSync(source, target);
   } catch (err2) {
     if (!isCrossDeviceError(err2))
       throw err2;
-    import_node_fs10.cpSync(source, target, {
+    import_node_fs11.cpSync(source, target, {
       errorOnExist: false,
       force: true,
       recursive: true,
       verbatimSymlinks: true
     });
-    import_node_fs10.rmSync(source, { recursive: true, force: true });
+    import_node_fs11.rmSync(source, { recursive: true, force: true });
   }
 }
 function buildLastUpdateNotice(status) {
@@ -6951,23 +7468,11 @@ function markLastUpdateRestartStatus(targetDir, restartStatus, fields = {}) {
     updatedAt: new Date().toISOString()
   });
 }
-function markLastUpdateReconciled(targetDir) {
-  const status = readLastUpdateStatus(targetDir);
-  if (!status || status.status !== "succeeded")
-    return;
-  if (status.reconciledAt)
-    return;
-  writeLastUpdateStatus({
-    ...status,
-    reconciledAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString()
-  });
-}
 function cleanupPendingDir(status) {
   if (!status?.pendingDir)
     return;
   try {
-    import_node_fs10.rmSync(status.pendingDir, { recursive: true, force: true });
+    import_node_fs11.rmSync(status.pendingDir, { recursive: true, force: true });
   } catch {}
 }
 function applyPreparedUpdate(status, restartStatus = status.restartStatus ?? "pending") {
@@ -7001,12 +7506,12 @@ function applyPreparedUpdate(status, restartStatus = status.restartStatus ?? "pe
   };
   writeLastUpdateStatus(applyingStatus);
   try {
-    if (import_node_fs10.existsSync(status.targetDir)) {
+    if (import_node_fs11.existsSync(status.targetDir)) {
       movePathSync(status.targetDir, backupDir);
     }
     movePathSync(status.packageDir, status.targetDir);
-    import_node_fs10.rmSync(backupDir, { recursive: true, force: true });
-    import_node_fs10.rmSync(status.pendingDir, { recursive: true, force: true });
+    import_node_fs11.rmSync(backupDir, { recursive: true, force: true });
+    import_node_fs11.rmSync(status.pendingDir, { recursive: true, force: true });
     writeLastUpdateStatus({
       ...applyingStatus,
       status: "succeeded",
@@ -7028,7 +7533,7 @@ function applyPreparedUpdate(status, restartStatus = status.restartStatus ?? "pe
   } catch (err2) {
     const error = String(err2 instanceof Error ? err2.stack ?? err2.message : err2);
     try {
-      if (!import_node_fs10.existsSync(status.targetDir) && import_node_fs10.existsSync(backupDir)) {
+      if (!import_node_fs11.existsSync(status.targetDir) && import_node_fs11.existsSync(backupDir)) {
         movePathSync(backupDir, status.targetDir);
       }
     } catch {}
@@ -7205,13 +7710,13 @@ async function executeUpdate(version, runCommand, logger, targetDir, baseUrlOrDe
   const updateId = createUpdateId(now, deps.random?.() ?? Math.random());
   const updateRoot = updateRootForTarget(targetDir);
   const statusPath = lastUpdateStatusPath(targetDir);
-  const pendingDir = import_node_path10.join(updateRoot, updateId);
-  const packageDir = import_node_path10.join(pendingDir, "package");
+  const pendingDir = import_node_path11.join(updateRoot, updateId);
+  const packageDir = import_node_path11.join(pendingDir, "package");
   let workDir = "";
   try {
-    import_node_fs10.mkdirSync(updateRoot, { recursive: true });
-    workDir = import_node_fs10.mkdtempSync(import_node_path10.join(updateRoot, ".work-"));
-    const tgzPath = import_node_path10.join(workDir, "plugin.tgz");
+    import_node_fs11.mkdirSync(updateRoot, { recursive: true });
+    workDir = import_node_fs11.mkdtempSync(import_node_path11.join(updateRoot, ".work-"));
+    const tgzPath = import_node_path11.join(workDir, "plugin.tgz");
     const existingStatus = readLastUpdateStatus(targetDir);
     if (existingStatus && isActiveUpdate(existingStatus, now)) {
       return {
@@ -7240,9 +7745,9 @@ async function executeUpdate(version, runCommand, logger, targetDir, baseUrlOrDe
       };
     }
     const buffer = Buffer.from(await response.arrayBuffer());
-    import_node_fs10.writeFileSync(tgzPath, buffer);
+    import_node_fs11.writeFileSync(tgzPath, buffer);
     logger.info(`下载完成 (${buffer.length} bytes)`);
-    import_node_fs10.mkdirSync(packageDir, { recursive: true });
+    import_node_fs11.mkdirSync(packageDir, { recursive: true });
     const tarResult = await runCommand(["tar", "-xzf", tgzPath, "-C", packageDir, "--strip-components=1"], { timeoutMs: 30000 });
     if (tarResult.code !== 0) {
       const err2 = tarResult.stderr || tarResult.stdout || "unknown error";
@@ -7321,7 +7826,7 @@ async function executeUpdate(version, runCommand, logger, targetDir, baseUrlOrDe
   } finally {
     try {
       if (workDir)
-        import_node_fs10.rmSync(workDir, { force: true, recursive: true });
+        import_node_fs11.rmSync(workDir, { force: true, recursive: true });
     } catch {}
   }
 }
@@ -7397,6 +7902,123 @@ function scheduleGatewayRestart(logger, deps = {}) {
   };
 }
 
+// src/update/stale-runtime.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs12 = require("node:fs");
+var import_node_path12 = require("node:path");
+var ESCALATION_FILE = "restart-escalation.json";
+var ESCALATION_SPAWN_DELAY_MS = 5000;
+function readPackageVersion(packageJsonPath) {
+  try {
+    const parsed = JSON.parse(import_node_fs12.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : undefined;
+  } catch {
+    return;
+  }
+}
+function detectStalePluginRuntime(targetDir, runningVersion = PLUGIN_VERSION) {
+  const diskVersion = readPackageVersion(import_node_path12.join(targetDir, "package.json"));
+  if (!diskVersion || !isNewerVersion(diskVersion, runningVersion)) {
+    return { stale: false, runningVersion, diskVersion };
+  }
+  return { stale: true, runningVersion, diskVersion };
+}
+function escalationRecordPath(targetDir) {
+  return import_node_path12.join(updateRootForTarget(targetDir), ESCALATION_FILE);
+}
+function readEscalationRecord(targetDir) {
+  try {
+    const parsed = JSON.parse(import_node_fs12.readFileSync(escalationRecordPath(targetDir), "utf8"));
+    return typeof parsed?.version === "string" ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function writeEscalationRecord(targetDir, record) {
+  const path = escalationRecordPath(targetDir);
+  import_node_fs12.mkdirSync(import_node_path12.dirname(path), { recursive: true });
+  const tmpPath = `${path}.tmp.${process.pid}`;
+  import_node_fs12.writeFileSync(tmpPath, `${JSON.stringify(record, null, 2)}
+`);
+  import_node_fs12.renameSync(tmpPath, path);
+}
+function resolveRestartCommand(deps) {
+  const argv1 = deps.argv1 ?? process.argv[1];
+  const execPath = deps.execPath ?? process.execPath;
+  if (argv1 && (/openclaw/i.test(import_node_path12.basename(argv1)) || /openclaw/i.test(argv1))) {
+    return [execPath, argv1, "gateway", "restart"];
+  }
+  return ["openclaw", "gateway", "restart"];
+}
+function maybeEscalateStaleRuntimeRestart(logger, targetDir, deps = {}) {
+  const info = detectStalePluginRuntime(targetDir, deps.runningVersion);
+  if (!info.stale || !info.diskVersion)
+    return { action: "none" };
+  const diskVersion = info.diskVersion;
+  logger.error(`插件更新未生效：磁盘已安装 ${diskVersion}，进程仍在运行 ${info.runningVersion}。` + "宿主的进程内重启不会重新加载插件代码，需要完整重启 openclaw 进程。");
+  try {
+    const cfg = deps.loadConfig?.();
+    if (cfg?.commands?.restart === false) {
+      return {
+        action: "manual-required",
+        diskVersion,
+        reason: "commands.restart=false，自动重启被配置禁用"
+      };
+    }
+  } catch (err2) {
+    logger.warn(`陈旧运行时检查读取配置失败: ${String(err2)}`);
+  }
+  const attempted = readEscalationRecord(targetDir);
+  if (attempted?.version === diskVersion) {
+    return {
+      action: "manual-required",
+      diskVersion,
+      reason: `已为 ${diskVersion} 自动触发过一次完整重启但未生效（宿主可能未由 service manager 托管）`
+    };
+  }
+  const command = resolveRestartCommand(deps);
+  const now = deps.now?.() ?? new Date;
+  try {
+    writeEscalationRecord(targetDir, {
+      version: diskVersion,
+      attemptedAt: now.toISOString()
+    });
+  } catch (err2) {
+    return {
+      action: "manual-required",
+      diskVersion,
+      reason: `无法记录自动重启尝试（${String(err2)}），为避免重启循环不再自动触发`
+    };
+  }
+  const spawnFn = deps.spawnFn ?? import_node_child_process2.spawn;
+  const scheduleFn = deps.scheduleFn ?? ((task, delayMs) => setTimeout(task, delayMs));
+  const timer = scheduleFn(() => {
+    try {
+      const child = spawnFn(command[0], command.slice(1), {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref?.();
+      logger.warn(`已触发完整 gateway 重启以加载插件 ${diskVersion}: ${command.join(" ")}`);
+    } catch (err2) {
+      logger.error(`自动完整重启失败（${String(err2)}），请手动完整重启 openclaw 进程以加载 ${diskVersion}`);
+    }
+  }, ESCALATION_SPAWN_DELAY_MS);
+  timer.unref?.();
+  logger.warn(`将在 ${ESCALATION_SPAWN_DELAY_MS / 1000}s 后尝试完整重启 gateway（openclaw gateway restart）以加载 ${diskVersion}`);
+  return { action: "restart-scheduled", diskVersion, command };
+}
+function buildStaleRuntimePromptNotice(info, escalation) {
+  if (!info.stale || !info.diskVersion)
+    return;
+  const base = `[系统通知] phone-notifications 插件已更新到 ${info.diskVersion} 并安装完成，` + `但当前进程仍在运行旧版本 ${info.runningVersion}：宿主的进程内重启（SIGUSR1 / ` + `gateway.restart）不会重新加载插件代码。`;
+  if (escalation.action === "restart-scheduled") {
+    return base + "系统已自动触发一次完整重启，若几分钟后此提示仍出现，说明自动重启未生效，" + "请告知用户需要完整重启 openclaw 进程（例如 systemctl restart openclaw，" + "或结束进程后由服务管理器拉起）。";
+  }
+  const reason = escalation.action === "manual-required" ? `（${escalation.reason}）` : "";
+  return base + `请告知用户需要完整重启 openclaw 进程才能生效${reason}：` + "例如 systemctl restart openclaw，或结束 openclaw 进程后由服务管理器拉起；" + "仅执行进程内的 gateway 重启无效。";
+}
+
 // src/update/index.ts
 
 var PLUGIN_ID2 = "phone-notifications";
@@ -7408,32 +8030,7 @@ function shouldSuppressUpdateNotifications() {
   return process.platform === "win32";
 }
 function resolveTargetDir(api) {
-  try {
-    const cfg = api.runtime.config?.loadConfig?.();
-    const installPath = cfg?.plugins?.installs?.[PLUGIN_ID2]?.installPath;
-    if (installPath)
-      return installPath;
-  } catch {}
-  return import_node_path11.join(resolvePluginStateDir(api), "extensions", PLUGIN_ID2);
-}
-async function updateConfigRecord(api, version, targetDir, tgzUrl) {
-  const configApi = api.runtime.config;
-  if (!configApi)
-    return;
-  const cfg = configApi.loadConfig();
-  if (!cfg.plugins)
-    cfg.plugins = {};
-  if (!cfg.plugins.installs)
-    cfg.plugins.installs = {};
-  cfg.plugins.installs[PLUGIN_ID2] = {
-    ...cfg.plugins.installs[PLUGIN_ID2],
-    source: "archive",
-    sourcePath: tgzUrl,
-    installPath: targetDir,
-    version,
-    installedAt: new Date().toISOString()
-  };
-  await configApi.writeConfigFile(cfg);
+  return import_node_path13.join(resolvePluginStateDir(api), "extensions", PLUGIN_ID2);
 }
 function applyManualRestart(logger, result, targetDir) {
   const version = result.version ?? "目标版本";
@@ -7528,25 +8125,12 @@ function finalizeUpdateResult(api, logger, result, targetDir) {
     message: `已应用更新到 ${version}，正在重启 gateway`
   };
 }
-async function reconcileSucceededUpdateRecord(api, logger, targetDir) {
-  const status = readLastUpdateStatus(targetDir);
-  if (status?.status !== "succeeded" || !status.tgzUrl)
-    return;
-  if (status.reconciledAt)
-    return;
-  try {
-    await updateConfigRecord(api, status.version, targetDir, status.tgzUrl);
-    markLastUpdateReconciled(targetDir);
-  } catch (err2) {
-    logger.warn(`更新已应用，但配置记录补写失败: ${String(err2)}`);
-  }
-}
 function resolveModulePackageJsonPath() {
-  return import_node_path11.join(__dirname, "..", "package.json");
+  return import_node_path13.join(__dirname, "..", "package.json");
 }
 function resolveEffectiveCurrentVersion(targetDir, modulePackageJsonPath = resolveModulePackageJsonPath()) {
   const installedVersion = pickNewestVersion([
-    readPackageVersionAt(import_node_path11.join(targetDir, "package.json")),
+    readPackageVersionAt(import_node_path13.join(targetDir, "package.json")),
     readPackageVersionAt(modulePackageJsonPath)
   ]);
   if (installedVersion && isNewerVersion(installedVersion, PLUGIN_VERSION)) {
@@ -7558,9 +8142,39 @@ function resolveEffectiveCurrentVersion(targetDir, modulePackageJsonPath = resol
   }
   return PLUGIN_VERSION;
 }
+function registerPluginUpdateTool(api, logger, baseUrl, onSuccess) {
+  api.registerTool({
+    name: "plugin-update",
+    label: "Plugin Update",
+    description: "将 phone-notifications 插件更新到指定版本。" + "仅在用户明确同意更新后调用。更新完成后会自动尝试重启 gateway；如宿主不支持，则需手动重启。",
+    parameters: {
+      type: "object",
+      required: ["version"],
+      additionalProperties: false,
+      properties: {
+        version: {
+          type: "string",
+          description: "目标版本号，如 1.11.0"
+        }
+      }
+    },
+    async execute(_toolCallId, params) {
+      const { version } = params;
+      const targetDir = resolveTargetDir(api);
+      const result = await executeUpdate(version, api.runtime.system.runCommandWithTimeout, logger, targetDir, baseUrl);
+      const finalResult = finalizeUpdateResult(api, logger, result, targetDir);
+      if (finalResult.success)
+        onSuccess?.();
+      return {
+        content: [{ type: "text", text: finalResult.message }],
+        details: finalResult
+      };
+    }
+  });
+}
 function readPackageVersionAt(packageJsonPath) {
   try {
-    const parsed = JSON.parse(import_node_fs11.readFileSync(packageJsonPath, "utf-8"));
+    const parsed = JSON.parse(import_node_fs13.readFileSync(packageJsonPath, "utf-8"));
     const version = typeof parsed.version === "string" ? parsed.version.trim() : "";
     return VERSION_PATTERN2.test(version) ? version : undefined;
   } catch {
@@ -7574,11 +8188,15 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
   }
   let pendingUpdate = null;
   let pendingGatewayUpdate = null;
+  let staleRuntimeInfo = {
+    stale: false,
+    runningVersion: PLUGIN_VERSION
+  };
+  let staleRuntimeEscalation = { action: "none" };
   const intervalMs = (config.checkIntervalHours ?? 4) * 3600000;
   const channel = config.channel ?? "latest";
   const baseUrl = config.baseUrl ?? PRODUCTION_UPDATE_BASE_URL;
   const suppressUpdateNotifications = shouldSuppressUpdateNotifications();
-  reconcileSucceededUpdateRecord(api, logger, resolveTargetDir(api));
   function clearPendingUpdateNotice() {
     pendingUpdate = null;
     pendingGatewayUpdate = null;
@@ -7610,42 +8228,21 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
   api.on("before_prompt_build", () => {
     if (suppressUpdateNotifications)
       return;
-    if (!pendingUpdate)
+    const notices = [];
+    const staleNotice = buildStaleRuntimePromptNotice(staleRuntimeInfo, staleRuntimeEscalation);
+    if (staleNotice) {
+      notices.push(staleNotice);
+    } else if (pendingUpdate) {
+      notices.push(`[系统通知] phone-notifications 插件有新版本 ${pendingUpdate.latest} 可用` + `（当前版本 ${pendingUpdate.current}）。
+` + `请用自然语言在合适时机告知用户，若用户同意更新，` + `调用 plugin-update tool 并传入 version 参数。` + `若用户拒绝，不再重复提醒。`);
+    }
+    if (notices.length === 0)
       return;
-    return {
-      appendSystemContext: `[系统通知] phone-notifications 插件有新版本 ${pendingUpdate.latest} 可用` + `（当前版本 ${pendingUpdate.current}）。
-` + `请用自然语言在合适时机告知用户，若用户同意更新，` + `调用 plugin-update tool 并传入 version 参数。` + `若用户拒绝，不再重复提醒。`
-    };
-  });
-  api.registerTool({
-    name: "plugin-update",
-    label: "Plugin Update",
-    description: "将 phone-notifications 插件更新到指定版本。" + "仅在用户明确同意更新后调用。更新完成后会自动尝试重启 gateway；如宿主不支持，则需手动重启。",
-    parameters: {
-      type: "object",
-      required: ["version"],
-      additionalProperties: false,
-      properties: {
-        version: {
-          type: "string",
-          description: "目标版本号，如 1.11.0"
-        }
-      }
-    },
-    async execute(_toolCallId, params) {
-      const { version } = params;
-      const targetDir = resolveTargetDir(api);
-      const result = await executeUpdate(version, api.runtime.system.runCommandWithTimeout, logger, targetDir, baseUrl);
-      const finalResult = finalizeUpdateResult(api, logger, result, targetDir);
-      if (finalResult.success) {
-        clearPendingUpdateNotice();
-      }
-      return {
-        content: [{ type: "text", text: finalResult.message }],
-        details: finalResult
-      };
-    }
+    return { appendSystemContext: notices.join(`
+
+`) };
   });
+  registerPluginUpdateTool(api, logger, baseUrl, clearPendingUpdateNotice);
   if (!suppressUpdateNotifications) {
     logger.info(`自动更新已启用: channel=${channel}, baseUrl=${baseUrl}, checkIntervalHours=${config.checkIntervalHours ?? 4}`);
   }
@@ -7807,6 +8404,14 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
   });
   return {
     start: () => {
+      const targetDir = resolveTargetDir(api);
+      staleRuntimeInfo = detectStalePluginRuntime(targetDir);
+      staleRuntimeEscalation = staleRuntimeInfo.stale ? maybeEscalateStaleRuntimeRestart(logger, targetDir, {
+        loadConfig: () => {
+          const configApi = api.runtime.config;
+          return configApi?.loadConfig?.();
+        }
+      }) : { action: "none" };
       if (!suppressUpdateNotifications)
         checker.start();
     },
@@ -7825,17 +8430,9 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
 }
 
 // src/plugin/auto-update.ts
-function registerAutoUpdateLifecycle(deps) {
-  const {
-    api,
-    config,
-    logger,
-    getBroadcastFn,
-    cacheBroadcast,
-    tunnelService
-  } = deps;
+function resolveAutoUpdateConfig(config) {
   const envName = loadEnvName();
-  const autoUpdateConfig = {
+  return {
     ...config.autoUpdate,
     channel: resolveUpdateChannel({
       configuredChannel: config.autoUpdate?.channel,
@@ -7847,6 +8444,27 @@ function registerAutoUpdateLifecycle(deps) {
       envName
     })
   };
+}
+function registerAutoUpdateAgentTool({
+  api,
+  config,
+  logger
+}) {
+  const autoUpdateConfig = resolveAutoUpdateConfig(config);
+  if (autoUpdateConfig.enabled === false)
+    return;
+  registerPluginUpdateTool(api, logger, autoUpdateConfig.baseUrl);
+}
+function registerAutoUpdateLifecycle(deps) {
+  const {
+    api,
+    config,
+    logger,
+    getBroadcastFn,
+    cacheBroadcast,
+    tunnelService
+  } = deps;
+  const autoUpdateConfig = resolveAutoUpdateConfig(config);
   const autoUpdateLifecycle = registerAutoUpdate(api, logger, autoUpdateConfig, getBroadcastFn, cacheBroadcast, tunnelService ? {
     notifyUpdateAvailable: (update) => tunnelService.notifyUpdateAvailable(update),
     clearPendingUpdate: () => tunnelService.clearPendingUpdate()
@@ -7865,10 +8483,10 @@ function registerAutoUpdateLifecycle(deps) {
 }
 
 // src/plugin/cli.ts
-var import_node_path19 = require("node:path");
+var import_node_path21 = require("node:path");
 
 // src/cli/auth.ts
-var import_node_fs12 = require("node:fs");
+var import_node_fs14 = require("node:fs");
 function registerAuthCli(program) {
   const auth = program.command("auth").description("用户认证管理");
   auth.command("set-api-key <apiKey>").description("设置用户 API Key（持久化到本地配置）").action((apiKey) => {
@@ -7902,13 +8520,13 @@ function registerAuthCli(program) {
   });
   auth.command("clear").description("清除已保存的认证信息").action(() => {
     const path = credentialsPath();
-    if (import_node_fs12.existsSync(path)) {
+    if (import_node_fs14.existsSync(path)) {
       const creds = readCredentials();
       delete creds.apiKey;
       delete creds.apiKeys;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
-        import_node_fs12.rmSync(path, { force: true });
+        import_node_fs14.rmSync(path, { force: true });
       } else {
         writeCredentials(creds);
       }
@@ -8053,9 +8671,9 @@ function registerNtfSummary(ntf, ctx) {
 }
 
 // src/cli/ntf-summary-job.ts
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs13 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_crypto4 = require("node:crypto");
+var import_node_fs15 = require("node:fs");
+var import_node_path14 = require("node:path");
 var SUMMARY_ROOT = ".summaries";
 var JOBS_DIR = "jobs";
 var CHUNKS_DIR = "chunks";
@@ -8175,7 +8793,7 @@ function nowIso2() {
 }
 function createJobId() {
   const stamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
-  return `${stamp}-${import_node_crypto3.randomUUID().slice(0, 8)}`;
+  return `${stamp}-${import_node_crypto4.randomUUID().slice(0, 8)}`;
 }
 function assertJobId(id) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,100}$/.test(id)) {
@@ -8183,24 +8801,24 @@ function assertJobId(id) {
   }
 }
 function summaryJobsDir(notificationsDir) {
-  return import_node_path12.join(notificationsDir, SUMMARY_ROOT, JOBS_DIR);
+  return import_node_path14.join(notificationsDir, SUMMARY_ROOT, JOBS_DIR);
 }
 function summaryJobDir(notificationsDir, id) {
   assertJobId(id);
-  return import_node_path12.join(summaryJobsDir(notificationsDir), id);
+  return import_node_path14.join(summaryJobsDir(notificationsDir), id);
 }
 function metaPath(jobDir) {
-  return import_node_path12.join(jobDir, "meta.json");
+  return import_node_path14.join(jobDir, "meta.json");
 }
 function chunkPath(jobDir, chunkId) {
-  return import_node_path12.join(jobDir, CHUNKS_DIR, `${chunkId}.json`);
+  return import_node_path14.join(jobDir, CHUNKS_DIR, `${chunkId}.json`);
 }
 function writeJson(path, value) {
-  import_node_fs13.writeFileSync(path, JSON.stringify(value, null, 2), "utf-8");
+  import_node_fs15.writeFileSync(path, JSON.stringify(value, null, 2), "utf-8");
 }
 function readJson(path) {
   try {
-    return JSON.parse(import_node_fs13.readFileSync(path, "utf-8"));
+    return JSON.parse(import_node_fs15.readFileSync(path, "utf-8"));
   } catch {
     exitError("READ_FAILED", `无法读取 JSON: ${path}`);
   }
@@ -8208,7 +8826,7 @@ function readJson(path) {
 function readMeta2(notificationsDir, id) {
   const dir = summaryJobDir(notificationsDir, id);
   const path = metaPath(dir);
-  if (!import_node_fs13.existsSync(path)) {
+  if (!import_node_fs15.existsSync(path)) {
     exitError("JOB_NOT_FOUND", `summary job 不存在: ${id}`);
   }
   const meta = readJson(path);
@@ -8296,7 +8914,7 @@ function resolveSummaryText(opts) {
   if (!hasSummary && !hasSummaryFile) {
     exitError("INVALID_COMMIT", "必须提供 --summary 或 --summary-file");
   }
-  const text = hasSummary ? opts.summary : import_node_fs13.readFileSync(import_node_path12.resolve(opts.summaryFile), "utf-8");
+  const text = hasSummary ? opts.summary : import_node_fs15.readFileSync(import_node_path14.resolve(opts.summaryFile), "utf-8");
   if (!text.trim()) {
     exitError("INVALID_COMMIT", "分片摘要不能为空");
   }
@@ -8320,7 +8938,7 @@ function buildResultMarkdown(meta, jobDir) {
       lines.push("(未提交摘要)", "");
       continue;
     }
-    lines.push(import_node_fs13.readFileSync(import_node_path12.join(jobDir, chunk.summaryFile), "utf-8").trim(), "");
+    lines.push(import_node_fs15.readFileSync(import_node_path14.join(jobDir, chunk.summaryFile), "utf-8").trim(), "");
   }
   return lines.join(`
 `).trimEnd() + `
@@ -8328,8 +8946,8 @@ function buildResultMarkdown(meta, jobDir) {
 }
 function writeChunkSummary(notificationsDir, meta, chunk, text) {
   const jobDir = summaryJobDir(notificationsDir, meta.id);
-  const relativeSummaryFile = import_node_path12.join(SUMMARIES_DIR, `${chunk.id}.md`);
-  import_node_fs13.writeFileSync(import_node_path12.join(jobDir, relativeSummaryFile), text, "utf-8");
+  const relativeSummaryFile = import_node_path14.join(SUMMARIES_DIR, `${chunk.id}.md`);
+  import_node_fs15.writeFileSync(import_node_path14.join(jobDir, relativeSummaryFile), text, "utf-8");
   chunk.status = "done";
   chunk.completedAt = nowIso2();
   chunk.summaryFile = relativeSummaryFile;
@@ -8341,7 +8959,7 @@ function finalizeResultIfReady(notificationsDir, meta) {
   }
   const jobDir = summaryJobDir(notificationsDir, meta.id);
   const markdown = buildResultMarkdown(meta, jobDir);
-  import_node_fs13.writeFileSync(import_node_path12.join(jobDir, RESULT_FILE), markdown, "utf-8");
+  import_node_fs15.writeFileSync(import_node_path14.join(jobDir, RESULT_FILE), markdown, "utf-8");
   meta.status = "complete";
   meta.resultFile = RESULT_FILE;
   return markdown;
@@ -8363,8 +8981,8 @@ function registerNtfSummaryJob(ntf, ctx) {
     const id = createJobId();
     const createdAt = nowIso2();
     const jobDir = summaryJobDir(dir, id);
-    import_node_fs13.mkdirSync(import_node_path12.join(jobDir, CHUNKS_DIR), { recursive: true });
-    import_node_fs13.mkdirSync(import_node_path12.join(jobDir, SUMMARIES_DIR), { recursive: true });
+    import_node_fs15.mkdirSync(import_node_path14.join(jobDir, CHUNKS_DIR), { recursive: true });
+    import_node_fs15.mkdirSync(import_node_path14.join(jobDir, SUMMARIES_DIR), { recursive: true });
     const chunks = [];
     for (let start = 0;start < notifications.length; start += chunkSize) {
       const rawChunk = notifications.slice(start, start + chunkSize);
@@ -8658,25 +9276,25 @@ function registerNtfStats(ntf, ctx) {
 }
 
 // src/cli/ntf-sync.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs14 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs16 = require("node:fs");
+var import_node_path15 = require("node:path");
 var SYNC_FETCH_LIMIT = 100;
 function checkpointPath(dir) {
-  return import_node_path13.join(dir, ".checkpoint.json");
+  return import_node_path15.join(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!import_node_fs14.existsSync(p))
+  if (!import_node_fs16.existsSync(p))
     return {};
   try {
-    return JSON.parse(import_node_fs14.readFileSync(p, "utf-8"));
+    return JSON.parse(import_node_fs16.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCheckpoint(dir, data) {
-  import_node_fs14.writeFileSync(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
+  import_node_fs16.writeFileSync(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
 }
 function validateDateKey(value, optionName) {
   const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
@@ -8730,7 +9348,7 @@ function isDateInScope(dateKey, scope) {
 var MEMORY_PLUGIN_KEYWORD = "memory-lancedb-ultra";
 function detectMemoryBackend() {
   try {
-    const out = import_node_child_process2.execFileSync("openclaw", ["plugins", "list"], {
+    const out = import_node_child_process3.execFileSync("openclaw", ["plugins", "list"], {
       encoding: "utf-8",
       timeout: 15000,
       stdio: ["ignore", "pipe", "ignore"]
@@ -8947,8 +9565,8 @@ function registerNtfSync(ntf, ctx) {
 }
 
 // src/cli/ntf-monitor.ts
-var import_node_fs15 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_fs17 = require("node:fs");
+var import_node_path16 = require("node:path");
 
 // src/monitor/fetch-gen.ts
 function generateFetchPy(name, matchRules) {
@@ -9035,20 +9653,20 @@ function tasksDir(ctx) {
   const base = ctx.workspaceDir || ctx.stateDir;
   if (!base)
     throw new Error("workspaceDir and stateDir both unavailable");
-  return import_node_path14.join(base, "tasks");
+  return import_node_path16.join(base, "tasks");
 }
 function readMeta3(taskDir) {
-  const metaPath2 = import_node_path14.join(taskDir, "meta.json");
-  if (!import_node_fs15.existsSync(metaPath2))
+  const metaPath2 = import_node_path16.join(taskDir, "meta.json");
+  if (!import_node_fs17.existsSync(metaPath2))
     return null;
   try {
-    return JSON.parse(import_node_fs15.readFileSync(metaPath2, "utf-8"));
+    return JSON.parse(import_node_fs17.readFileSync(metaPath2, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeMeta2(taskDir, meta) {
-  import_node_fs15.writeFileSync(import_node_path14.join(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  import_node_fs17.writeFileSync(import_node_path16.join(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function generateReadme(name, description) {
   return `# Monitor Task: ${name}
@@ -9067,30 +9685,30 @@ function registerNtfMonitor(ntf, ctx) {
   const monitor = ntf.command("monitor").description("通知监控任务管理");
   monitor.command("list").description("列出所有监控任务").action(() => {
     const dir = tasksDir(ctx);
-    if (!import_node_fs15.existsSync(dir)) {
+    if (!import_node_fs17.existsSync(dir)) {
       output({ ok: true, tasks: [] });
       return;
     }
     const tasks = [];
-    for (const entry of import_node_fs15.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs17.readdirSync(dir, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const meta = readMeta3(import_node_path14.join(dir, entry.name));
+      const meta = readMeta3(import_node_path16.join(dir, entry.name));
       if (meta)
         tasks.push(meta);
     }
     output({ ok: true, tasks });
   });
   monitor.command("show <name>").description("查看监控任务详情").action((name) => {
-    const taskDir = import_node_path14.join(tasksDir(ctx), name);
+    const taskDir = import_node_path16.join(tasksDir(ctx), name);
     const meta = readMeta3(taskDir);
     if (!meta)
       exitError("NOT_FOUND", `监控任务 '${name}' 不存在`);
-    const checkpointPath2 = import_node_path14.join(taskDir, "checkpoint.json");
+    const checkpointPath2 = import_node_path16.join(taskDir, "checkpoint.json");
     let checkpoint = {};
-    if (import_node_fs15.existsSync(checkpointPath2)) {
+    if (import_node_fs17.existsSync(checkpointPath2)) {
       try {
-        checkpoint = JSON.parse(import_node_fs15.readFileSync(checkpointPath2, "utf-8"));
+        checkpoint = JSON.parse(import_node_fs17.readFileSync(checkpointPath2, "utf-8"));
       } catch {}
     }
     output({
@@ -9103,8 +9721,8 @@ function registerNtfMonitor(ntf, ctx) {
   });
   monitor.command("create <name>").description("创建监控任务").requiredOption("--description <text>", "任务描述").requiredOption("--match-rules <json>", "匹配规则 JSON").requiredOption("--schedule <cron>", "cron 表达式").action((name, opts) => {
     const dir = tasksDir(ctx);
-    const taskDir = import_node_path14.join(dir, name);
-    if (import_node_fs15.existsSync(taskDir)) {
+    const taskDir = import_node_path16.join(dir, name);
+    if (import_node_fs17.existsSync(taskDir)) {
       exitError("ALREADY_EXISTS", `监控任务 '${name}' 已存在`);
     }
     let matchRules;
@@ -9113,7 +9731,7 @@ function registerNtfMonitor(ntf, ctx) {
     } catch {
       exitError("VALIDATION_FAILED", "match-rules 必须是合法的 JSON");
     }
-    import_node_fs15.mkdirSync(taskDir, { recursive: true });
+    import_node_fs17.mkdirSync(taskDir, { recursive: true });
     const meta = {
       name,
       description: opts.description,
@@ -9123,8 +9741,8 @@ function registerNtfMonitor(ntf, ctx) {
       createdAt: new Date().toISOString()
     };
     writeMeta2(taskDir, meta);
-    import_node_fs15.writeFileSync(import_node_path14.join(taskDir, "fetch.py"), generateFetchPy(name, matchRules), "utf-8");
-    import_node_fs15.writeFileSync(import_node_path14.join(taskDir, "README.md"), generateReadme(name, opts.description), "utf-8");
+    import_node_fs17.writeFileSync(import_node_path16.join(taskDir, "fetch.py"), generateFetchPy(name, matchRules), "utf-8");
+    import_node_fs17.writeFileSync(import_node_path16.join(taskDir, "README.md"), generateReadme(name, opts.description), "utf-8");
     output({
       ok: true,
       name,
@@ -9148,8 +9766,8 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("delete <name>").description("删除监控任务").option("--yes", "跳过确认").action((name, opts) => {
-    const taskDir = import_node_path14.join(tasksDir(ctx), name);
-    if (!import_node_fs15.existsSync(taskDir)) {
+    const taskDir = import_node_path16.join(tasksDir(ctx), name);
+    if (!import_node_fs17.existsSync(taskDir)) {
       exitError("NOT_FOUND", `监控任务 '${name}' 不存在`);
     }
     if (!opts.yes) {
@@ -9162,7 +9780,7 @@ function registerNtfMonitor(ntf, ctx) {
       });
       process.exit(1);
     }
-    import_node_fs15.rmSync(taskDir, { recursive: true, force: true });
+    import_node_fs17.rmSync(taskDir, { recursive: true, force: true });
     output({
       ok: true,
       name,
@@ -9174,7 +9792,7 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("enable <name>").description("启用监控任务").action((name) => {
-    const taskDir = import_node_path14.join(tasksDir(ctx), name);
+    const taskDir = import_node_path16.join(tasksDir(ctx), name);
     const meta = readMeta3(taskDir);
     if (!meta)
       exitError("NOT_FOUND", `监控任务 '${name}' 不存在`);
@@ -9183,7 +9801,7 @@ function registerNtfMonitor(ntf, ctx) {
     output({ ok: true, name, enabled: true });
   });
   monitor.command("disable <name>").description("暂停监控任务").action((name) => {
-    const taskDir = import_node_path14.join(tasksDir(ctx), name);
+    const taskDir = import_node_path16.join(tasksDir(ctx), name);
     const meta = readMeta3(taskDir);
     if (!meta)
       exitError("NOT_FOUND", `监控任务 '${name}' 不存在`);
@@ -9193,63 +9811,6 @@ function registerNtfMonitor(ntf, ctx) {
   });
 }
 
-// src/light/sender.ts
-var import_node_crypto4 = require("node:crypto");
-async function sendLightEffect(apiKey, segments, logger, repeatInput, reason, title) {
-  const apiUrl = getEnvUrls().lightApiUrl;
-  const appKey = "phone-notifications";
-  const templateId = "1990771146010017800";
-  const resolvedTitle = resolveLightTitle(title, reason, segments);
-  logger?.info(`Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "…" : "UNSET"}, templateId=${templateId ?? "UNSET"}, apiKey=${apiKey ? apiKey.substring(0, 20) + "…" : "EMPTY"}, title=${resolvedTitle}, reason=${reason ?? ""}, segments=${JSON.stringify(segments)}`);
-  if (!apiUrl || !appKey || !templateId) {
-    return {
-      ok: false,
-      error: "灯效 API 未配置，请确认构建时已封装 OPENCLAW_HOST_* / LIGHT_APP_KEY / LIGHT_TEMPLATE_ID"
-    };
-  }
-  let bizContent;
-  try {
-    bizContent = buildLightEffectApnsBody(segments, repeatInput, reason);
-  } catch (error) {
-    return { ok: false, error: error?.message ?? String(error) };
-  }
-  const bizUniqueId = import_node_crypto4.randomUUID();
-  const requestBody = {
-    appKey,
-    bizMap: { noticeType: "APP_NOTIFICATION_IMPORTANT", title: resolvedTitle, reason },
-    bizUniqueId,
-    paramsMap: { bizContent },
-    pushType: "SPECIFY_PUSH",
-    templateId
-  };
-  logger?.info(`Light sender: POST ${apiUrl}, bizUniqueId=${bizUniqueId}, body=${JSON.stringify(requestBody).substring(0, 500)}`);
-  const res = await fetch(apiUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Api-Key-Id": apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey
-    },
-    body: JSON.stringify(requestBody)
-  });
-  const resBody = await res.text();
-  if (!res.ok) {
-    logger?.warn(`Light sender: FAILED ${res.status}, url=${apiUrl}, resBody=${resBody.substring(0, 500)}`);
-    return { ok: false, status: res.status, error: resBody };
-  }
-  logger?.info(`Light sender: OK bizUniqueId=${bizUniqueId}, resBody=${resBody.substring(0, 200)}`);
-  return { ok: true, bizUniqueId, response: JSON.parse(resBody) };
-}
-function resolveLightTitle(title, reason, segments) {
-  const trimmedTitle = title?.trim();
-  if (trimmedTitle)
-    return trimmedTitle;
-  const trimmedReason = reason?.trim();
-  if (trimmedReason)
-    return trimmedReason;
-  const modeDesc = segments.map((segment) => segment.mode).join("+");
-  return `Effect: ${modeDesc || "custom"}`;
-}
-
 // src/cli/light-send.ts
 function registerLightSend(light) {
   light.command("send").description("发送灯效指令到硬件设备").requiredOption("--segments <json>", "灯效参数 JSON").option("--repeat", "无限循环播放（默认仅播放一轮）").option("--repeat-times <n>", "整条组合重复次数：0=无限，1=一轮；当前 ANCS 路径不支持 >=2").action(async (opts) => {
@@ -9279,8 +9840,8 @@ function registerLightSend(light) {
 }
 
 // src/cli/light-setup-tools.ts
-var import_node_fs16 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs18 = require("node:fs");
+var import_node_path17 = require("node:path");
 function isObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -9326,7 +9887,7 @@ function upsertToolsForPolicy(policy, tools) {
 function resolveConfigPath2() {
   return resolveConfigPath();
 }
-var LIGHT_TOOLS = [...LIGHT_RULE_TOOL_NAME_LIST];
+var LIGHT_TOOLS = ["light_control", ...LIGHT_RULE_TOOL_NAME_LIST];
 function upsertLightRuleToolsAlsoAllow(cfg) {
   if (!isObject(cfg.tools))
     cfg.tools = {};
@@ -9346,14 +9907,14 @@ function upsertLightRuleToolsAlsoAllow(cfg) {
   return { globalChanged, mainAgentChanged };
 }
 function registerLightSetupTools(light) {
-  light.command("setup").description("自动放行云端灯效规则工具（兼容 tools.allow / tools.alsoAllow）").action(() => {
+  light.command("setup").description("自动放行一次性灯效与云端灯效规则工具（兼容 tools.allow / tools.alsoAllow）").action(() => {
     const configPath = resolveConfigPath2();
-    if (!import_node_fs16.existsSync(configPath)) {
+    if (!import_node_fs18.existsSync(configPath)) {
       exitError("CONFIG_NOT_FOUND", `未找到配置文件: ${configPath}`);
     }
     let cfg = {};
     try {
-      const raw = import_node_fs16.readFileSync(configPath, "utf-8");
+      const raw = import_node_fs18.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (isObject(parsed))
         cfg = parsed;
@@ -9362,8 +9923,8 @@ function registerLightSetupTools(light) {
     }
     const result = upsertLightRuleToolsAlsoAllow(cfg);
     try {
-      import_node_fs16.mkdirSync(import_node_path15.dirname(configPath), { recursive: true });
-      import_node_fs16.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + `
+      import_node_fs18.mkdirSync(import_node_path17.dirname(configPath), { recursive: true });
+      import_node_fs18.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + `
 `, "utf-8");
     } catch (err2) {
       exitError("WRITE_FAILED", `写入配置失败: ${err2?.message ?? String(err2)}`);
@@ -9382,10 +9943,10 @@ function registerLightSetupTools(light) {
 }
 
 // src/tunnel/status.ts
-var import_node_fs17 = require("node:fs");
-var import_node_path16 = require("node:path");
-var TUNNEL_STATUS_REL_PATH = import_node_path16.join("plugins", "phone-notifications", "tunnel-status.json");
-var TUNNEL_LOCK_REL_PATH = import_node_path16.join("plugins", "phone-notifications", "relay-tunnel.lock");
+var import_node_fs19 = require("node:fs");
+var import_node_path18 = require("node:path");
+var TUNNEL_STATUS_REL_PATH = import_node_path18.join("plugins", "phone-notifications", "tunnel-status.json");
+var TUNNEL_LOCK_REL_PATH = import_node_path18.join("plugins", "phone-notifications", "relay-tunnel.lock");
 function isTunnelState(value) {
   return value === "connected" || value === "connecting" || value === "disconnected" || value === "stopped";
 }
@@ -9434,9 +9995,9 @@ function staleStatusMessage(status, lock) {
   return `${prefix}，但当前运行锁启动于 ${lock.startedAt}，晚于状态时间，说明状态未随新进程刷新。请重启 openclaw 主进程。`;
 }
 function assessTunnelStatus(stateDir) {
-  const statusFilePath = import_node_path16.join(stateDir, TUNNEL_STATUS_REL_PATH);
-  const lockFilePath = import_node_path16.join(stateDir, TUNNEL_LOCK_REL_PATH);
-  if (!import_node_fs17.existsSync(statusFilePath)) {
+  const statusFilePath = import_node_path18.join(stateDir, TUNNEL_STATUS_REL_PATH);
+  const lockFilePath = import_node_path18.join(stateDir, TUNNEL_LOCK_REL_PATH);
+  if (!import_node_fs19.existsSync(statusFilePath)) {
     return {
       status: null,
       issueCode: "STATUS_NOT_FOUND",
@@ -9444,7 +10005,7 @@ function assessTunnelStatus(stateDir) {
       statusFilePath,
       lockFilePath,
       lock: {
-        exists: import_node_fs17.existsSync(lockFilePath),
+        exists: import_node_fs19.existsSync(lockFilePath),
         pid: null,
         startedAt: null,
         active: null
@@ -9453,7 +10014,7 @@ function assessTunnelStatus(stateDir) {
   }
   let rawStatus;
   try {
-    rawStatus = JSON.parse(import_node_fs17.readFileSync(statusFilePath, "utf-8"));
+    rawStatus = JSON.parse(import_node_fs19.readFileSync(statusFilePath, "utf-8"));
   } catch {
     return {
       status: null,
@@ -9462,7 +10023,7 @@ function assessTunnelStatus(stateDir) {
       statusFilePath,
       lockFilePath,
       lock: {
-        exists: import_node_fs17.existsSync(lockFilePath),
+        exists: import_node_fs19.existsSync(lockFilePath),
         pid: null,
         startedAt: null,
         active: null
@@ -9477,7 +10038,7 @@ function assessTunnelStatus(stateDir) {
       statusFilePath,
       lockFilePath,
       lock: {
-        exists: import_node_fs17.existsSync(lockFilePath),
+        exists: import_node_fs19.existsSync(lockFilePath),
         pid: null,
         startedAt: null,
         active: null
@@ -9485,11 +10046,11 @@ function assessTunnelStatus(stateDir) {
     };
   }
   const status = rawStatus;
-  const lockExists = import_node_fs17.existsSync(lockFilePath);
+  const lockExists = import_node_fs19.existsSync(lockFilePath);
   let lockInfo = null;
   if (lockExists) {
     try {
-      lockInfo = parseTunnelLockInfo(JSON.parse(import_node_fs17.readFileSync(lockFilePath, "utf-8")));
+      lockInfo = parseTunnelLockInfo(JSON.parse(import_node_fs19.readFileSync(lockFilePath, "utf-8")));
     } catch {
       lockInfo = null;
     }
@@ -9592,12 +10153,12 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-var import_node_fs18 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs20 = require("node:fs");
+var import_node_path19 = require("node:path");
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = import_node_path17.join(ctx.stateDir, "plugins", "phone-notifications", "logs");
-    if (import_node_fs18.existsSync(dir))
+    const dir = import_node_path19.join(ctx.stateDir, "plugins", "phone-notifications", "logs");
+    if (import_node_fs20.existsSync(dir))
       return dir;
   }
   return null;
@@ -9605,7 +10166,7 @@ function resolveLogsDir(ctx) {
 function listLogDateKeys(dir) {
   const pattern = /^(\d{4}-\d{2}-\d{2})\.log$/;
   const keys = [];
-  for (const entry of import_node_fs18.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of import_node_fs20.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isFile())
       continue;
     const m = pattern.exec(entry.name);
@@ -9615,10 +10176,10 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = import_node_path17.join(dir, `${dateKey}.log`);
-  if (!import_node_fs18.existsSync(filePath))
+  const filePath = import_node_path19.join(dir, `${dateKey}.log`);
+  if (!import_node_fs20.existsSync(filePath))
     return;
-  const content = import_node_fs18.readFileSync(filePath, "utf-8");
+  const content = import_node_fs20.readFileSync(filePath, "utf-8");
   const lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split(`
 `)) {
@@ -9654,7 +10215,7 @@ function registerLogSearch(ntf, ctx) {
 }
 
 // src/cli/env.ts
-var import_node_child_process3 = require("node:child_process");
+var import_node_child_process4 = require("node:child_process");
 var GATEWAY_RESTART_TIMEOUT_MS = 30000;
 var NOOP_LOGGER = {
   info() {},
@@ -9705,7 +10266,7 @@ function triggerGatewayReloadAfterEnvSwitch(deps = {}) {
   }
   const hostCli = deps.hostCli?.trim() || process.env.HOST_CLI?.trim() || "openclaw";
   const command = `${hostCli} gateway restart`;
-  const run = deps.spawnSync ?? import_node_child_process3.spawnSync;
+  const run = deps.spawnSync ?? import_node_child_process4.spawnSync;
   const result = run(hostCli, ["gateway", "restart"], {
     encoding: "utf-8",
     stdio: "pipe",
@@ -9759,11 +10320,11 @@ function registerEnvCli(ntf, deps = {}) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs21 = require("node:fs");
+var import_node_fs23 = require("node:fs");
 var import_node_readline = require("node:readline");
 
 // src/cli/doctor/check-dangerous-flags.ts
-var import_node_fs19 = require("node:fs");
+var import_node_fs21 = require("node:fs");
 function isObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
@@ -9783,13 +10344,13 @@ var checkDangerousFlags = ({ cfg, configPath }) => {
     detail: "这会关闭 Control UI 的设备身份验证，任何人都可以访问控制面板。",
     fixDescription: "设为 false",
     fix: () => {
-      const raw = import_node_fs19.readFileSync(configPath, "utf-8");
+      const raw = import_node_fs21.readFileSync(configPath, "utf-8");
       const config = JSON.parse(raw);
       const gw = config.gateway;
       const cui = gw.controlUi;
       cui.dangerouslyDisableDeviceAuth = false;
-      import_node_fs19.copyFileSync(configPath, configPath + ".bak");
-      import_node_fs19.writeFileSync(configPath, JSON.stringify(config, null, 2) + `
+      import_node_fs21.copyFileSync(configPath, configPath + ".bak");
+      import_node_fs21.writeFileSync(configPath, JSON.stringify(config, null, 2) + `
 `, "utf-8");
     }
   };
@@ -9846,11 +10407,11 @@ function warnEmpty() {
 }
 
 // src/cli/doctor/check-state-dir-perms.ts
-var import_node_fs20 = require("node:fs");
+var import_node_fs22 = require("node:fs");
 var checkStateDirPerms = ({ stateDir }) => {
   let mode;
   try {
-    mode = import_node_fs20.statSync(stateDir).mode;
+    mode = import_node_fs22.statSync(stateDir).mode;
   } catch {
     return null;
   }
@@ -9865,7 +10426,7 @@ var checkStateDirPerms = ({ stateDir }) => {
     detail: "其他用户可以读取该目录下的凭证和配置文件。",
     fixDescription: "chmod 700 " + stateDir,
     fix: () => {
-      import_node_fs20.chmodSync(stateDir, 448);
+      import_node_fs22.chmodSync(stateDir, 448);
     }
   };
 };
@@ -9970,6 +10531,180 @@ var checkTunnel = ({ stateDir }) => {
   };
 };
 
+// src/cli/doctor/check-local-gateway.ts
+var import_node_net = __toESM(require("node:net"));
+
+// src/tunnel/gateway-target.ts
+var DEFAULT_GATEWAY_PORT = "18789";
+var DEFAULT_GATEWAY_HOST = "127.0.0.1";
+var BASE_URL_ENV_KEYS = [
+  "PHONE_NOTIFICATIONS_GATEWAY_BASE_URL",
+  "OPENCLAW_GATEWAY_BASE_URL",
+  "QCLAW_GATEWAY_BASE_URL"
+];
+var PORT_ENV_KEYS = [
+  "OPENCLAW_GATEWAY_PORT",
+  "QCLAW_GATEWAY_PORT"
+];
+function trimToUndefined3(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+function firstEnv(env, keys) {
+  for (const key of keys) {
+    const value = trimToUndefined3(env[key]);
+    if (value)
+      return { key, value };
+  }
+  return;
+}
+function normalizePort(value) {
+  const raw = typeof value === "number" && Number.isInteger(value) ? String(value) : trimToUndefined3(value);
+  if (!raw || !/^\d+$/.test(raw))
+    return;
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    return;
+  }
+  return String(port);
+}
+function normalizeBaseUrl(raw) {
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `http://${raw}`;
+  let parsed;
+  try {
+    parsed = new URL(withScheme);
+  } catch {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return;
+  }
+  if (!parsed.hostname)
+    return;
+  return `${parsed.protocol}//${parsed.host}`;
+}
+function isGatewayTlsEnabled(config) {
+  return config.gateway?.tls?.enabled === true;
+}
+function resolveGatewayPort(params) {
+  const envPort = firstEnv(params.env, PORT_ENV_KEYS);
+  const normalizedEnvPort = envPort ? normalizePort(envPort.value) : undefined;
+  if (envPort && normalizedEnvPort) {
+    return { port: normalizedEnvPort, source: envPort.key };
+  }
+  const configPort = normalizePort(params.config.gateway?.port);
+  if (configPort) {
+    return { port: configPort, source: "openclaw.json gateway.port" };
+  }
+  return { port: DEFAULT_GATEWAY_PORT, source: "default" };
+}
+function resolveLocalGatewayBaseUrl(params = {}) {
+  const config = params.config ?? {};
+  const env = params.env ?? process.env;
+  const tlsEnabled = isGatewayTlsEnabled(config);
+  const envBaseUrl = firstEnv(env, BASE_URL_ENV_KEYS);
+  if (envBaseUrl) {
+    const normalized = normalizeBaseUrl(envBaseUrl.value);
+    if (normalized) {
+      return {
+        baseUrl: normalized,
+        source: envBaseUrl.key,
+        explicit: true,
+        tlsEnabled
+      };
+    }
+  }
+  const { port, source } = resolveGatewayPort({ config, env });
+  const baseUrl = `http://${DEFAULT_GATEWAY_HOST}:${port}`;
+  const warning = envBaseUrl ? `忽略无效的 ${envBaseUrl.key}=${envBaseUrl.value}` : undefined;
+  return {
+    baseUrl,
+    source,
+    explicit: false,
+    tlsEnabled,
+    warning
+  };
+}
+function resolveLocalGatewayTcpTarget(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    return null;
+  }
+  const port = parsed.port ? Number.parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : parsed.protocol === "http:" ? 80 : Number.NaN;
+  if (!parsed.hostname || !Number.isInteger(port))
+    return null;
+  return { host: parsed.hostname, port };
+}
+
+// src/cli/doctor/check-local-gateway.ts
+var PROBE_TIMEOUT_MS = 1200;
+function probeTcp(host, port) {
+  return new Promise((resolve3) => {
+    const socket = import_node_net.default.connect({ host, port });
+    let settled = false;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      socket.destroy();
+      resolve3(result);
+    };
+    socket.setTimeout(PROBE_TIMEOUT_MS);
+    socket.once("connect", () => finish({ ok: true }));
+    socket.once("timeout", () => finish({ ok: false, error: "timeout" }));
+    socket.once("error", (err2) => finish({ ok: false, error: err2.message }));
+  });
+}
+var checkLocalGateway = async ({ cfg }) => {
+  const resolution = resolveLocalGatewayBaseUrl({ config: cfg });
+  if (resolution.warning) {
+    return {
+      id: "local-gateway",
+      severity: "warn",
+      title: "本地 Gateway 地址配置无效",
+      detail: `${resolution.warning}，当前回退到 ${resolution.baseUrl}`,
+      fixDescription: "请修正 PHONE_NOTIFICATIONS_GATEWAY_BASE_URL，或清理该环境变量后重启 openclaw/gateway",
+      fix: null
+    };
+  }
+  if (resolution.tlsEnabled && !resolution.explicit) {
+    return {
+      id: "local-gateway",
+      severity: "warn",
+      title: "Gateway TLS 可能阻断 Relay 本地代理",
+      detail: `检测到 gateway.tls.enabled=true，但插件本地代理默认连接 ${resolution.baseUrl}。` + "如果 Gateway 只接受 HTTPS/WSS，本地 RPC 握手会失败。",
+      fixDescription: "设置 PHONE_NOTIFICATIONS_GATEWAY_BASE_URL=https://127.0.0.1:<port>，或关闭 gateway.tls.enabled 后重启 gateway",
+      fix: null
+    };
+  }
+  const target = resolveLocalGatewayTcpTarget(resolution.baseUrl);
+  if (!target) {
+    return {
+      id: "local-gateway",
+      severity: "warn",
+      title: "本地 Gateway 地址无法解析",
+      detail: `无法解析插件将使用的本地 Gateway 地址: ${resolution.baseUrl}`,
+      fixDescription: "请设置 PHONE_NOTIFICATIONS_GATEWAY_BASE_URL=http://127.0.0.1:<port>",
+      fix: null
+    };
+  }
+  const probe = await probeTcp(target.host, target.port);
+  if (probe.ok)
+    return null;
+  return {
+    id: "local-gateway",
+    severity: "warn",
+    title: "本地 Gateway 不可达",
+    detail: `插件将连接 ${resolution.baseUrl}，但 TCP 探测失败` + (probe.error ? `: ${probe.error}` : ""),
+    fixDescription: "请执行 openclaw gateway status，确认 gateway.port 与 PHONE_NOTIFICATIONS_GATEWAY_BASE_URL 是否一致",
+    fix: null
+  };
+};
+
 // src/cli/doctor/check-node-version.ts
 var MIN_MAJOR = 22;
 var MIN_MINOR = 12;
@@ -10029,6 +10764,7 @@ var allCheckers = [
   checkStateDirPerms,
   checkToolPolicy,
   checkTunnel,
+  checkLocalGateway,
   checkNodeVersion,
   checkPluginVersion
 ];
@@ -10038,10 +10774,10 @@ function isObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function readConfig(configPath) {
-  if (!import_node_fs21.existsSync(configPath))
+  if (!import_node_fs23.existsSync(configPath))
     return {};
   try {
-    const parsed = JSON.parse(import_node_fs21.readFileSync(configPath, "utf-8"));
+    const parsed = JSON.parse(import_node_fs23.readFileSync(configPath, "utf-8"));
     return isObject5(parsed) ? parsed : {};
   } catch {
     return {};
@@ -10252,7 +10988,7 @@ function registerRecStoragePath(rec, ctx) {
 
 // src/cli/rec-setup.ts
 var import_node_readline2 = require("node:readline");
-var import_node_fs22 = require("node:fs");
+var import_node_fs24 = require("node:fs");
 function ask(rl, question) {
   return new Promise((resolve3) => rl.question(question, resolve3));
 }
@@ -10353,9 +11089,9 @@ async function setupLocal(rl) {
 function registerRecSetup(rec, ctx) {
   rec.command("setup").description("交互式配置 ASR 转写参数，保存到本地配置文件").action(async () => {
     const configPath = resolveAsrConfigPath(ctx);
-    if (import_node_fs22.existsSync(configPath)) {
+    if (import_node_fs24.existsSync(configPath)) {
       try {
-        const existing = JSON.parse(import_node_fs22.readFileSync(configPath, "utf-8"));
+        const existing = JSON.parse(import_node_fs24.readFileSync(configPath, "utf-8"));
         process.stderr.write(`当前已有配置：mode = ${existing.mode}`);
         if (existing.updatedAt)
           process.stderr.write(`，更新于 ${existing.updatedAt}`);
@@ -10371,7 +11107,7 @@ function registerRecSetup(rec, ctx) {
       const modeIdx = await askChoice(rl, "选择模式", ["api（云端 model-proxy 长录音）", "local（本地 Whisper）"]);
       const config = modeIdx === 0 ? await setupApi(rl) : await setupLocal(rl);
       const stored = { ...config, updatedAt: new Date().toISOString() };
-      import_node_fs22.writeFileSync(configPath, JSON.stringify(stored, null, 2), "utf-8");
+      import_node_fs24.writeFileSync(configPath, JSON.stringify(stored, null, 2), "utf-8");
       process.stderr.write(`
 ✓ 配置已保存到 ${configPath}
 
@@ -10467,9 +11203,9 @@ function registerImageStoragePath(image, ctx) {
 }
 
 // src/cli/update.ts
-var import_node_child_process4 = require("node:child_process");
-var import_node_fs23 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_child_process5 = require("node:child_process");
+var import_node_fs25 = require("node:fs");
+var import_node_path20 = require("node:path");
 var import_node_os2 = __toESM(require("node:os"));
 async function fetchText(url) {
   const res = await fetch(url, { signal: AbortSignal.timeout(30000) });
@@ -10542,9 +11278,9 @@ async function runUpdate(ctx, opts) {
 `);
     process.exit(1);
   }
-  const tmpScript = import_node_path18.join(import_node_os2.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
+  const tmpScript = import_node_path20.join(import_node_os2.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
   try {
-    import_node_fs23.writeFileSync(tmpScript, installScript, "utf-8");
+    import_node_fs25.writeFileSync(tmpScript, installScript, "utf-8");
   } catch (err2) {
     const msg = `写入临时文件失败: ${err2?.message ?? String(err2)}`;
     if (json) {
@@ -10556,9 +11292,9 @@ async function runUpdate(ctx, opts) {
     process.exit(1);
   }
   const stateDir = resolveStateDir(ctx.stateDir);
-  const result = import_node_child_process4.spawnSync(process.execPath, [tmpScript, "--version", latest, "--state-dir", stateDir], { stdio: "inherit" });
+  const result = import_node_child_process5.spawnSync(process.execPath, [tmpScript, "--version", latest, "--state-dir", stateDir], { stdio: "inherit" });
   try {
-    import_node_fs23.unlinkSync(tmpScript);
+    import_node_fs25.unlinkSync(tmpScript);
   } catch {}
   if (result.error) {
     const msg = `安装脚本执行失败: ${result.error.message}`;
@@ -10632,10 +11368,10 @@ function inferOpenClawRootDir(workspaceDir) {
   if (!workspaceDir) {
     return;
   }
-  if (import_node_path19.basename(workspaceDir) !== "workspace") {
+  if (import_node_path21.basename(workspaceDir) !== "workspace") {
     return;
   }
-  return import_node_path19.dirname(workspaceDir);
+  return import_node_path21.dirname(workspaceDir);
 }
 function registerPluginCli(api, params) {
   const { logger, openclawDir } = params;
@@ -10655,12 +11391,12 @@ function registerPluginCli(api, params) {
 }
 
 // src/plugin/ntf-bin.ts
-var import_node_fs24 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs26 = require("node:fs");
+var import_node_path22 = require("node:path");
 var import_node_process = __toESM(require("node:process"));
 function ensureNtfBinInstalled(opts) {
   const { ntfCjsPath, stateDir, logger } = opts;
-  if (!import_node_fs24.existsSync(ntfCjsPath)) {
+  if (!import_node_fs26.existsSync(ntfCjsPath)) {
     logger.warn(`ntf wrapper: 目标不存在 ${ntfCjsPath}，跳过`);
     return;
   }
@@ -10688,29 +11424,29 @@ function resolveNtfBinInstallDirs(opts) {
   const envPath = opts.envPath ?? import_node_process.default.env.PATH ?? "";
   const pathDirs = splitPathDirs(envPath);
   const candidates = [];
-  pushCandidate(candidates, import_node_path20.dirname(import_node_process.default.execPath), "node 同目录", true);
+  pushCandidate(candidates, import_node_path22.dirname(import_node_process.default.execPath), "node 同目录", true);
   for (const cliName of inferHostCliNames(argv)) {
     const cliPath = findCommandOnPath(cliName, pathDirs);
     if (cliPath) {
-      pushCandidate(candidates, import_node_path20.dirname(cliPath), `宿主 CLI (${cliName}) 同目录`, true);
+      pushCandidate(candidates, import_node_path22.dirname(cliPath), `宿主 CLI (${cliName}) 同目录`, true);
     }
   }
   for (const dir of pathDirs) {
     pushCandidate(candidates, dir, "PATH 目录", true);
   }
   if (opts.stateDir) {
-    pushCandidate(candidates, import_node_path20.join(opts.stateDir, "bin"), "stateDir/bin 兜底", false);
+    pushCandidate(candidates, import_node_path22.join(opts.stateDir, "bin"), "stateDir/bin 兜底", false);
   }
   return candidates;
 }
 function tryInstallWrapper(dir, target) {
   try {
-    import_node_fs24.mkdirSync(dir, { recursive: true });
+    import_node_fs26.mkdirSync(dir, { recursive: true });
   } catch (err2) {
     return { ok: false, reason: `mkdir ${dir} 失败: ${describeError(err2)}` };
   }
   const wrapperName = import_node_process.default.platform === "win32" ? "ntf.cmd" : "ntf";
-  const wrapperPath = import_node_path20.join(dir, wrapperName);
+  const wrapperPath = import_node_path22.join(dir, wrapperName);
   if (pathExists(wrapperPath)) {
     if (isExistingWrapperForTarget(wrapperPath, target)) {
       return { ok: true, path: wrapperPath, created: false };
@@ -10719,13 +11455,13 @@ function tryInstallWrapper(dir, target) {
   }
   try {
     if (import_node_process.default.platform === "win32") {
-      import_node_fs24.writeFileSync(wrapperPath, `@echo off\r
+      import_node_fs26.writeFileSync(wrapperPath, `@echo off\r
 node "${target}" %*\r
 `, "utf-8");
     } else {
-      import_node_fs24.symlinkSync(target, wrapperPath);
+      import_node_fs26.symlinkSync(target, wrapperPath);
       try {
-        import_node_fs24.chmodSync(target, 493);
+        import_node_fs26.chmodSync(target, 493);
       } catch {}
     }
     return { ok: true, path: wrapperPath, created: true };
@@ -10735,7 +11471,7 @@ node "${target}" %*\r
 }
 function pathExists(path) {
   try {
-    import_node_fs24.lstatSync(path);
+    import_node_fs26.lstatSync(path);
     return true;
   } catch {
     return false;
@@ -10744,16 +11480,16 @@ function pathExists(path) {
 function isExistingWrapperForTarget(wrapperPath, target) {
   if (import_node_process.default.platform === "win32") {
     try {
-      return import_node_fs24.readFileSync(wrapperPath, "utf-8").includes(`"${target}"`);
+      return import_node_fs26.readFileSync(wrapperPath, "utf-8").includes(`"${target}"`);
     } catch {
       return false;
     }
   }
   try {
-    if (!import_node_fs24.lstatSync(wrapperPath).isSymbolicLink()) {
+    if (!import_node_fs26.lstatSync(wrapperPath).isSymbolicLink()) {
       return false;
     }
-    return import_node_fs24.realpathSync(wrapperPath) === import_node_fs24.realpathSync(target);
+    return import_node_fs26.realpathSync(wrapperPath) === import_node_fs26.realpathSync(target);
   } catch {
     return false;
   }
@@ -10764,7 +11500,7 @@ function describeError(err2) {
   return String(err2);
 }
 function splitPathDirs(envPath) {
-  return envPath.split(import_node_path20.delimiter).map((entry) => entry.trim()).filter((entry) => entry && import_node_path20.isAbsolute(entry));
+  return envPath.split(import_node_path22.delimiter).map((entry) => entry.trim()).filter((entry) => entry && import_node_path22.isAbsolute(entry));
 }
 function inferHostCliNames(argv) {
   const names = ["openclaw", "jvsclaw", "qclaw"];
@@ -10778,8 +11514,8 @@ function findCommandOnPath(command, pathDirs) {
   const names = import_node_process.default.platform === "win32" && !command.toLowerCase().endsWith(".cmd") ? [command, `${command}.cmd`, `${command}.exe`] : [command];
   for (const dir of pathDirs) {
     for (const name of names) {
-      const candidate = import_node_path20.join(dir, name);
-      if (import_node_fs24.existsSync(candidate)) {
+      const candidate = import_node_path22.join(dir, name);
+      if (import_node_fs26.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -10794,11 +11530,11 @@ function pushCandidate(candidates, dir, label, onPath) {
 }
 
 // src/plugin/lifecycle.ts
-var import_node_fs34 = require("node:fs");
+var import_node_fs36 = require("node:fs");
 
 // src/notification/app-name-map.ts
-var import_node_fs25 = require("node:fs");
-var import_node_path21 = require("node:path");
+var import_node_fs27 = require("node:fs");
+var import_node_path23 = require("node:path");
 var PLUGIN_STATE_DIR = "phone-notifications";
 var CACHE_FILE = "app-name-map.json";
 var BUILTIN_APP_NAME_MAP_URL = getEnvUrls().appNameMapUrl;
@@ -10819,7 +11555,7 @@ function isAppNameMapApiResponse(v) {
   return Array.isArray(o.data) && o.data.every((item) => item !== null && typeof item === "object" && typeof item.packageName === "string" && typeof item.appName === "string");
 }
 function getCachePath(stateDir) {
-  return import_node_path21.join(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+  return import_node_path23.join(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
 }
 function createAppNameMapProvider(opts) {
   const { stateDir, logger } = opts;
@@ -10831,10 +11567,10 @@ function createAppNameMapProvider(opts) {
   let inFlightFetch = null;
   function loadFromDisk() {
     const path = getCachePath(stateDir);
-    if (!import_node_fs25.existsSync(path))
+    if (!import_node_fs27.existsSync(path))
       return;
     try {
-      const raw = JSON.parse(import_node_fs25.readFileSync(path, "utf-8"));
+      const raw = JSON.parse(import_node_fs27.readFileSync(path, "utf-8"));
       if (!isRecordOfStrings(raw))
         return;
       map.clear();
@@ -10880,10 +11616,10 @@ function createAppNameMapProvider(opts) {
         logger.warn("[app-name-map] refresh succeeded but got 0 entries");
         return;
       }
-      const dir = import_node_path21.join(stateDir, "plugins", PLUGIN_STATE_DIR);
-      import_node_fs25.mkdirSync(dir, { recursive: true });
+      const dir = import_node_path23.join(stateDir, "plugins", PLUGIN_STATE_DIR);
+      import_node_fs27.mkdirSync(dir, { recursive: true });
       const cachePath = getCachePath(stateDir);
-      import_node_fs25.writeFileSync(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      import_node_fs27.writeFileSync(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
       logger.info(`[app-name-map] refreshed ${map.size} entries from server and saved: ${cachePath}`);
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
@@ -10934,8 +11670,8 @@ function createAppNameMapProvider(opts) {
 }
 
 // src/recording/storage.ts
-var import_node_fs26 = require("node:fs");
-var import_node_path22 = require("node:path");
+var import_node_fs28 = require("node:fs");
+var import_node_path24 = require("node:path");
 
 // src/recording/state-machine.ts
 var VALID_TRANSITIONS = new Map([
@@ -11199,7 +11935,7 @@ function stripMarkdownFence(markdown) {
 function deriveTitleFromTranscriptPath(transcriptFile, recordingId) {
   if (!transcriptFile)
     return;
-  const name = import_node_path22.basename(transcriptFile, ".md");
+  const name = import_node_path24.basename(transcriptFile, ".md");
   const prefix = `${recordingId}_`;
   if (name.startsWith(prefix)) {
     const derived = name.slice(prefix.length).trim();
@@ -11241,16 +11977,16 @@ function extractTranscriptContent(markdown) {
 `).trim();
 }
 function resolveRecordingStorageDir(ctx, logger) {
-  const stateRecDir = import_node_path22.join(ctx.stateDir, "plugins", "phone-notifications", RECORDINGS_DIR);
+  const stateRecDir = import_node_path24.join(ctx.stateDir, "plugins", "phone-notifications", RECORDINGS_DIR);
   try {
-    import_node_fs26.mkdirSync(stateRecDir, { recursive: true });
+    import_node_fs28.mkdirSync(stateRecDir, { recursive: true });
     logger.info(`录音将写入 stateDir 路径: ${stateRecDir}`);
     return stateRecDir;
   } catch {}
   if (ctx.workspaceDir) {
-    const wsRecDir = import_node_path22.join(ctx.workspaceDir, RECORDINGS_DIR);
+    const wsRecDir = import_node_path24.join(ctx.workspaceDir, RECORDINGS_DIR);
     try {
-      import_node_fs26.mkdirSync(wsRecDir, { recursive: true });
+      import_node_fs28.mkdirSync(wsRecDir, { recursive: true });
       logger.warn(`stateDir 不可用，录音已回退到 workspace 路径: ${wsRecDir}`);
       return wsRecDir;
     } catch {}
@@ -11270,17 +12006,17 @@ class RecordingStorage {
   constructor(dir, logger) {
     this.logger = logger;
     this.dir = dir;
-    this.audioDir = import_node_path22.join(dir, AUDIO_DIR);
-    this.transcriptDataDir = import_node_path22.join(dir, TRANSCRIPT_DATA_DIR);
-    this.transcriptsDir = import_node_path22.join(dir, TRANSCRIPTS_DIR);
-    this.summariesDir = import_node_path22.join(dir, SUMMARIES_DIR2);
-    this.indexPath = import_node_path22.join(dir, INDEX_FILE);
+    this.audioDir = import_node_path24.join(dir, AUDIO_DIR);
+    this.transcriptDataDir = import_node_path24.join(dir, TRANSCRIPT_DATA_DIR);
+    this.transcriptsDir = import_node_path24.join(dir, TRANSCRIPTS_DIR);
+    this.summariesDir = import_node_path24.join(dir, SUMMARIES_DIR2);
+    this.indexPath = import_node_path24.join(dir, INDEX_FILE);
   }
   async init() {
-    import_node_fs26.mkdirSync(this.audioDir, { recursive: true });
-    import_node_fs26.mkdirSync(this.transcriptDataDir, { recursive: true });
-    import_node_fs26.mkdirSync(this.transcriptsDir, { recursive: true });
-    import_node_fs26.mkdirSync(this.summariesDir, { recursive: true });
+    import_node_fs28.mkdirSync(this.audioDir, { recursive: true });
+    import_node_fs28.mkdirSync(this.transcriptDataDir, { recursive: true });
+    import_node_fs28.mkdirSync(this.transcriptsDir, { recursive: true });
+    import_node_fs28.mkdirSync(this.summariesDir, { recursive: true });
     this.loadIndex();
     this.logger.info(`录音存储已初始化: ${this.dir}（共 ${this.index.recordings.length} 条记录）`);
   }
@@ -11312,13 +12048,13 @@ class RecordingStorage {
         return id;
       }
       if (existing.transcriptDataFile) {
-        import_node_fs26.rmSync(import_node_path22.join(this.dir, existing.transcriptDataFile), { force: true });
+        import_node_fs28.rmSync(import_node_path24.join(this.dir, existing.transcriptDataFile), { force: true });
       }
       if (existing.transcriptFile) {
-        import_node_fs26.rmSync(import_node_path22.join(this.dir, existing.transcriptFile), { force: true });
+        import_node_fs28.rmSync(import_node_path24.join(this.dir, existing.transcriptFile), { force: true });
       }
       if (existing.summaryFile) {
-        import_node_fs26.rmSync(import_node_path22.join(this.dir, existing.summaryFile), { force: true });
+        import_node_fs28.rmSync(import_node_path24.join(this.dir, existing.summaryFile), { force: true });
       }
       existing.metadata = metadata;
       existing.clientLabel = clientLabel;
@@ -11375,7 +12111,7 @@ class RecordingStorage {
       return;
     const nextAudioFile = `${AUDIO_DIR}/${filename}`;
     if (entry.audioFile && entry.audioFile !== nextAudioFile) {
-      import_node_fs26.rmSync(import_node_path22.join(this.dir, entry.audioFile), { force: true });
+      import_node_fs28.rmSync(import_node_path24.join(this.dir, entry.audioFile), { force: true });
     }
     entry.audioFile = nextAudioFile;
     entry.updatedAt = new Date().toISOString();
@@ -11395,7 +12131,7 @@ class RecordingStorage {
       return;
     const nextTranscriptDataFile = `${TRANSCRIPT_DATA_DIR}/${filename}`;
     if (entry.transcriptDataFile && entry.transcriptDataFile !== nextTranscriptDataFile) {
-      import_node_fs26.rmSync(import_node_path22.join(this.dir, entry.transcriptDataFile), { force: true });
+      import_node_fs28.rmSync(import_node_path24.join(this.dir, entry.transcriptDataFile), { force: true });
     }
     entry.transcriptDataFile = nextTranscriptDataFile;
     entry.updatedAt = new Date().toISOString();
@@ -11407,7 +12143,7 @@ class RecordingStorage {
       return;
     const nextTranscriptFile = `${TRANSCRIPTS_DIR}/${filename}`;
     if (entry.transcriptFile && entry.transcriptFile !== nextTranscriptFile) {
-      import_node_fs26.rmSync(import_node_path22.join(this.dir, entry.transcriptFile), { force: true });
+      import_node_fs28.rmSync(import_node_path24.join(this.dir, entry.transcriptFile), { force: true });
     }
     entry.transcriptFile = nextTranscriptFile;
     entry.updatedAt = new Date().toISOString();
@@ -11419,7 +12155,7 @@ class RecordingStorage {
       return;
     const nextSummaryFile = `${SUMMARIES_DIR2}/${filename}`;
     if (entry.summaryFile && entry.summaryFile !== nextSummaryFile) {
-      import_node_fs26.rmSync(import_node_path22.join(this.dir, entry.summaryFile), { force: true });
+      import_node_fs28.rmSync(import_node_path24.join(this.dir, entry.summaryFile), { force: true });
     }
     entry.summaryFile = nextSummaryFile;
     entry.updatedAt = new Date().toISOString();
@@ -11508,24 +12244,24 @@ class RecordingStorage {
     if (!entry)
       return false;
     if (entry.audioFile) {
-      const audioPath = import_node_path22.join(this.dir, entry.audioFile);
-      import_node_fs26.rmSync(audioPath, { force: true });
+      const audioPath = import_node_path24.join(this.dir, entry.audioFile);
+      import_node_fs28.rmSync(audioPath, { force: true });
     }
     if (entry.srtFile) {
-      const srtPath = import_node_path22.join(this.dir, entry.srtFile);
-      import_node_fs26.rmSync(srtPath, { force: true });
+      const srtPath = import_node_path24.join(this.dir, entry.srtFile);
+      import_node_fs28.rmSync(srtPath, { force: true });
     }
     if (entry.transcriptDataFile) {
-      const transcriptDataPath = import_node_path22.join(this.dir, entry.transcriptDataFile);
-      import_node_fs26.rmSync(transcriptDataPath, { force: true });
+      const transcriptDataPath = import_node_path24.join(this.dir, entry.transcriptDataFile);
+      import_node_fs28.rmSync(transcriptDataPath, { force: true });
     }
     if (entry.transcriptFile) {
-      const transcriptPath = import_node_path22.join(this.dir, entry.transcriptFile);
-      import_node_fs26.rmSync(transcriptPath, { force: true });
+      const transcriptPath = import_node_path24.join(this.dir, entry.transcriptFile);
+      import_node_fs28.rmSync(transcriptPath, { force: true });
     }
     if (entry.summaryFile) {
-      const summaryPath = import_node_path22.join(this.dir, entry.summaryFile);
-      import_node_fs26.rmSync(summaryPath, { force: true });
+      const summaryPath = import_node_path24.join(this.dir, entry.summaryFile);
+      import_node_fs28.rmSync(summaryPath, { force: true });
     }
     if (opts?.localOnly) {
       entry.audioFile = undefined;
@@ -11561,24 +12297,24 @@ class RecordingStorage {
     return `${recordingId}.md`;
   }
   getAudioFilePath(recordingId, ossUrl) {
-    return import_node_path22.join(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
+    return import_node_path24.join(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
   }
   getSrtFilePath(recordingId) {
-    return import_node_path22.join(this.audioDir, this.buildSrtFilename(recordingId));
+    return import_node_path24.join(this.audioDir, this.buildSrtFilename(recordingId));
   }
   getTranscriptDataFilePath(recordingId) {
-    return import_node_path22.join(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
+    return import_node_path24.join(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
   }
   getSummaryFilePath(recordingId) {
-    return import_node_path22.join(this.summariesDir, this.buildSummaryFilename(recordingId));
+    return import_node_path24.join(this.summariesDir, this.buildSummaryFilename(recordingId));
   }
   loadIndex() {
-    if (!import_node_fs26.existsSync(this.indexPath)) {
+    if (!import_node_fs28.existsSync(this.indexPath)) {
       this.index = { recordings: [] };
       return;
     }
     try {
-      const raw = JSON.parse(import_node_fs26.readFileSync(this.indexPath, "utf-8"));
+      const raw = JSON.parse(import_node_fs28.readFileSync(this.indexPath, "utf-8"));
       if (raw && Array.isArray(raw.recordings)) {
         let needsRewrite = false;
         const normalized = raw.recordings.filter((entry) => entry && typeof entry === "object").map((entry) => {
@@ -11599,14 +12335,23 @@ class RecordingStorage {
           if (typeof entry.transcriptFile === "string") {
             compacted.transcriptFile = entry.transcriptFile;
           }
-          let transcriptDoc = typeof entry.transcriptDataFile === "string" ? this.readRelativeTranscriptDocument(entry.transcriptDataFile) : undefined;
-          if (typeof entry.transcriptDataFile === "string" && transcriptDoc) {
+          let transcriptDocLoaded = false;
+          let transcriptDoc;
+          const loadTranscriptDoc = () => {
+            if (!transcriptDocLoaded) {
+              transcriptDocLoaded = true;
+              transcriptDoc = typeof compacted.transcriptDataFile === "string" ? this.readRelativeTranscriptDocument(compacted.transcriptDataFile) : undefined;
+            }
+            return transcriptDoc;
+          };
+          if (typeof entry.transcriptDataFile === "string") {
             compacted.transcriptDataFile = entry.transcriptDataFile;
           } else {
             const legacyTranscriptText = typeof entry.transcript === "string" && entry.transcript.trim() ? entry.transcript.trim() : compacted.transcriptFile ? extractTranscriptContent(this.readRelativeTextFile(compacted.transcriptFile) ?? "") || undefined : undefined;
             const legacyTitle = typeof entry.title === "string" && entry.title.trim() ? entry.title.trim() : deriveTitleFromTranscriptPath(compacted.transcriptFile, compacted.id);
             const legacySummary = typeof entry.summary === "string" && entry.summary.trim() ? entry.summary.trim() : undefined;
             if (legacyTranscriptText) {
+              transcriptDocLoaded = true;
               transcriptDoc = buildTranscriptDocument({
                 recordingId: compacted.id,
                 generatedAt: compacted.updatedAt,
@@ -11619,7 +12364,7 @@ class RecordingStorage {
                 segments: []
               });
               const transcriptDataFilename = this.buildTranscriptDataFilename(compacted.id);
-              import_node_fs26.writeFileSync(import_node_path22.join(this.transcriptDataDir, transcriptDataFilename), JSON.stringify(transcriptDoc, null, 2), "utf-8");
+              import_node_fs28.writeFileSync(import_node_path24.join(this.transcriptDataDir, transcriptDataFilename), JSON.stringify(transcriptDoc, null, 2), "utf-8");
               compacted.transcriptDataFile = `${TRANSCRIPT_DATA_DIR}/${transcriptDataFilename}`;
               needsRewrite = true;
             }
@@ -11628,14 +12373,14 @@ class RecordingStorage {
             compacted.summaryFile = entry.summaryFile;
           } else if (typeof entry.summary === "string" && entry.summary.trim()) {
             const summaryFilename = this.buildSummaryFilename(entry.id);
-            import_node_fs26.writeFileSync(import_node_path22.join(this.summariesDir, summaryFilename), entry.summary.trim(), "utf-8");
+            import_node_fs28.writeFileSync(import_node_path24.join(this.summariesDir, summaryFilename), entry.summary.trim(), "utf-8");
             compacted.summaryFile = `${SUMMARIES_DIR2}/${summaryFilename}`;
             needsRewrite = true;
           } else {
-            const summaryFromDocument = extractTranscriptSummaryFromDocument(transcriptDoc);
+            const summaryFromDocument = extractTranscriptSummaryFromDocument(loadTranscriptDoc());
             if (summaryFromDocument) {
               const summaryFilename = this.buildSummaryFilename(entry.id);
-              import_node_fs26.writeFileSync(import_node_path22.join(this.summariesDir, summaryFilename), summaryFromDocument, "utf-8");
+              import_node_fs28.writeFileSync(import_node_path24.join(this.summariesDir, summaryFilename), summaryFromDocument, "utf-8");
               compacted.summaryFile = `${SUMMARIES_DIR2}/${summaryFilename}`;
               needsRewrite = true;
             }
@@ -11643,7 +12388,7 @@ class RecordingStorage {
           if (typeof entry.title === "string" && entry.title.trim()) {
             compacted.title = entry.title.trim();
           } else {
-            const titleFromDocument = extractTranscriptTitleFromDocument(transcriptDoc);
+            const titleFromDocument = extractTranscriptTitleFromDocument(loadTranscriptDoc());
             const derivedTitle = titleFromDocument ?? deriveTitleFromTranscriptPath(compacted.transcriptFile, compacted.id);
             if (derivedTitle) {
               compacted.title = derivedTitle;
@@ -11670,13 +12415,14 @@ class RecordingStorage {
         this.index = { recordings: [] };
       }
     } catch {
-      this.logger.warn(`录音索引文件损坏，已重建: ${this.indexPath}`);
+      const quarantinePath = quarantineCorruptFile(this.indexPath);
+      this.logger.warn(quarantinePath ? `录音索引文件损坏，已隔离到 ${quarantinePath} 并重建空索引` : `录音索引文件损坏且隔离失败，已重建空索引: ${this.indexPath}`);
       this.index = { recordings: [] };
     }
   }
   readRelativeTextFile(relativePath) {
     try {
-      return import_node_fs26.readFileSync(import_node_path22.join(this.dir, relativePath), "utf-8");
+      return import_node_fs28.readFileSync(import_node_path24.join(this.dir, relativePath), "utf-8");
     } catch {
       return;
     }
@@ -11689,13 +12435,13 @@ class RecordingStorage {
     return parseTranscriptDocument(raw);
   }
   saveIndex() {
-    import_node_fs26.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2), "utf-8");
+    writeFileAtomic(this.indexPath, JSON.stringify(this.index, null, 2));
   }
   async close() {}
 }
 // src/recording/downloader.ts
-var import_node_fs27 = require("node:fs");
-var import_node_path23 = require("node:path");
+var import_node_fs29 = require("node:fs");
+var import_node_path25 = require("node:path");
 var import_promises2 = require("node:stream/promises");
 var import_node_stream = require("node:stream");
 var DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
@@ -11705,7 +12451,7 @@ async function downloadFile(url, destPath, logger, options) {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
   const retryBackoffMs = options?.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
-  import_node_fs27.mkdirSync(import_node_path23.dirname(destPath), { recursive: true });
+  import_node_fs29.mkdirSync(import_node_path25.dirname(destPath), { recursive: true });
   let lastError;
   for (let attempt = 1;attempt <= maxRetries; attempt++) {
     const startMs = Date.now();
@@ -11721,11 +12467,11 @@ async function downloadFile(url, destPath, logger, options) {
         if (!res.body) {
           throw new Error("响应体为空");
         }
-        const writeStream = import_node_fs27.createWriteStream(destPath);
+        const writeStream = import_node_fs29.createWriteStream(destPath);
         const readable = import_node_stream.Readable.fromWeb(res.body);
         await import_promises2.pipeline(readable, writeStream);
         const elapsed = Date.now() - startMs;
-        const fileSize = import_node_fs27.existsSync(destPath) ? import_node_fs27.statSync(destPath).size : 0;
+        const fileSize = import_node_fs29.existsSync(destPath) ? import_node_fs29.statSync(destPath).size : 0;
         logger.info(`[downloader] 下载完成: ${destPath} (${formatBytes(fileSize)}, ${elapsed}ms)`);
         return { ok: true, sizeBytes: fileSize, elapsedMs: elapsed };
       } finally {
@@ -11734,8 +12480,8 @@ async function downloadFile(url, destPath, logger, options) {
     } catch (err2) {
       lastError = err2?.message ?? String(err2);
       try {
-        if (import_node_fs27.existsSync(destPath))
-          import_node_fs27.unlinkSync(destPath);
+        if (import_node_fs29.existsSync(destPath))
+          import_node_fs29.unlinkSync(destPath);
       } catch {}
       const isAbort = err2?.name === "AbortError";
       logger.warn(`[downloader] 下载失败 (attempt ${attempt}/${maxRetries}): ${isAbort ? "超时" : lastError}`);
@@ -11759,8 +12505,8 @@ function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 // src/recording/result-writer.ts
-var import_node_fs28 = require("node:fs");
-var import_node_path24 = require("node:path");
+var import_node_fs30 = require("node:fs");
+var import_node_path26 = require("node:path");
 function handleRecordingResultWrite(params, storage2, logger, options = {}) {
   const recordingId = normalizeRequiredText(params.recordingId, "recordingId");
   if (!params.transcript && !params.summary) {
@@ -11840,11 +12586,11 @@ function writeTranscript(recordingId, recording, transcript, storage2, logger) {
     raw: transcript
   });
   const transcriptDataFilename = storage2.buildTranscriptDataFilename(recordingId);
-  import_node_fs28.writeFileSync(storage2.getTranscriptDataFilePath(recordingId), JSON.stringify(transcriptDocument, null, 2), "utf-8");
+  import_node_fs30.writeFileSync(storage2.getTranscriptDataFilePath(recordingId), JSON.stringify(transcriptDocument, null, 2), "utf-8");
   storage2.setTranscriptDataFile(recordingId, transcriptDataFilename);
   const transcriptFilename = storage2.buildTranscriptFilename(recordingId, title);
   const markdown = normalizePossiblyEmptyText2(transcript.markdown) ?? buildTranscriptMarkdown(recording, title, text, segments);
-  import_node_fs28.writeFileSync(import_node_path24.join(storage2.getTranscriptsDir(), transcriptFilename), ensureTrailingNewline(markdown), "utf-8");
+  import_node_fs30.writeFileSync(import_node_path26.join(storage2.getTranscriptsDir(), transcriptFilename), ensureTrailingNewline(markdown), "utf-8");
   storage2.setTranscriptFile(recordingId, transcriptFilename);
   storage2.setTitle(recordingId, title);
   logger.info(`[recording-result] 转录文本已写入: ${recordingId}`);
@@ -11859,7 +12605,7 @@ function writeSummary(recordingId, summary, storage2, logger) {
     return;
   }
   const summaryFilename = storage2.buildSummaryFilename(recordingId);
-  import_node_fs28.writeFileSync(storage2.getSummaryFilePath(recordingId), ensureTrailingNewline(markdown), "utf-8");
+  import_node_fs30.writeFileSync(storage2.getSummaryFilePath(recordingId), ensureTrailingNewline(markdown), "utf-8");
   storage2.setSummaryFile(recordingId, summaryFilename);
   logger.info(`[recording-result] 总结已写入: ${recordingId}`);
   return markdown.trim();
@@ -12032,8 +12778,8 @@ function formatTimestamp(ms) {
   return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
 }
 // src/image/store.ts
-var import_node_fs29 = require("node:fs");
-var import_node_path25 = require("node:path");
+var import_node_fs31 = require("node:fs");
+var import_node_path27 = require("node:path");
 var IMAGES_DIR = "images";
 var FILES_DIR = "files";
 var INDEX_FILE2 = "index.json";
@@ -12048,16 +12794,16 @@ function extFromMime(mime) {
   return "jpg";
 }
 function resolveImageStorageDir(ctx, logger) {
-  const stateImagesDir = import_node_path25.join(ctx.stateDir, "plugins", "phone-notifications", IMAGES_DIR);
+  const stateImagesDir = import_node_path27.join(ctx.stateDir, "plugins", "phone-notifications", IMAGES_DIR);
   try {
-    import_node_fs29.mkdirSync(stateImagesDir, { recursive: true });
+    import_node_fs31.mkdirSync(stateImagesDir, { recursive: true });
     logger.info(`图片将写入 stateDir 路径: ${stateImagesDir}`);
     return stateImagesDir;
   } catch {}
   if (ctx.workspaceDir) {
-    const wsImagesDir = import_node_path25.join(ctx.workspaceDir, IMAGES_DIR);
+    const wsImagesDir = import_node_path27.join(ctx.workspaceDir, IMAGES_DIR);
     try {
-      import_node_fs29.mkdirSync(wsImagesDir, { recursive: true });
+      import_node_fs31.mkdirSync(wsImagesDir, { recursive: true });
       logger.warn(`stateDir 不可用，图片已回退到 workspace 路径: ${wsImagesDir}`);
       return wsImagesDir;
     } catch {}
@@ -12074,11 +12820,11 @@ class ImageStorage {
   constructor(dir, logger) {
     this.logger = logger;
     this.dir = dir;
-    this.filesDir = import_node_path25.join(dir, FILES_DIR);
-    this.indexPath = import_node_path25.join(dir, INDEX_FILE2);
+    this.filesDir = import_node_path27.join(dir, FILES_DIR);
+    this.indexPath = import_node_path27.join(dir, INDEX_FILE2);
   }
   async init() {
-    import_node_fs29.mkdirSync(this.filesDir, { recursive: true });
+    import_node_fs31.mkdirSync(this.filesDir, { recursive: true });
     this.loadIndex();
     this.logger.info(`图片存储已初始化: ${this.dir}（共 ${this.index.images.length} 条记录）`);
   }
@@ -12096,7 +12842,7 @@ class ImageStorage {
         return existing;
       }
       if (existing.localFile) {
-        import_node_fs29.rmSync(import_node_path25.join(this.dir, existing.localFile), { force: true });
+        import_node_fs31.rmSync(import_node_path27.join(this.dir, existing.localFile), { force: true });
       }
       existing.metadata = metadata;
       existing.clientLabel = clientLabel;
@@ -12145,10 +12891,10 @@ class ImageStorage {
     return `${FILES_DIR}/${this.buildFilename(imageId, mime)}`;
   }
   getFilePath(imageId, mime) {
-    return import_node_path25.join(this.filesDir, this.buildFilename(imageId, mime));
+    return import_node_path27.join(this.filesDir, this.buildFilename(imageId, mime));
   }
   resolveFile(relative) {
-    return import_node_path25.isAbsolute(relative) ? relative : import_node_path25.join(this.dir, relative);
+    return import_node_path27.isAbsolute(relative) ? relative : import_node_path27.join(this.dir, relative);
   }
   findById(id) {
     return this.index.images.find((e) => e.imageId === id);
@@ -12157,26 +12903,27 @@ class ImageStorage {
     return [...this.index.images].sort((a, b) => b.metadata.created_at.localeCompare(a.metadata.created_at));
   }
   loadIndex() {
-    if (!import_node_fs29.existsSync(this.indexPath)) {
+    if (!import_node_fs31.existsSync(this.indexPath)) {
       this.index = { images: [] };
       return;
     }
     try {
-      const raw = JSON.parse(import_node_fs29.readFileSync(this.indexPath, "utf-8"));
+      const raw = JSON.parse(import_node_fs31.readFileSync(this.indexPath, "utf-8"));
       this.index = raw && Array.isArray(raw.images) ? { images: raw.images } : { images: [] };
     } catch {
-      this.logger.warn(`图片索引文件损坏，已重建: ${this.indexPath}`);
+      const quarantinePath = quarantineCorruptFile(this.indexPath);
+      this.logger.warn(quarantinePath ? `图片索引文件损坏，已隔离到 ${quarantinePath} 并重建空索引` : `图片索引文件损坏且隔离失败，已重建空索引: ${this.indexPath}`);
       this.index = { images: [] };
     }
   }
   saveIndex() {
-    import_node_fs29.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2), "utf-8");
+    writeFileAtomic(this.indexPath, JSON.stringify(this.index, null, 2));
   }
   async close() {}
 }
 // src/image/handler.ts
-var import_node_fs30 = require("node:fs");
-var import_node_path26 = require("node:path");
+var import_node_fs32 = require("node:fs");
+var import_node_path28 = require("node:path");
 var DEFAULT_IMAGE_MAX_BYTES = 20 * 1024 * 1024;
 var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1000;
 function handleImageSync(imageId, metadata, storage2, maxBytes, logger) {
@@ -12209,13 +12956,13 @@ async function runImageDownloadInBackground(imageId, metadata, storage2, maxByte
   logger.info(`[image-sync] 图片已同步: ${imageId} (${result.sizeBytes} bytes)`);
 }
 async function downloadImage(url, destPath, maxBytes, logger) {
-  import_node_fs30.mkdirSync(import_node_path26.dirname(destPath), { recursive: true });
+  import_node_fs32.mkdirSync(import_node_path28.dirname(destPath), { recursive: true });
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
   const cleanup = () => {
     try {
-      if (import_node_fs30.existsSync(destPath))
-        import_node_fs30.unlinkSync(destPath);
+      if (import_node_fs32.existsSync(destPath))
+        import_node_fs32.unlinkSync(destPath);
     } catch {}
   };
   try {
@@ -12230,7 +12977,7 @@ async function downloadImage(url, destPath, maxBytes, logger) {
     if (contentLength > 0 && contentLength > maxBytes) {
       return { ok: false, error: `图片超过上限 ${maxBytes} 字节` };
     }
-    const writeStream = import_node_fs30.createWriteStream(destPath);
+    const writeStream = import_node_fs32.createWriteStream(destPath);
     let total = 0;
     try {
       for await (const chunk of res.body) {
@@ -12264,19 +13011,19 @@ async function downloadImage(url, destPath, maxBytes, logger) {
   }
 }
 // src/tunnel/service.ts
-var import_node_fs32 = require("node:fs");
-var import_node_path29 = require("node:path");
+var import_node_fs34 = require("node:fs");
+var import_node_path31 = require("node:path");
 
 // src/tunnel/relay-client.ts
-var import_node_fs31 = require("node:fs");
-var import_node_path27 = require("node:path");
+var import_node_fs33 = require("node:fs");
+var import_node_path29 = require("node:path");
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
 var import_extension = __toESM(require_extension(), 1);
 var import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
 var import_receiver = __toESM(require_receiver(), 1);
-var import_sender2 = __toESM(require_sender(), 1);
+var import_sender3 = __toESM(require_sender(), 1);
 var import_subprotocol = __toESM(require_subprotocol(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
@@ -12386,8 +13133,8 @@ class RelayClient {
       lastDisconnectReason
     };
     try {
-      import_node_fs31.mkdirSync(import_node_path27.dirname(this.opts.statusFilePath), { recursive: true });
-      import_node_fs31.writeFileSync(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      import_node_fs33.mkdirSync(import_node_path29.dirname(this.opts.statusFilePath), { recursive: true });
+      import_node_fs33.writeFileSync(this.opts.statusFilePath, JSON.stringify(info, null, 2));
     } catch {}
   }
   onInbound(handler) {
@@ -12789,13 +13536,13 @@ var import_node_crypto5 = require("node:crypto");
 
 // src/host-sdk.ts
 var import_node_module = require("node:module");
-var import_node_path28 = require("node:path");
+var import_node_path30 = require("node:path");
 var import_node_url = require("node:url");
 function resolveHostSdkModuleFromHostEntry(specifier, hostEntry = process.argv[1]) {
   if (!hostEntry?.trim())
     return "";
   try {
-    return import_node_module.createRequire(import_node_path28.resolve(hostEntry)).resolve(specifier);
+    return import_node_module.createRequire(import_node_path30.resolve(hostEntry)).resolve(specifier);
   } catch {
     return "";
   }
@@ -12988,6 +13735,33 @@ function loadOrCreateDeviceIdentity(stateDir) {
 
 // src/tunnel/http-proxy.ts
 var RELAY_INTERNAL_HTTP_HEADER = "x-openclaw-relay-internal";
+var GATEWAY_RESPONSE_HEADERS_TIMEOUT_MS = 30000;
+var LARGE_RESPONSE_BODY_WARN_CHARS = 512 * 1024;
+async function fetchWithHeadersTimeout(url, init, upstreamSignal, timeoutMs) {
+  const controller = new AbortController;
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort(upstreamSignal.reason);
+    } else {
+      upstreamSignal.addEventListener("abort", () => controller.abort(upstreamSignal.reason), { once: true });
+    }
+  }
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err2) {
+    if (timedOut) {
+      throw new Error(`local gateway did not respond within ${timeoutMs}ms`);
+    }
+    throw err2;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 var PATH_MAP = {
   "/api/message/messageBridge/send": "/notifications"
 };
@@ -13058,12 +13832,11 @@ async function handleHttpRequest(opts, frame) {
     for (let attemptIndex = 0;attemptIndex < authAttempts.length; attemptIndex++) {
       const attempt = authAttempts[attemptIndex];
       opts.logger.info(`TunnelProxy: HTTP id=${frame.id} attempt ${attemptIndex + 1}/${authAttempts.length} auth=${attempt.label}`);
-      const res = await fetch(url.toString(), {
+      const res = await fetchWithHeadersTimeout(url.toString(), {
         method: frame.method,
         headers: attempt.headers,
-        signal: opts.abortSignal,
         body: frame.method !== "GET" && frame.method !== "HEAD" ? frame.body : undefined
-      });
+      }, opts.abortSignal, GATEWAY_RESPONSE_HEADERS_TIMEOUT_MS);
       const hasFallback = attemptIndex < authAttempts.length - 1;
       if (res.status === 401 && hasFallback) {
         const body = await res.text();
@@ -13103,6 +13876,9 @@ async function sendHttpResponse(opts, params) {
   }
   const body = await res.text();
   opts.logger.info(`TunnelProxy: HTTP id=${frameId} response body=${previewText(body)}`);
+  if (body.length > LARGE_RESPONSE_BODY_WARN_CHARS) {
+    opts.logger.warn(`TunnelProxy: HTTP id=${frameId} ${method} ${path2} response body is ${body.length} chars; single proxy_response frame may exceed the app-side WebSocket message limit (~1MiB)`);
+  }
   const headers = {};
   res.headers.forEach((value, key) => {
     headers[key] = value;
@@ -13520,6 +14296,158 @@ function slimMessagesPayload(payload) {
   }
   return changed;
 }
+var TOOL_MESSAGE_ROLES = new Set(["toolResult", "tool"]);
+var TOOL_CONTENT_TYPES = new Set([
+  "toolResult",
+  "tool_result",
+  "toolUse",
+  "tool_use",
+  "toolCall",
+  "tool_call",
+  "thinking",
+  "redacted_thinking",
+  "reasoning"
+]);
+var MESSAGE_REASONING_FIELDS = [
+  "thinking",
+  "redactedThinking",
+  "redacted_thinking",
+  "reasoning",
+  "reasoningContent",
+  "reasoning_content",
+  "thinkingSignature"
+];
+function stripReasoningFields(message) {
+  if (!isRecord2(message))
+    return { message, changed: false };
+  if (!MESSAGE_REASONING_FIELDS.some((field) => (field in message))) {
+    return { message, changed: false };
+  }
+  const next = { ...message };
+  for (const field of MESSAGE_REASONING_FIELDS) {
+    delete next[field];
+  }
+  return { message: next, changed: true };
+}
+function isToolMessage(message) {
+  return isRecord2(message) && typeof message.role === "string" && TOOL_MESSAGE_ROLES.has(message.role);
+}
+function stripToolContentBlocks(content) {
+  if (!Array.isArray(content))
+    return { content, changed: false };
+  const kept = content.filter((item) => !(isRecord2(item) && typeof item.type === "string" && TOOL_CONTENT_TYPES.has(item.type)));
+  return { content: kept, changed: kept.length !== content.length };
+}
+function isEmptyMessageContent(content) {
+  if (content == null)
+    return true;
+  if (typeof content === "string")
+    return content.trim().length === 0;
+  if (Array.isArray(content))
+    return content.length === 0;
+  return false;
+}
+function hasDisplayableMessageContent(message) {
+  if (!isRecord2(message))
+    return false;
+  if (!isEmptyMessageContent(message.content))
+    return true;
+  return typeof message.text === "string" && message.text.trim().length > 0;
+}
+function messageText(message) {
+  if (!isRecord2(message))
+    return "";
+  if (typeof message.content === "string")
+    return message.content;
+  if (!Array.isArray(message.content))
+    return "";
+  return message.content.filter((item) => isRecord2(item) && item.type === "text" && typeof item.text === "string").map((item) => item.text).join("");
+}
+function isInternalSubagentAnnounce(message) {
+  if (!isRecord2(message))
+    return false;
+  const provenance = isRecord2(message.provenance) ? message.provenance : undefined;
+  if (provenance?.kind === "inter_session" && provenance?.sourceTool === "subagent_announce") {
+    return true;
+  }
+  const text = messageText(message);
+  return message.role === "user" && text.includes("[Inter-session message]") && text.includes("sourceTool=subagent_announce") && text.includes("isUser=false");
+}
+function filterInternalMessages(messages) {
+  const filtered = messages.filter((message) => !isInternalSubagentAnnounce(message));
+  return {
+    messages: filtered,
+    removed: messages.length - filtered.length,
+    changed: filtered.length !== messages.length
+  };
+}
+function filterToolMessages(messages) {
+  const result = [];
+  let changed = false;
+  for (const message of messages) {
+    if (isToolMessage(message)) {
+      changed = true;
+      continue;
+    }
+    const stripped = stripToolContentFromMessage(message);
+    if (stripped.changed) {
+      changed = true;
+      if (!hasDisplayableMessageContent(stripped.message))
+        continue;
+      result.push(stripped.message);
+      continue;
+    }
+    result.push(message);
+  }
+  return { messages: result, removed: messages.length - result.length, changed };
+}
+function stripToolContentFromMessage(message) {
+  const reasoningStripped = stripReasoningFields(message);
+  let next = reasoningStripped.message;
+  let changed = reasoningStripped.changed;
+  if (isRecord2(next) && Array.isArray(next.content)) {
+    const stripped = stripToolContentBlocks(next.content);
+    if (stripped.changed) {
+      next = { ...next, content: stripped.content };
+      changed = true;
+    }
+  }
+  return changed ? { message: next, changed } : { message, changed: false };
+}
+function rewriteSessionEventFrame(frame) {
+  if (frame?.type !== "event")
+    return { action: "keep" };
+  if (frame.event === "session.tool") {
+    return { action: "drop", reason: "tool event mirror" };
+  }
+  if (frame.event !== "session.message")
+    return { action: "keep" };
+  const message = frame?.payload?.message;
+  if (!isRecord2(message))
+    return { action: "keep" };
+  if (isToolMessage(message)) {
+    return { action: "drop", reason: "tool message" };
+  }
+  if (isInternalSubagentAnnounce(message)) {
+    return { action: "drop", reason: "internal subagent announce" };
+  }
+  const stripped = stripToolContentFromMessage(message);
+  if (!stripped.changed)
+    return { action: "keep" };
+  if (!hasDisplayableMessageContent(stripped.message)) {
+    return { action: "drop", reason: "no displayable content after strip" };
+  }
+  return {
+    action: "rewrite",
+    frame: {
+      ...frame,
+      payload: {
+        ...frame.payload,
+        message: stripped.message
+      }
+    }
+  };
+}
 function slimSessionsListPayload(payload) {
   if (!Array.isArray(payload?.sessions))
     return false;
@@ -13611,6 +14539,27 @@ function slimConfigGetPayload(payload) {
     rawPlaceholder: CONFIG_RAW_PLACEHOLDER
   });
 }
+var SUPPRESSED_AGENT_STREAMS = new Set([
+  "command_output",
+  "tool",
+  "thinking",
+  "thought"
+]);
+var TOOL_ITEM_KINDS = new Set(["command", "tool"]);
+function isSuppressedAgentEventFrame(frame) {
+  if (frame?.type !== "event" || frame?.event !== "agent")
+    return false;
+  const payload = frame.payload;
+  if (!isRecord2(payload) || typeof payload.stream !== "string")
+    return false;
+  if (SUPPRESSED_AGENT_STREAMS.has(payload.stream))
+    return true;
+  if (payload.stream === "item") {
+    const kind = isRecord2(payload.data) ? payload.data.kind : undefined;
+    return typeof kind === "string" && TOOL_ITEM_KINDS.has(kind);
+  }
+  return false;
+}
 function slimRelayFrame(frame) {
   if (frame?.type === "event" && frame.event === "agent") {
     return slimAgentEventPayload(frame.payload);
@@ -13624,6 +14573,15 @@ function slimRelayFrame(frame) {
   }
   return false;
 }
+function slimParsedRelayFrame(text, frame, logger) {
+  if (text.length <= SLIM_TRIGGER_CHARS)
+    return text;
+  if (!slimRelayFrame(frame))
+    return text;
+  const slimmed = JSON.stringify(frame);
+  logger?.info(`TunnelProxy: slimmed relay-bound frame ${text.length} → ${slimmed.length} chars`);
+  return slimmed;
+}
 function slimRelayFrameText(text, logger) {
   if (text.length <= SLIM_TRIGGER_CHARS)
     return text;
@@ -13633,11 +14591,7 @@ function slimRelayFrameText(text, logger) {
   } catch {
     return text;
   }
-  if (!slimRelayFrame(frame))
-    return text;
-  const slimmed = JSON.stringify(frame);
-  logger?.info(`TunnelProxy: slimmed relay-bound frame ${text.length} → ${slimmed.length} chars`);
-  return slimmed;
+  return slimParsedRelayFrame(text, frame, logger);
 }
 
 // src/tunnel/proxy.ts
@@ -13655,6 +14609,9 @@ var MAX_AUTO_PAIRING_APPROVALS = 3;
 var RECENT_ABORTED_CHAT_RUN_TTL_MS = 60000;
 var GATEWAY_RPC_HANDSHAKE_TIMEOUT_MS = 1e4;
 var MAX_GATEWAY_WS_PENDING = 200;
+var GATEWAY_RPC_CONNECT_LOG_INTERVAL_MS = 1e4;
+var GATEWAY_RPC_RECONNECT_BASE_MS = 1000;
+var GATEWAY_RPC_RECONNECT_MAX_MS = 30000;
 var approveDevicePairingPromise = null;
 var approveDevicePairingWarned = false;
 function formatErrorMessage(err2) {
@@ -13692,6 +14649,12 @@ class TunnelProxy {
   gatewayReqMetaById = new Map;
   recentAbortedChatRuns = new Map;
   httpAbortControllers = new Map;
+  gatewayWsConnectLogLastAt = 0;
+  gatewayWsConnectLogSuppressed = 0;
+  maintainGatewayWs = false;
+  gatewayWsReconnectTimer = null;
+  gatewayWsReconnectAttempt = 0;
+  gatewayConnectionState = null;
   deviceIdentity;
   stateDir;
   hostStateDir;
@@ -13732,14 +14695,22 @@ class TunnelProxy {
         break;
     }
   }
-  cleanup() {
-    this.opts.logger.info(`TunnelProxy: cleanup, closing ${this.wsProxy.activeCount} active WS connections, gatewayWs=${!!this.gatewayWs}`);
+  cleanupRelayState() {
+    this.opts.logger.info(`TunnelProxy: relay cleanup, closing ${this.wsProxy.activeCount} active WS connections, gatewayWs=${!!this.gatewayWs}`);
     this.wsProxy.cleanup();
     for (const [id, controller] of this.httpAbortControllers) {
       this.opts.logger.info(`TunnelProxy: aborting HTTP proxy id=${id}`);
       controller.abort();
     }
     this.httpAbortControllers.clear();
+    this.gatewayWsPending = [];
+    this.gatewayReqMetaById.clear();
+    this.recentAbortedChatRuns.clear();
+  }
+  cleanup() {
+    this.cleanupRelayState();
+    this.maintainGatewayWs = false;
+    this.clearGatewayReconnectTimer();
     const gatewayWs = this.gatewayWs;
     this.gatewayWs = null;
     this.gatewayWsReady = false;
@@ -13747,14 +14718,19 @@ class TunnelProxy {
     this.gatewayWsReconnectRequested = false;
     this.gatewayWsPairingApprovalPending = false;
     this.gatewayWsAutoPairingApprovals = 0;
-    this.gatewayWsPending = [];
-    this.gatewayReqMetaById.clear();
-    this.recentAbortedChatRuns.clear();
+    const wasConnected = this.gatewayConnectionState === "connected";
     if (gatewayWs) {
       try {
         gatewayWs.close();
       } catch {}
     }
+    if (wasConnected) {
+      this.setGatewayConnectionState("disconnected", "plugin stopping");
+    }
+  }
+  startGatewayConnection() {
+    this.maintainGatewayWs = true;
+    this.ensureGatewayWs();
   }
   async handleRequestFrame(frame) {
     const controller = new AbortController;
@@ -14020,6 +14996,21 @@ class TunnelProxy {
   }
   maybeRewriteGatewayFrame(text, frame) {
     this.pruneRecentAbortedChatRuns();
+    if (isSuppressedAgentEventFrame(frame)) {
+      const stream = frame?.payload?.stream;
+      const kind = frame?.payload?.data?.kind;
+      this.opts.logger.info(`TunnelProxy: dropping agent event stream=${stream}${kind ? ` kind=${kind}` : ""} for session=${frame?.payload?.sessionKey ?? "unknown"}`);
+      return null;
+    }
+    const sessionEvent = rewriteSessionEventFrame(frame);
+    if (sessionEvent.action === "drop") {
+      this.opts.logger.info(`TunnelProxy: dropping ${frame?.event} event (${sessionEvent.reason}) for session=${frame?.payload?.sessionKey ?? "unknown"}`);
+      return null;
+    }
+    if (sessionEvent.action === "rewrite") {
+      this.opts.logger.info(`TunnelProxy: stripped thinking/tool content blocks from session.message for session=${frame?.payload?.sessionKey ?? "unknown"}`);
+      return JSON.stringify(sessionEvent.frame);
+    }
     if (frame?.type === "event" && frame?.event === "chat" && frame?.payload?.state === "aborted") {
       this.rememberRecentAbortedChatRun(frame.payload?.runId, frame.payload?.sessionKey);
       return text;
@@ -14048,22 +15039,36 @@ class TunnelProxy {
         this.opts.logger.info(`TunnelProxy: suppressing synthetic abort failure final for runId=${runId}`);
         return null;
       }
+      const stripped = stripToolContentFromMessage(frame?.payload?.message);
+      if (stripped.changed) {
+        this.opts.logger.info(`TunnelProxy: stripped thinking/tool content blocks from chat final for runId=${runId ?? "unknown"}`);
+        return JSON.stringify({
+          ...frame,
+          payload: { ...frame.payload, message: stripped.message }
+        });
+      }
       return text;
     }
     if (frame?.type === "res" && frame?.ok === true && reqMeta?.method === "chat.history" && Array.isArray(frame?.payload?.messages)) {
       const sessionKey = this.normalizeSessionKey(frame?.payload?.sessionKey) ?? reqMeta.sessionKey;
-      if (!sessionKey)
-        return text;
-      const filteredMessages = frame.payload.messages.filter((message) => !this.isSyntheticAbortHistoryMessage(message, sessionKey));
-      if (filteredMessages.length === frame.payload.messages.length) {
+      const originalCount = frame.payload.messages.length;
+      let messages = frame.payload.messages;
+      if (sessionKey) {
+        messages = messages.filter((message) => !this.isSyntheticAbortHistoryMessage(message, sessionKey));
+      }
+      const internalFiltered = filterInternalMessages(messages);
+      messages = internalFiltered.messages;
+      const toolFiltered = filterToolMessages(messages);
+      messages = toolFiltered.messages;
+      if (messages.length === originalCount && !internalFiltered.changed && !toolFiltered.changed) {
         return text;
       }
-      this.opts.logger.info(`TunnelProxy: removed ${frame.payload.messages.length - filteredMessages.length} synthetic abort history message(s) for session=${sessionKey}`);
+      this.opts.logger.info(`TunnelProxy: chat.history filtered ${originalCount - messages.length} message(s) (tool+internal+synthetic) for session=${sessionKey ?? "unknown"}`);
       return JSON.stringify({
         ...frame,
         payload: {
           ...frame.payload,
-          messages: filteredMessages
+          messages
         }
       });
     }
@@ -14074,10 +15079,11 @@ class TunnelProxy {
       return;
     if (this.gatewayWsConnecting)
       return;
+    this.clearGatewayReconnectTimer();
     this.gatewayWsConnecting = true;
     this.gatewayWsReady = false;
     const wsUrl = this.opts.gatewayBaseUrl.replace(/^http/, "ws");
-    this.opts.logger.info(`TunnelProxy: RPC WS connecting to gateway ${wsUrl} (pending=${this.gatewayWsPending.length})`);
+    this.logGatewayWsConnecting(wsUrl);
     let ws;
     try {
       ws = new wrapper_default(wsUrl, {
@@ -14087,7 +15093,9 @@ class TunnelProxy {
       const message = formatErrorMessage(err2);
       this.gatewayWsConnecting = false;
       this.opts.logger.error(`TunnelProxy: RPC WS failed to create gateway connection: ${message}`);
+      this.setGatewayConnectionState("disconnected", message);
       this.failAllGatewayRequests("GATEWAY_RPC_CONNECT_FAILED", `local gateway RPC connect failed: ${message}`);
+      this.scheduleGatewayReconnect(message);
       return;
     }
     this.gatewayWs = ws;
@@ -14095,10 +15103,11 @@ class TunnelProxy {
       handshakeTimer = null;
       if (this.gatewayWs !== ws || this.gatewayWsReady)
         return;
-      this.opts.logger.warn(`TunnelProxy: RPC WS handshake timed out after ${GATEWAY_RPC_HANDSHAKE_TIMEOUT_MS}ms (pending=${this.gatewayWsPending.length})`);
+      this.opts.logger.warn(`TunnelProxy: RPC WS handshake timed out after ${GATEWAY_RPC_HANDSHAKE_TIMEOUT_MS}ms (pending=${this.gatewayWsPending.length}); ${this.gatewayTroubleshootingHint()}`);
       this.gatewayWs = null;
       this.gatewayWsReady = false;
       this.gatewayWsConnecting = false;
+      this.setGatewayConnectionState("disconnected", "gateway RPC handshake timed out");
       this.failAllGatewayRequests("GATEWAY_RPC_HANDSHAKE_TIMEOUT", "local gateway RPC handshake timed out");
       try {
         if (typeof ws.terminate === "function") {
@@ -14107,6 +15116,7 @@ class TunnelProxy {
           ws.close();
         }
       } catch {}
+      this.scheduleGatewayReconnect("gateway RPC handshake timed out");
     }, GATEWAY_RPC_HANDSHAKE_TIMEOUT_MS);
     const clearHandshakeTimer = () => {
       if (handshakeTimer) {
@@ -14150,6 +15160,9 @@ class TunnelProxy {
         this.gatewayWsReconnectRequested = false;
         this.gatewayWsReady = true;
         this.gatewayWsConnecting = false;
+        this.gatewayWsReconnectAttempt = 0;
+        this.clearGatewayReconnectTimer();
+        this.setGatewayConnectionState("connected", "hello-ok");
         this.opts.logger.info(`TunnelProxy: RPC WS handshake done (hello-ok), flushing ${this.gatewayWsPending.length} pending frames`);
         const pending = this.gatewayWsPending;
         this.gatewayWsPending = [];
@@ -14175,13 +15188,19 @@ class TunnelProxy {
           return;
         }
         this.opts.logger.error(`TunnelProxy: RPC WS handshake failed (pending=${this.gatewayWsPending.length}): ${previewText(JSON.stringify(frame.error), 500)}`);
+        this.setGatewayConnectionState("disconnected", "gateway RPC handshake failed");
         clearHandshakeTimer();
         this.failAllGatewayRequests("GATEWAY_RPC_HANDSHAKE_FAILED", `local gateway RPC handshake failed: ${previewText(JSON.stringify(frame.error), 500)}`);
         ws.close();
         return;
       }
       const rewritten = this.maybeRewriteGatewayFrame(text, frame);
-      if (rewritten !== null) {
+      if (rewritten === null) {
+        return;
+      }
+      if (rewritten === text) {
+        this.opts.client.sendRaw(slimParsedRelayFrame(text, frame, this.opts.logger));
+      } else {
         this.opts.client.sendRaw(slimRelayFrameText(rewritten, this.opts.logger));
       }
     });
@@ -14198,6 +15217,9 @@ class TunnelProxy {
         this.gatewayWsReady = false;
       }
       this.gatewayWsConnecting = false;
+      if (wasReady || this.maintainGatewayWs && !shouldReconnect && !shouldHoldForPairing) {
+        this.setGatewayConnectionState("disconnected", `gateway closed: code=${code}, reason=${reasonText}`);
+      }
       this.maybeClearStoredDeviceTokenOnMismatch(code, reasonText);
       if (shouldReconnect) {
         this.gatewayWsReconnectRequested = false;
@@ -14206,16 +15228,20 @@ class TunnelProxy {
       } else if (!shouldHoldForPairing && (pendingCount > 0 || this.gatewayReqMetaById.size > 0)) {
         this.failAllGatewayRequests("GATEWAY_RPC_DISCONNECTED", `local gateway RPC disconnected: code=${code}, reason=${reasonText}`);
       }
+      if (!shouldReconnect && !shouldHoldForPairing) {
+        this.scheduleGatewayReconnect(`gateway closed: code=${code}, reason=${reasonText}`);
+      }
     });
     ws.on("error", (err2) => {
       clearHandshakeTimer();
-      this.opts.logger.warn(`TunnelProxy: RPC WS error: ${err2.message} (ready=${this.gatewayWsReady}, pending=${this.gatewayWsPending.length}, activeWs=${this.wsProxy.activeCount})`);
+      this.opts.logger.warn(`TunnelProxy: RPC WS error: ${err2.message} (ready=${this.gatewayWsReady}, pending=${this.gatewayWsPending.length}, activeWs=${this.wsProxy.activeCount}); ${this.gatewayTroubleshootingHint()}`);
       const shouldFailRequests = this.gatewayWs === ws && (this.gatewayWsPending.length > 0 || this.gatewayReqMetaById.size > 0);
       this.gatewayWsConnecting = false;
       if (this.gatewayWs === ws) {
         this.gatewayWs = null;
         this.gatewayWsReady = false;
       }
+      this.setGatewayConnectionState("disconnected", `gateway RPC error: ${err2.message}`);
       if (shouldFailRequests) {
         this.failAllGatewayRequests("GATEWAY_RPC_ERROR", `local gateway RPC error: ${err2.message}`);
       }
@@ -14224,8 +15250,58 @@ class TunnelProxy {
           ws.terminate();
         }
       } catch {}
+      this.scheduleGatewayReconnect(`gateway RPC error: ${err2.message}`);
     });
   }
+  setGatewayConnectionState(state, reason) {
+    if (this.gatewayConnectionState === state)
+      return;
+    this.gatewayConnectionState = state;
+    if (state === "connected") {
+      this.opts.logger.info(`TunnelProxy: local gateway connection state connected (${reason})`);
+      this.opts.onGatewayConnected?.();
+      return;
+    }
+    this.opts.logger.warn(`TunnelProxy: local gateway connection state disconnected (${reason})`);
+    this.opts.onGatewayDisconnected?.(reason);
+  }
+  clearGatewayReconnectTimer() {
+    if (!this.gatewayWsReconnectTimer)
+      return;
+    clearTimeout(this.gatewayWsReconnectTimer);
+    this.gatewayWsReconnectTimer = null;
+  }
+  scheduleGatewayReconnect(reason) {
+    if (!this.maintainGatewayWs || this.gatewayWsReconnectTimer)
+      return;
+    if (this.gatewayWsReady || this.gatewayWsConnecting)
+      return;
+    const baseDelayMs = Math.min(GATEWAY_RPC_RECONNECT_BASE_MS * Math.pow(2, this.gatewayWsReconnectAttempt), GATEWAY_RPC_RECONNECT_MAX_MS);
+    const jitterMs = Math.floor(Math.random() * Math.max(1, baseDelayMs / 4));
+    const delayMs = baseDelayMs + jitterMs;
+    this.gatewayWsReconnectAttempt++;
+    this.opts.logger.info(`TunnelProxy: reconnecting local gateway RPC in ${delayMs}ms (attempt ${this.gatewayWsReconnectAttempt}, reason=${reason})`);
+    this.gatewayWsReconnectTimer = setTimeout(() => {
+      this.gatewayWsReconnectTimer = null;
+      this.ensureGatewayWs();
+    }, delayMs);
+    this.gatewayWsReconnectTimer.unref?.();
+  }
+  logGatewayWsConnecting(wsUrl) {
+    const now = Date.now();
+    const shouldLog = this.gatewayWsConnectLogLastAt === 0 || now - this.gatewayWsConnectLogLastAt >= GATEWAY_RPC_CONNECT_LOG_INTERVAL_MS;
+    if (!shouldLog) {
+      this.gatewayWsConnectLogSuppressed++;
+      return;
+    }
+    const suppressed = this.gatewayWsConnectLogSuppressed > 0 ? `, suppressed=${this.gatewayWsConnectLogSuppressed}` : "";
+    this.opts.logger.info(`TunnelProxy: RPC WS connecting to gateway ${wsUrl} (pending=${this.gatewayWsPending.length}${suppressed})`);
+    this.gatewayWsConnectLogLastAt = now;
+    this.gatewayWsConnectLogSuppressed = 0;
+  }
+  gatewayTroubleshootingHint() {
+    return `check local gateway (${this.opts.gatewayBaseUrl}), openclaw gateway status, gateway.port/gateway.tls.enabled, or PHONE_NOTIFICATIONS_GATEWAY_BASE_URL`;
+  }
   handleConnectChallenge(ws, frame) {
     const challengeNonce = frame.payload?.nonce ?? "";
     const connectRequestId = `tunnel-connect-${import_node_crypto5.randomUUID()}`;
@@ -14278,57 +15354,105 @@ class TunnelProxy {
 }
 
 // src/tunnel/connect-status-reporter.ts
+var REPORT_TIMEOUT_MS = 1e4;
+var RETRY_BASE_MS = 1000;
+var RETRY_MAX_MS = 60000;
 function createConnectStatusReporter(opts) {
   const { logger } = opts;
   let lastReported = null;
+  let desiredStatus = null;
   let inFlight = null;
+  let retryTimer = null;
+  let retryAttempt = 0;
   async function post(status) {
     const url = getEnvUrls().gatewayConnectStatusUrl;
     if (!url) {
       logger.warn("[gateway-connect-status] url is empty for current env, skip report");
-      return;
+      return "skip";
     }
     const apiKey = loadApiKey();
     if (!apiKey) {
       logger.info("[gateway-connect-status] api key missing, skip report");
-      return;
+      return "skip";
     }
     const rawApiKey = apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
     try {
       const res = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ apiKey: rawApiKey, connectStatus: status })
+        body: JSON.stringify({ apiKey: rawApiKey, connectStatus: status }),
+        signal: AbortSignal.timeout(REPORT_TIMEOUT_MS)
       });
       if (!res.ok) {
         logger.warn(`[gateway-connect-status] report ${status} failed: HTTP ${res.status} ${res.statusText}`);
-        return;
+        return res.status >= 500 || res.status === 429 ? "retry" : "skip";
       }
       logger.info(`[gateway-connect-status] reported ${status}`);
+      return "success";
     } catch (err2) {
       const message = err2 instanceof Error ? err2.message : String(err2);
       logger.warn(`[gateway-connect-status] report ${status} error: ${message}`);
+      return "retry";
+    }
+  }
+  function clearRetryTimer() {
+    if (!retryTimer)
+      return;
+    clearTimeout(retryTimer);
+    retryTimer = null;
+  }
+  function scheduleRetry() {
+    if (retryTimer || desiredStatus === null || desiredStatus === lastReported) {
+      return;
     }
+    const delayMs = Math.min(RETRY_BASE_MS * Math.pow(2, retryAttempt), RETRY_MAX_MS);
+    retryAttempt++;
+    logger.info(`[gateway-connect-status] retrying ${desiredStatus} in ${delayMs}ms (attempt ${retryAttempt})`);
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      drain();
+    }, delayMs);
+    retryTimer.unref?.();
+  }
+  function drain() {
+    if (inFlight || desiredStatus === null || desiredStatus === lastReported) {
+      return;
+    }
+    clearRetryTimer();
+    const status = desiredStatus;
+    inFlight = post(status).then((result) => {
+      if (result === "success") {
+        lastReported = status;
+        retryAttempt = 0;
+      } else if (result === "skip" && desiredStatus === status) {
+        desiredStatus = null;
+        retryAttempt = 0;
+      }
+    }).finally(() => {
+      inFlight = null;
+      if (desiredStatus === lastReported)
+        return;
+      if (desiredStatus !== status) {
+        retryAttempt = 0;
+        drain();
+        return;
+      }
+      scheduleRetry();
+    });
   }
   return {
     report(status) {
-      if (lastReported === status)
+      desiredStatus = status;
+      if (lastReported === status) {
+        clearRetryTimer();
         return;
-      lastReported = status;
-      const run = async () => {
-        if (inFlight) {
-          try {
-            await inFlight;
-          } catch {}
-        }
-        await post(status);
-      };
-      inFlight = run().finally(() => {
-        inFlight = null;
-      });
+      }
+      drain();
     },
     reset() {
       lastReported = null;
+      retryAttempt = 0;
+      drain();
     }
   };
 }
@@ -14378,6 +15502,9 @@ function createTunnelService(opts) {
   let authRefreshTimer = null;
   let authRefreshPromise = null;
   let pendingAuthRefreshReason = null;
+  const connectStatusReporter = createConnectStatusReporter({
+    logger: opts.logger
+  });
   function emitRelayEvent(event, payload) {
     if (!client?.isConnected())
       return false;
@@ -14405,7 +15532,7 @@ function createTunnelService(opts) {
   }
   function readLockInfo(filePath) {
     try {
-      const parsed = JSON.parse(import_node_fs32.readFileSync(filePath, "utf-8"));
+      const parsed = JSON.parse(import_node_fs34.readFileSync(filePath, "utf-8"));
       const pid = typeof parsed.pid === "number" ? parsed.pid : null;
       const updatedAtMs = typeof parsed.updatedAt === "string" ? Date.parse(parsed.updatedAt) : Number.NaN;
       return {
@@ -14438,7 +15565,7 @@ function createTunnelService(opts) {
       if (!filePath)
         return;
       try {
-        import_node_fs32.writeFileSync(filePath, buildLockPayload(), { mode: 384 });
+        import_node_fs34.writeFileSync(filePath, buildLockPayload(), { mode: 384 });
       } catch {}
     }, intervalMs);
     lockRefreshTimer.unref?.();
@@ -14452,25 +15579,25 @@ function createTunnelService(opts) {
     lockStartedAt = null;
     if (fd !== null) {
       try {
-        import_node_fs32.closeSync(fd);
+        import_node_fs34.closeSync(fd);
       } catch {}
     }
     if (filePath) {
       try {
-        import_node_fs32.unlinkSync(filePath);
+        import_node_fs34.unlinkSync(filePath);
       } catch {}
     }
   }
   function acquireLock(filePath) {
-    import_node_fs32.mkdirSync(import_node_path29.dirname(filePath), { recursive: true });
+    import_node_fs34.mkdirSync(import_node_path31.dirname(filePath), { recursive: true });
     const heartbeatSec = opts.heartbeatSec ?? DEFAULT_HEARTBEAT_SEC;
     const refreshMs = heartbeatSec * 1000 * LOCK_REFRESH_HEARTBEAT_MULTIPLIER;
     const staleMs = heartbeatSec * 1000 * LOCK_STALE_HEARTBEAT_MULTIPLIER;
     for (let attempt = 0;attempt < 2; attempt++) {
       try {
         lockStartedAt = new Date().toISOString();
-        const fd = import_node_fs32.openSync(filePath, "wx", 384);
-        import_node_fs32.writeFileSync(fd, buildLockPayload());
+        const fd = import_node_fs34.openSync(filePath, "wx", 384);
+        import_node_fs34.writeFileSync(fd, buildLockPayload());
         lockFilePath = filePath;
         lockFd = fd;
         startLockRefresh(refreshMs);
@@ -14488,7 +15615,7 @@ function createTunnelService(opts) {
           const staleReason = describeStaleLock(ownerPid, updatedAt, staleMs);
           opts.logger.warn(`Relay tunnel: removing stale local lock (${staleReason})`);
           try {
-            import_node_fs32.unlinkSync(filePath);
+            import_node_fs34.unlinkSync(filePath);
           } catch {}
           continue;
         }
@@ -14593,10 +15720,10 @@ function createTunnelService(opts) {
     const { logger } = opts;
     const hostStateDir = resolveHostStateDir(ctx.stateDir);
     const stateDir = resolveStateDir(hostStateDir);
-    const baseStateDir = import_node_path29.join(stateDir, "plugins", "phone-notifications");
+    const baseStateDir = import_node_path31.join(stateDir, "plugins", "phone-notifications");
     logger.info(`Relay tunnel: starting (pid=${process.pid}, url=${redactUrlSecrets(opts.tunnelUrl)}, heartbeat=${opts.heartbeatSec ?? DEFAULT_HEARTBEAT_SEC}s, backoff=${opts.reconnectBackoffMs ?? DEFAULT_RECONNECT_BACKOFF_MS}ms, gateway=${opts.gatewayBaseUrl}, hasGatewayToken=${!!opts.gatewayToken}, hasGatewayPwd=${!!opts.gatewayPassword})`);
-    const statusFilePath = import_node_path29.join(baseStateDir, "tunnel-status.json");
-    const lockPath = import_node_path29.join(baseStateDir, "relay-tunnel.lock");
+    const statusFilePath = import_node_path31.join(baseStateDir, "tunnel-status.json");
+    const lockPath = import_node_path31.join(baseStateDir, "relay-tunnel.lock");
     if (!acquireLock(lockPath)) {
       return;
     }
@@ -14616,20 +15743,24 @@ function createTunnelService(opts) {
         gatewayAuthMode: opts.gatewayAuthMode,
         gatewayToken: opts.gatewayToken,
         gatewayPassword: opts.gatewayPassword,
+        onGatewayConnected: () => {
+          connectStatusReporter.report("connected");
+        },
+        onGatewayDisconnected: () => {
+          connectStatusReporter.report("disconnected");
+        },
         client,
         logger
       });
-      const connectStatusReporter = createConnectStatusReporter({ logger });
       client.onInbound((frame) => proxy.handleFrame(frame));
       client.onConnected(() => {
-        connectStatusReporter.report("connected");
         emitPendingPluginUpdate("relay connected");
       });
       client.onDisconnected((reason) => {
-        logger.warn(`Relay tunnel: relay disconnected, cleaning local proxy state (${reason})`);
-        connectStatusReporter.report("disconnected");
-        proxy?.cleanup();
+        logger.warn(`Relay tunnel: relay disconnected, cleaning relay proxy state (${reason})`);
+        proxy?.cleanupRelayState();
       });
+      proxy.startGatewayConnection();
       abortController = new AbortController;
       client.connectWithAutoReconnect(abortController.signal).catch((err2) => {
         releaseLock();
@@ -14692,7 +15823,7 @@ function createTunnelService(opts) {
 }
 
 // src/profile/auth/base-apikey.ts
-function stripBearer(apiKey) {
+function stripBearer2(apiKey) {
   return apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
 }
 
@@ -14710,7 +15841,7 @@ class BaseApiKeyAuthProvider {
     if (!apiKey) {
       throw new Error(`apiKey 未设置，请先执行 ntf auth set-api-key <apiKey>（或 ${credentialsPath()}）`);
     }
-    const raw = stripBearer(apiKey);
+    const raw = stripBearer2(apiKey);
     return {
       query: { apiKey: raw },
       headers: { "X-Api-Key-Id": raw }
@@ -14737,11 +15868,11 @@ class ArkclawAuthProvider extends BaseApiKeyAuthProvider {
 // src/profile/auth/jvsclaw.ts
 var import_node_crypto6 = require("node:crypto");
 var import_node_os3 = __toESM(require("node:os"));
-var import_node_fs33 = require("node:fs");
-var import_node_path30 = require("node:path");
+var import_node_fs35 = require("node:fs");
+var import_node_path32 = require("node:path");
 var CLAW_CODE = "JvsClaw";
-var RETRY_BASE_MS = 2000;
-var RETRY_MAX_MS = 60000;
+var RETRY_BASE_MS2 = 2000;
+var RETRY_MAX_MS2 = 60000;
 var FATAL_READY_CODES = new Set([
   "54016",
   "54017",
@@ -14749,7 +15880,7 @@ var FATAL_READY_CODES = new Set([
   "54020",
   "54024"
 ]);
-var JVSCLAW_LINK_SECRET_CONFIG_PATH = import_node_path30.join(DEFAULT_JVSCLAW_STATE_DIR, "openclaw.json");
+var JVSCLAW_LINK_SECRET_CONFIG_PATH = import_node_path32.join(DEFAULT_JVSCLAW_STATE_DIR, "openclaw.json");
 var PLUGIN_ID3 = "phone-notifications";
 var LINK_SECRET_WATCH_DEBOUNCE_MS = 250;
 
@@ -14802,7 +15933,7 @@ class JvsclawAuthProvider extends BaseApiKeyAuthProvider {
           logger.error(`jvsclaw auth: 置换失败且不可恢复（code=${err2.code}）: ${err2.message}，停止轮询`);
           return;
         }
-        const delayMs = Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS);
+        const delayMs = Math.min(RETRY_BASE_MS2 * 2 ** (attempt - 1), RETRY_MAX_MS2);
         logger.warn(`jvsclaw auth: 置换失败（attempt ${attempt}）: ${err2?.message ?? String(err2)}，${delayMs}ms 后重试`);
         const aborted = await sleep2(delayMs, abortSignal);
         if (aborted)
@@ -14861,8 +15992,8 @@ class JvsclawAuthProvider extends BaseApiKeyAuthProvider {
   watch(onChange) {
     const unwatchCredentials = super.watch(onChange);
     const configPath = resolveConfigPath();
-    const configDir = import_node_path30.dirname(configPath);
-    const configFile = import_node_path30.basename(configPath);
+    const configDir = import_node_path32.dirname(configPath);
+    const configFile = import_node_path32.basename(configPath);
     let debounceTimer = null;
     let configWatcher = null;
     const emitChange = () => {
@@ -14875,7 +16006,7 @@ class JvsclawAuthProvider extends BaseApiKeyAuthProvider {
       debounceTimer.unref?.();
     };
     try {
-      configWatcher = import_node_fs33.watch(configDir, { persistent: false }, (_event, changedName) => {
+      configWatcher = import_node_fs35.watch(configDir, { persistent: false }, (_event, changedName) => {
         if (!changedName)
           return;
         const name = String(changedName);
@@ -14900,7 +16031,7 @@ function hashLinkSecret(value) {
 function readJvsclawLinkSecretFromConfigFile(configPath = resolveConfigPath()) {
   let config;
   try {
-    config = JSON.parse(import_node_fs33.readFileSync(configPath, "utf-8"));
+    config = JSON.parse(import_node_fs35.readFileSync(configPath, "utf-8"));
   } catch {
     return;
   }
@@ -14948,17 +16079,51 @@ function resolveAuthProvider(deps) {
   }
 }
 
+// src/plugin/register-guard.ts
+var DEFAULT_KEY = "__default__";
+var wiredRuntimes = new Map;
+function normalizeKey(key) {
+  return key && key.length > 0 ? key : DEFAULT_KEY;
+}
+function claimWiredRuntime(key, create) {
+  const normalized = normalizeKey(key);
+  const existing = wiredRuntimes.get(normalized);
+  if (existing) {
+    return { runtime: existing, firstAssembly: false };
+  }
+  const runtime = create();
+  wiredRuntimes.set(normalized, runtime);
+  return { runtime, firstAssembly: true };
+}
+function releaseWiredRuntime(key) {
+  wiredRuntimes.delete(normalizeKey(key));
+}
+
+// src/plugin/shared-storage.ts
+var DEFAULT_KEY2 = "__default__";
+var registry = new Map;
+function normalizeKey2(key) {
+  return key && key.length > 0 ? key : DEFAULT_KEY2;
+}
+function publishSharedStorage(key, handles) {
+  registry.set(normalizeKey2(key), handles);
+}
+function clearSharedStorage(key) {
+  registry.delete(normalizeKey2(key));
+}
+function getSharedNotificationStorage(key) {
+  return registry.get(normalizeKey2(key))?.storage ?? null;
+}
+function getSharedRecordingStorage(key) {
+  return registry.get(normalizeKey2(key))?.recordingStorage ?? null;
+}
+function getSharedImageStorage(key) {
+  return registry.get(normalizeKey2(key))?.imageStorage ?? null;
+}
+
 // src/plugin/lifecycle.ts
 function registerStorageLifecycle(deps) {
-  const {
-    api,
-    logger,
-    lightRuleCtx,
-    setStorage,
-    setRecordingStorage,
-    setImageStorage,
-    onStorageReady
-  } = deps;
+  const { api, logger, runtime, sharedStorageKey } = deps;
   let storage2 = null;
   let recordingStorage = null;
   let imageStorage = null;
@@ -14977,32 +16142,38 @@ function registerStorageLifecycle(deps) {
       const resolveDisplayName = appNameMapProvider.resolveDisplayName.bind(appNameMapProvider);
       storage2 = new NotificationStorage(storageDir, logger, resolveDisplayName);
       await storage2.init();
-      setStorage(storage2);
       logger.info(`通知存储服务已启动: ${storageDir}`);
       const recDir = resolveRecordingStorageDir(storageCtx, logger);
       recordingStorage = new RecordingStorage(recDir, logger);
       await recordingStorage.init();
-      setRecordingStorage(recordingStorage);
       logger.info(`录音存储服务已启动: ${recDir}`);
       const imageDir = resolveImageStorageDir(storageCtx, logger);
       imageStorage = new ImageStorage(imageDir, logger);
       await imageStorage.init();
-      setImageStorage(imageStorage);
       logger.info(`图片存储服务已启动: ${imageDir}`);
-      lightRuleCtx.workspaceDir = ctx.workspaceDir;
-      lightRuleCtx.stateDir = stateDir;
-      onStorageReady?.();
+      runtime.markStorageReady({
+        storage: storage2,
+        recordingStorage,
+        imageStorage,
+        workspaceDir: ctx.workspaceDir,
+        stateDir
+      });
+      publishSharedStorage(sharedStorageKey, {
+        storage: storage2,
+        recordingStorage,
+        imageStorage
+      });
     },
     async stop() {
+      runtime.markStorageStopped();
+      clearSharedStorage(sharedStorageKey);
+      releaseWiredRuntime(sharedStorageKey);
       await storage2?.close();
       storage2 = null;
-      setStorage(null);
       await recordingStorage?.close();
       recordingStorage = null;
-      setRecordingStorage(null);
       await imageStorage?.close();
       imageStorage = null;
-      setImageStorage(null);
       appNameMapProvider?.stop();
       appNameMapProvider = null;
       logger.info("通知/录音/图片存储服务已停止");
@@ -15014,7 +16185,7 @@ function readHostGatewayConfig(params) {
   let configData;
   if (configPath) {
     try {
-      configData = JSON.parse(import_node_fs34.readFileSync(configPath, "utf-8"));
+      configData = JSON.parse(import_node_fs36.readFileSync(configPath, "utf-8"));
     } catch (err2) {
       if (err2?.code !== "ENOENT") {
         params.logger.warn(`Relay tunnel: 无法读取 gateway 鉴权配置 (${configPath})`);
@@ -15094,7 +16265,20 @@ function registerRelayTunnelLifecycle(deps) {
     logger.info(`Relay tunnel: detected ${exclusiveTunnelHint} in host gateway config, skipping relay startup to keep ingress mutually exclusive`);
     return null;
   }
-  const gatewayPort = process.env.OPENCLAW_GATEWAY_PORT ?? process.env.QCLAW_GATEWAY_PORT ?? "18789";
+  const hostGatewayConfig = readHostGatewayConfig({
+    stateDir: openclawDir,
+    logger
+  });
+  const gatewayBaseUrl = resolveLocalGatewayBaseUrl({
+    config: hostGatewayConfig
+  });
+  if (gatewayBaseUrl.warning) {
+    logger.warn(`Relay tunnel: ${gatewayBaseUrl.warning}`);
+  }
+  if (gatewayBaseUrl.tlsEnabled && !gatewayBaseUrl.explicit) {
+    logger.warn("Relay tunnel: detected gateway.tls.enabled=true; local relay proxy still uses HTTP by default. If local RPC fails, set PHONE_NOTIFICATIONS_GATEWAY_BASE_URL=https://127.0.0.1:<port> or disable gateway TLS.");
+  }
+  logger.info(`Relay tunnel: local gateway base URL ${gatewayBaseUrl.baseUrl} (source=${gatewayBaseUrl.source})`);
   const { gatewayAuthMode, gatewayToken, gatewayPassword } = resolveLocalGatewayAuth({
     stateDir: openclawDir,
     logger
@@ -15105,7 +16289,7 @@ function registerRelayTunnelLifecycle(deps) {
     authProvider,
     heartbeatSec: config.relay?.heartbeatSec,
     reconnectBackoffMs: config.relay?.reconnectBackoffMs,
-    gatewayBaseUrl: `http://localhost:${gatewayPort}`,
+    gatewayBaseUrl: gatewayBaseUrl.baseUrl,
     gatewayAuthMode,
     gatewayToken,
     gatewayPassword,
@@ -15237,8 +16421,10 @@ function registerNotificationInterfaces(deps) {
     registerGatewayMethod,
     notifyNotificationSummaryStatus,
     notifyNotificationSummaryResult,
-    tunnelService
+    tunnelService,
+    agentToolsOnly = false
   } = deps;
+  const registerGatewayMethodForMode = agentToolsOnly ? () => {} : registerGatewayMethod;
   const summaryJobs = new Map;
   function pruneSummaryJobs() {
     while (summaryJobs.size > SUMMARY_JOB_HISTORY_LIMIT) {
@@ -15330,7 +16516,7 @@ function registerNotificationInterfaces(deps) {
   function resolveSummaryNotificationsDir() {
     return getStorage()?.getStorageDir() ?? summaryNotificationsDir ?? null;
   }
-  registerGatewayMethod("notifications.push", async ({ params, respond }) => {
+  registerGatewayMethodForMode("notifications.push", async ({ params, respond }) => {
     const storage2 = getStorage();
     if (!storage2) {
       respond(false, null, {
@@ -15358,7 +16544,7 @@ function registerNotificationInterfaces(deps) {
     logger.info(`notifications[${ingestId}]: ingest done in ${Date.now() - startMs}ms ` + `(received=${result.received} ingested=${result.ingested} ` + `dedupedById=${result.dedupedById} dedupedByContent=${result.dedupedByContent} invalid=${result.invalid})`);
     respond(true, toIngestResponse(result));
   });
-  registerGatewayMethod("notifications.summary.start", async ({ params, respond }) => {
+  registerGatewayMethodForMode("notifications.summary.start", async ({ params, respond }) => {
     const notificationsDir = resolveSummaryNotificationsDir();
     if (!notificationsDir) {
       respond(false, null, {
@@ -15390,7 +16576,7 @@ function registerNotificationInterfaces(deps) {
       });
     });
   });
-  registerGatewayMethod("notifications.summary.status", async ({ params, respond }) => {
+  registerGatewayMethodForMode("notifications.summary.status", async ({ params, respond }) => {
     const jobId = trimToUndefined2(params?.jobId);
     if (!jobId) {
       respond(false, null, {
@@ -15409,7 +16595,7 @@ function registerNotificationInterfaces(deps) {
     }
     respond(true, serializeSummaryJob(state));
   });
-  registerGatewayMethod("notifications.summary.result", async ({ params, respond }) => {
+  registerGatewayMethodForMode("notifications.summary.result", async ({ params, respond }) => {
     const jobId = trimToUndefined2(params?.jobId);
     if (!jobId) {
       respond(false, null, {
@@ -15558,6 +16744,10 @@ function registerNotificationInterfaces(deps) {
       }
     }
   });
+  if (agentToolsOnly) {
+    logger.info("Agent 通知工具已注册: notifications_summary");
+    return;
+  }
   api.registerHttpRoute({
     path: "/notifications",
     auth: "gateway",
@@ -15991,6 +17181,76 @@ function registerImageInterfaces(deps) {
   logger.info("HTTP 图片端点已注册: POST /images");
 }
 
+// src/system/os-info.ts
+var import_node_fs37 = require("node:fs");
+var import_node_os4 = __toESM(require("node:os"));
+function defaultReadProcVersion() {
+  try {
+    return import_node_fs37.readFileSync("/proc/version", "utf-8");
+  } catch {
+    return null;
+  }
+}
+function detectWsl(release, env, readProcVersion) {
+  const distro = env.WSL_DISTRO_NAME?.trim() || null;
+  const hasWslEnv = Boolean(env.WSL_DISTRO_NAME || env.WSL_INTEROP);
+  const haystacks = [release, readProcVersion() ?? ""].map((value) => value.toLowerCase());
+  const kernelHit = haystacks.some((value) => value.includes("microsoft") || value.includes("wsl"));
+  if (!hasWslEnv && !kernelHit) {
+    return null;
+  }
+  const isWsl2 = Boolean(env.WSL_INTEROP) || haystacks.some((value) => value.includes("wsl2"));
+  const version = isWsl2 ? 2 : kernelHit || hasWslEnv ? 1 : null;
+  return { version, distro };
+}
+function detectOsInfo(probe = {}) {
+  const platform = probe.platform ?? import_node_os4.default.platform();
+  const arch = probe.arch ?? import_node_os4.default.arch();
+  const release = probe.release ?? import_node_os4.default.release();
+  const env = probe.env ?? process.env;
+  const readProcVersion = probe.readProcVersion ?? defaultReadProcVersion;
+  if (platform === "win32") {
+    return { os: "windows", isWsl: false, platform, arch, release };
+  }
+  if (platform === "darwin") {
+    return { os: "macos", isWsl: false, platform, arch, release };
+  }
+  if (platform === "linux") {
+    const wsl = detectWsl(release, env, readProcVersion);
+    if (wsl) {
+      return { os: "wsl", isWsl: true, platform, arch, release, wsl };
+    }
+    return { os: "linux", isWsl: false, platform, arch, release };
+  }
+  return { os: "unknown", isWsl: false, platform, arch, release };
+}
+
+// src/plugin/system.ts
+function buildOsResponse() {
+  return detectOsInfo();
+}
+function registerSystemInterfaces(deps) {
+  const { api, logger, registerGatewayMethod } = deps;
+  registerGatewayMethod("system.os", async ({ respond }) => {
+    respond(true, buildOsResponse());
+  });
+  api.registerHttpRoute({
+    path: "/system/os",
+    auth: "gateway",
+    async handler(req, res) {
+      if (req.method !== "GET") {
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Method Not Allowed" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, ...buildOsResponse() }));
+    }
+  });
+  logger.info("Gateway 系统方法已注册: system.os");
+  logger.info("HTTP 系统端点已注册: GET /system/os");
+}
+
 // src/plugin/runtime-mode.ts
 var PLUGIN_CLI_COMMANDS = new Set(["ntf", "phone-notifications"]);
 var GLOBAL_OPTIONS_WITH_VALUE = [
@@ -16025,15 +17285,94 @@ function isPluginCliInvocation(argv = process.argv) {
   return primaryCommand ? PLUGIN_CLI_COMMANDS.has(primaryCommand) : false;
 }
 
+// src/plugin/runtime.ts
+class PluginRuntime {
+  logger;
+  lightRuleCtx;
+  tunnelService = null;
+  storage = null;
+  recordingStorage = null;
+  imageStorage = null;
+  broadcastFn = null;
+  storageReady = false;
+  storageReadyListeners = [];
+  broadcastChangedListeners = [];
+  constructor(logger, stateDir) {
+    this.logger = logger;
+    this.lightRuleCtx = { stateDir };
+  }
+  getStorage() {
+    return this.storage;
+  }
+  getRecordingStorage() {
+    return this.recordingStorage;
+  }
+  getImageStorage() {
+    return this.imageStorage;
+  }
+  getBroadcastFn() {
+    return this.broadcastFn;
+  }
+  markStorageReady(params) {
+    this.storage = params.storage;
+    this.recordingStorage = params.recordingStorage;
+    this.imageStorage = params.imageStorage;
+    this.lightRuleCtx.workspaceDir = params.workspaceDir;
+    this.lightRuleCtx.stateDir = params.stateDir;
+    this.storageReady = true;
+    this.emitAll(this.storageReadyListeners, "onStorageReady");
+  }
+  markStorageStopped() {
+    this.storage = null;
+    this.recordingStorage = null;
+    this.imageStorage = null;
+    this.storageReady = false;
+  }
+  onStorageReady(listener) {
+    this.storageReadyListeners.push(listener);
+    if (this.storageReady) {
+      this.emitOne(listener, "onStorageReady");
+    }
+  }
+  cacheBroadcast(broadcast) {
+    if (!broadcast) {
+      return;
+    }
+    const changed = this.broadcastFn !== broadcast;
+    this.broadcastFn = broadcast;
+    if (changed) {
+      this.emitAll(this.broadcastChangedListeners, "onBroadcastChanged");
+    }
+  }
+  onBroadcastChanged(listener) {
+    this.broadcastChangedListeners.push(listener);
+    if (this.broadcastFn) {
+      this.emitOne(listener, "onBroadcastChanged");
+    }
+  }
+  emitAll(listeners, name) {
+    for (const listener of listeners) {
+      this.emitOne(listener, name);
+    }
+  }
+  emitOne(listener, name) {
+    try {
+      listener();
+    } catch (err2) {
+      this.logger.warn(`PluginRuntime: ${name} listener failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+  }
+}
+
 // src/index.ts
 
 var LIGHT_RULE_PROMPT_GUIDANCE = [
-  "灯效规则路由提示：",
+  "灯效路由提示：",
   `- 当用户表达“收到/当/如果/有某类通知或消息时，亮灯/闪灯/变成某种灯效”时，这是云端持久灯效规则请求，必须调用 ${LIGHT_RULE_TOOL_NAMES.create} 或 ${LIGHT_RULE_TOOL_NAMES.update}。`,
+  "- 当用户要求现在/立即亮灯，或在当前一次性任务完成后亮灯时，必须调用 light_control；不要创建灯效规则。",
   "- 创建规则时把用户的自然语言诉求整理成 ruleText；由 Notification Intelligence Service 的独立 Agent 编译和保存规则。",
   "- 灯效规则的创建、修改、删除和查询都走 lightrules_* 工具；不要手写或编辑 tasks/*/meta.json。",
-  "- 如果 lightrules_* 工具返回错误，必须如实说明本次查询/修改失败；不要使用聊天历史或旧 toolResult 里的规则列表冒充当前云端结果。",
-  "- 插件不再提供 OpenClaw 层的一次性 light_control，下发、评估和亮灯原因由云端服务处理。"
+  "- 如果 lightrules_* 工具返回错误，必须如实说明本次查询/修改失败；不要使用聊天历史或旧 toolResult 里的规则列表冒充当前云端结果。"
 ].join(`
 `);
 var src_default = {
@@ -16042,16 +17381,12 @@ var src_default = {
   register(api) {
     const config = api.pluginConfig ?? {};
     const ignoredApps = new Set(config.ignoredApps ?? []);
-    let storage2 = null;
-    let recordingStorage = null;
-    let imageStorage = null;
-    let broadcastFn = null;
-    let autoUpdateLifecycle = null;
-    let tunnelService = null;
     const openclawDir = resolvePluginStateDir(api);
     const logger = openclawDir ? new PluginFileLogger(api.logger, openclawDir) : createVersionAwareLogger(api.logger);
+    const registrationMode = api.registrationMode ?? "(unknown)";
+    logger.info(`register() 调用: registrationMode=${registrationMode} cliInvocation=${isPluginCliInvocation()}`);
     ensureNtfBinInstalled({
-      ntfCjsPath: import_node_path31.join(__dirname, "bin", "ntf.cjs"),
+      ntfCjsPath: import_node_path33.join(__dirname, "bin", "ntf.cjs"),
       stateDir: openclawDir,
       logger
     });
@@ -16063,19 +17398,10 @@ var src_default = {
       logger.info("检测到插件 CLI 命令执行上下文，仅注册 CLI，跳过后台服务以避免影响 Relay tunnel 常驻连接");
       return;
     }
+    const { runtime, firstAssembly } = claimWiredRuntime(openclawDir, () => new PluginRuntime(logger, openclawDir));
     api.on("before_prompt_build", () => ({
       appendSystemContext: LIGHT_RULE_PROMPT_GUIDANCE
     }));
-    function cacheBroadcast(broadcast) {
-      if (!broadcast) {
-        return;
-      }
-      const changed = broadcastFn !== broadcast;
-      broadcastFn = broadcast;
-      if (changed) {
-        autoUpdateLifecycle?.notifyBroadcastReady();
-      }
-    }
     function isDirectMobileGatewayRequest(opts) {
       const client = opts.client?.connect?.client;
       if (!client)
@@ -16086,18 +17412,18 @@ var src_default = {
       return client.id === "openclaw-ios" || client.id === "openclaw-android";
     }
     async function deactivateRelayForDirectGatewayRequest(method, opts) {
-      if (!tunnelService || !isDirectMobileGatewayRequest(opts))
+      if (!runtime.tunnelService || !isDirectMobileGatewayRequest(opts))
         return;
       const client = opts.client?.connect?.client;
       try {
-        await tunnelService.deactivateForExternalTunnel(`gateway method ${method} from ${client?.id ?? "unknown"}`);
+        await runtime.tunnelService.deactivateForExternalTunnel(`gateway method ${method} from ${client?.id ?? "unknown"}`);
       } catch (err2) {
         logger.warn(`Relay tunnel: failed to deactivate after direct gateway method ${method}: ${err2?.message ?? String(err2)}`);
       }
     }
     function registerGatewayMethodWithBroadcastCapture(method, handler) {
       api.registerGatewayMethod(method, async (opts) => {
-        cacheBroadcast(opts.context?.broadcast);
+        runtime.cacheBroadcast(opts.context?.broadcast);
         await deactivateRelayForDirectGatewayRequest(method, opts);
         return handler(opts);
       });
@@ -16106,7 +17432,8 @@ var src_default = {
       return items.filter((notification) => !ignoredApps.has(notification.app));
     }
     function notifyRecordingStatus(event) {
-      const relayEmitted = tunnelService?.emitEvent("recording.status", event) ?? false;
+      const relayEmitted = runtime.tunnelService?.emitEvent("recording.status", event) ?? false;
+      const broadcastFn = runtime.getBroadcastFn();
       if (!broadcastFn) {
         if (relayEmitted)
           return;
@@ -16116,7 +17443,8 @@ var src_default = {
       broadcastFn("recording.status", event);
     }
     function notifyNotificationSummaryStatus(event) {
-      const relayEmitted = tunnelService?.emitEvent(NOTIFICATION_SUMMARY_STATUS_EVENT, event) ?? false;
+      const relayEmitted = runtime.tunnelService?.emitEvent(NOTIFICATION_SUMMARY_STATUS_EVENT, event) ?? false;
+      const broadcastFn = runtime.getBroadcastFn();
       if (!broadcastFn) {
         if (relayEmitted)
           return;
@@ -16128,7 +17456,8 @@ var src_default = {
       broadcastFn(NOTIFICATION_SUMMARY_STATUS_EVENT, event);
     }
     function notifyNotificationSummaryResult(event) {
-      const relayEmitted = tunnelService?.emitEvent(NOTIFICATION_SUMMARY_RESULT_EVENT, event) ?? false;
+      const relayEmitted = runtime.tunnelService?.emitEvent(NOTIFICATION_SUMMARY_RESULT_EVENT, event) ?? false;
+      const broadcastFn = runtime.getBroadcastFn();
       if (!broadcastFn) {
         if (relayEmitted)
           return;
@@ -16140,28 +17469,36 @@ var src_default = {
       broadcastFn(NOTIFICATION_SUMMARY_RESULT_EVENT, event);
     }
     const lightRuleClient = new NotificationIntelligenceLightRuleClient({ logger });
-    const lightRuleCtx = {
-      stateDir: openclawDir
-    };
-    const lightRuleRegistry = new LightRuleRegistry(lightRuleCtx);
+    if (!firstAssembly) {
+      registerNotificationInterfaces({
+        api,
+        logger,
+        getStorage: () => runtime.getStorage() ?? getSharedNotificationStorage(openclawDir),
+        summaryNotificationsDir: getStateFallbackNotificationDir(openclawDir),
+        filterNotifications,
+        registerGatewayMethod: () => {},
+        notifyNotificationSummaryStatus,
+        notifyNotificationSummaryResult,
+        tunnelService: runtime.tunnelService,
+        agentToolsOnly: true
+      });
+      registerLightControlTool(api, logger);
+      registerLightRulesTools(api, lightRuleClient, logger);
+      registerAutoUpdateAgentTool({ api, config, logger });
+      logger.info(`register(): 本进程已完成后台装配（openclawDir=${openclawDir ?? "(default)"}），` + "已为当前 Agent collector 补注册工具，跳过重复后台 wiring");
+      return;
+    }
+    const lightRuleRegistry = new LightRuleRegistry(runtime.lightRuleCtx);
+    runtime.onStorageReady(() => {
+      lightRuleRegistry.reload();
+    });
     registerStorageLifecycle({
       api,
       logger,
-      lightRuleCtx,
-      setStorage(nextStorage) {
-        storage2 = nextStorage;
-      },
-      setRecordingStorage(nextRecordingStorage) {
-        recordingStorage = nextRecordingStorage;
-      },
-      setImageStorage(nextImageStorage) {
-        imageStorage = nextImageStorage;
-      },
-      onStorageReady() {
-        lightRuleRegistry.reload();
-      }
+      runtime,
+      sharedStorageKey: openclawDir
     });
-    tunnelService = registerRelayTunnelLifecycle({
+    runtime.tunnelService = registerRelayTunnelLifecycle({
       api,
       config,
       logger,
@@ -16170,41 +17507,48 @@ var src_default = {
     registerNotificationInterfaces({
       api,
       logger,
-      getStorage: () => storage2,
+      getStorage: () => runtime.getStorage() ?? getSharedNotificationStorage(openclawDir),
       summaryNotificationsDir: getStateFallbackNotificationDir(openclawDir),
       filterNotifications,
       registerGatewayMethod: registerGatewayMethodWithBroadcastCapture,
       notifyNotificationSummaryStatus,
       notifyNotificationSummaryResult,
-      tunnelService
+      tunnelService: runtime.tunnelService
     });
     registerRecordingInterfaces({
       api,
       logger,
-      getRecordingStorage: () => recordingStorage,
+      getRecordingStorage: () => runtime.getRecordingStorage() ?? getSharedRecordingStorage(openclawDir),
       notifyRecordingStatus,
       registerGatewayMethod: registerGatewayMethodWithBroadcastCapture,
-      tunnelService
+      tunnelService: runtime.tunnelService
     });
     registerImageInterfaces({
       api,
       logger,
-      getImageStorage: () => imageStorage,
+      getImageStorage: () => runtime.getImageStorage() ?? getSharedImageStorage(openclawDir),
       registerGatewayMethod: registerGatewayMethodWithBroadcastCapture,
       maxBytes: config.image?.maxBytes ?? 0,
-      tunnelService
+      tunnelService: runtime.tunnelService
+    });
+    registerSystemInterfaces({
+      api,
+      logger,
+      registerGatewayMethod: registerGatewayMethodWithBroadcastCapture
     });
-    registerLightRulesGateway(api, lightRuleRegistry, logger, cacheBroadcast);
+    registerLightControlTool(api, logger);
+    registerLightRulesGateway(api, lightRuleRegistry, logger, (broadcast) => runtime.cacheBroadcast(broadcast));
     registerLightRulesTools(api, lightRuleClient, logger);
     logger.info(`灯效规则方法已注册: gateway=${LIGHT_RULE_GATEWAY_METHOD_LIST.join(", ")}; tools=${LIGHT_RULE_TOOL_NAME_LIST.join(", ")}`);
-    autoUpdateLifecycle = registerAutoUpdateLifecycle({
+    const autoUpdateLifecycle = registerAutoUpdateLifecycle({
       api,
       config,
       logger,
-      getBroadcastFn: () => broadcastFn,
-      cacheBroadcast,
-      tunnelService
+      getBroadcastFn: () => runtime.getBroadcastFn(),
+      cacheBroadcast: (broadcast) => runtime.cacheBroadcast(broadcast),
+      tunnelService: runtime.tunnelService
     });
+    runtime.onBroadcastChanged(() => autoUpdateLifecycle.notifyBroadcastReady());
     registerPluginCli(api, {
       logger,
       openclawDir
@@ -16212,5 +17556,5 @@ var src_default = {
   }
 };
 
-//# debugId=1C4AEF73472B01C364756E2164756E21
+//# debugId=3D7085ABD8318D3264756E2164756E21
 //# sourceMappingURL=index.cjs.map