@yoooclaw/phone-notifications 1.11.4-beta.2 → 1.11.4-beta.4

package/dist/index.cjs

@@ -579,20 +579,20 @@ function selectModelByMemory(availableGB, isAppleSilicon = false) {
   return "tiny";
 }
 function resolveModelsDir(dataDir) {
-  const dir = (0, import_node_path21.join)(dataDir, WHISPER_MODELS_DIR);
-  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path20.join)(dataDir, WHISPER_MODELS_DIR);
+  (0, import_node_fs24.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function resolveBinDir(dataDir) {
-  const dir = (0, import_node_path21.join)(dataDir, WHISPER_BIN_DIR);
-  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path20.join)(dataDir, WHISPER_BIN_DIR);
+  (0, import_node_fs24.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function isModelDownloaded(modelsDir, modelSize) {
-  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
-  if (!(0, import_node_fs25.existsSync)(modelPath)) return false;
+  const modelPath = (0, import_node_path20.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  if (!(0, import_node_fs24.existsSync)(modelPath)) return false;
   try {
-    const stat = (0, import_node_fs25.statSync)(modelPath);
+    const stat = (0, import_node_fs24.statSync)(modelPath);
     const expectedSize = MODEL_DISK_SIZES[modelSize];
     return stat.size >= expectedSize * 0.8;
   } catch {
@@ -601,7 +601,7 @@ function isModelDownloaded(modelsDir, modelSize) {
 }
 async function downloadModel(modelsDir, modelSize, logger, modelSource, mirrorUrl) {
   const filename = MODEL_FILENAMES[modelSize];
-  const modelPath = (0, import_node_path21.join)(modelsDir, filename);
+  const modelPath = (0, import_node_path20.join)(modelsDir, filename);
   if (isModelDownloaded(modelsDir, modelSize)) {
     logger.info(`[whisper-local] \u6A21\u578B\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u4E0B\u8F7D: ${filename}`);
     return { ok: true, modelPath };
@@ -667,7 +667,7 @@ async function probeUrl(url, logger) {
 async function downloadFromUrl(url, modelPath, logger) {
   const tmpPath = `${modelPath}.downloading`;
   try {
-    (0, import_node_fs25.mkdirSync)((0, import_node_path21.dirname)(modelPath), { recursive: true });
+    (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(modelPath), { recursive: true });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 30 * 60 * 1e3);
     try {
@@ -683,7 +683,7 @@ async function downloadFromUrl(url, modelPath, logger) {
         return { ok: false, modelPath, error: "\u6A21\u578B\u4E0B\u8F7D\u5931\u8D25: \u54CD\u5E94\u4F53\u4E3A\u7A7A" };
       }
       const contentLength = Number(res.headers.get("content-length") ?? 0);
-      const writeStream = (0, import_node_fs25.createWriteStream)(tmpPath);
+      const writeStream = (0, import_node_fs24.createWriteStream)(tmpPath);
       const readable = import_node_stream2.Readable.fromWeb(res.body);
       let downloaded = 0;
       let lastLogPercent = 0;
@@ -705,14 +705,14 @@ async function downloadFromUrl(url, modelPath, logger) {
     }
     const { renameSync: renameSync2 } = await import("fs");
     renameSync2(tmpPath, modelPath);
-    const fileSize = (0, import_node_fs25.statSync)(modelPath).size;
+    const fileSize = (0, import_node_fs24.statSync)(modelPath).size;
     logger.info(
-      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path21.basename)(modelPath)} (${formatBytes2(fileSize)})`
+      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path20.basename)(modelPath)} (${formatBytes2(fileSize)})`
     );
     return { ok: true, modelPath };
   } catch (err2) {
     try {
-      if ((0, import_node_fs25.existsSync)(tmpPath)) (0, import_node_fs25.unlinkSync)(tmpPath);
+      if ((0, import_node_fs24.existsSync)(tmpPath)) (0, import_node_fs24.unlinkSync)(tmpPath);
     } catch {
     }
     const msg = err2?.name === "AbortError" ? "\u6A21\u578B\u4E0B\u8F7D\u8D85\u65F6\uFF0830 \u5206\u949F\uFF09" : err2?.message ?? String(err2);
@@ -724,8 +724,8 @@ function findWhisperBinary(dataDir, logger) {
   const binDir = resolveBinDir(dataDir);
   const binNames = (0, import_node_os4.platform)() === "win32" ? ["whisper-cli.exe", "whisper.exe", "main.exe"] : ["whisper-cli", "whisper", "main"];
   for (const name of binNames) {
-    const binPath = (0, import_node_path21.join)(binDir, name);
-    if ((0, import_node_fs25.existsSync)(binPath)) {
+    const binPath = (0, import_node_path20.join)(binDir, name);
+    if ((0, import_node_fs24.existsSync)(binPath)) {
       logger.info(`[whisper-local] \u627E\u5230\u672C\u5730\u4E8C\u8FDB\u5236: ${binPath}`);
       return binPath;
     }
@@ -776,7 +776,7 @@ async function transcribeWithWhisperLocal(audioFilePath, localConfig, dataDir, l
       return { ok: false, error: `\u6A21\u578B\u4E0B\u8F7D\u5931\u8D25: ${downloadResult.error}` };
     }
   }
-  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  const modelPath = (0, import_node_path20.join)(modelsDir, MODEL_FILENAMES[modelSize]);
   let inputPath = audioFilePath;
   let tmpWavPath = null;
   const actualFmt = detectAudioFormat(audioFilePath);
@@ -828,10 +828,10 @@ async function transcribeWithWhisperLocal(audioFilePath, localConfig, dataDir, l
     logger.info(`[whisper-local] \u8F6C\u5199\u8017\u65F6: ${Math.round(elapsed / 1e3)}s`);
     const jsonPath = inputPath + ".json";
     let jsonContent;
-    if ((0, import_node_fs25.existsSync)(jsonPath)) {
-      jsonContent = (0, import_node_fs25.readFileSync)(jsonPath, "utf-8");
+    if ((0, import_node_fs24.existsSync)(jsonPath)) {
+      jsonContent = (0, import_node_fs24.readFileSync)(jsonPath, "utf-8");
       try {
-        (0, import_node_fs25.unlinkSync)(jsonPath);
+        (0, import_node_fs24.unlinkSync)(jsonPath);
       } catch {
       }
     } else {
@@ -909,10 +909,10 @@ function getPhysicalCoreCount() {
 }
 function detectAudioFormat(filePath) {
   try {
-    const fd = (0, import_node_fs25.openSync)(filePath, "r");
+    const fd = (0, import_node_fs24.openSync)(filePath, "r");
     const buf = Buffer.alloc(12);
-    (0, import_node_fs25.readSync)(fd, buf, 0, 12, 0);
-    (0, import_node_fs25.closeSync)(fd);
+    (0, import_node_fs24.readSync)(fd, buf, 0, 12, 0);
+    (0, import_node_fs24.closeSync)(fd);
     const header = buf.toString("ascii", 0, 4);
     const header8 = buf.toString("ascii", 0, 8);
     if (header === "RIFF" && buf.toString("ascii", 8, 12) === "WAVE") return ".wav";
@@ -947,7 +947,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
       timeout: 12e4,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (ffmpegResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
+    if (ffmpegResult.status === 0 && (0, import_node_fs24.existsSync)(outputPath)) {
       logger.info(`[whisper-local] ffmpeg \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
       return { ok: true };
     }
@@ -960,7 +960,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
         ["--rate", "16000", "--mono", inputPath, outputPath],
         { encoding: "utf-8", timeout: 12e4, stdio: ["pipe", "pipe", "pipe"] }
       );
-      if (opusResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
+      if (opusResult.status === 0 && (0, import_node_fs24.existsSync)(outputPath)) {
         logger.info(`[whisper-local] opusdec \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
         return { ok: true };
       }
@@ -974,7 +974,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
     if (detectedExt && !inputPath.endsWith(detectedExt)) {
       tmpCopy = inputPath + ".detected" + detectedExt;
       try {
-        (0, import_node_fs25.copyFileSync)(inputPath, tmpCopy);
+        (0, import_node_fs24.copyFileSync)(inputPath, tmpCopy);
         actualInputPath = tmpCopy;
         logger.info(
           `[whisper-local] \u68C0\u6D4B\u5230\u5B9E\u9645\u683C\u5F0F ${detectedExt}\uFF0C\u4E34\u65F6\u91CD\u547D\u540D`
@@ -998,22 +998,22 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
         timeout: 12e4,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs24.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs25.unlinkSync)(tmpCopy);
+          (0, import_node_fs24.unlinkSync)(tmpCopy);
         } catch {
         }
       }
-      if (afResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
+      if (afResult.status === 0 && (0, import_node_fs24.existsSync)(outputPath)) {
         logger.info(`[whisper-local] afconvert \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
         return { ok: true };
       }
       const stderr = afResult.stderr?.slice(0, 200) ?? "";
       return { ok: false, error: `afconvert \u8F6C\u6362\u5931\u8D25 (exit ${afResult.status}): ${stderr}` };
     } catch (err2) {
-      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs24.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs25.unlinkSync)(tmpCopy);
+          (0, import_node_fs24.unlinkSync)(tmpCopy);
         } catch {
         }
       }
@@ -1024,9 +1024,9 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
   return { ok: false, error: `\u65E0\u6CD5\u5C06\u97F3\u9891\u8F6C\u6362\u4E3A WAV \u683C\u5F0F\u3002${fmtHint}` };
 }
 function cleanupTmpWav(path2) {
-  if (path2 && (0, import_node_fs25.existsSync)(path2)) {
+  if (path2 && (0, import_node_fs24.existsSync)(path2)) {
     try {
-      (0, import_node_fs25.unlinkSync)(path2);
+      (0, import_node_fs24.unlinkSync)(path2);
     } catch {
     }
   }
@@ -1112,13 +1112,13 @@ function formatBytes2(bytes) {
   if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
 }
-var import_node_child_process3, import_node_fs25, import_node_path21, import_promises3, import_node_stream2, import_node_os4, WHISPER_MODELS_DIR, WHISPER_BIN_DIR, HF_MODEL_URL_TEMPLATE, MODELSCOPE_MODEL_URL_TEMPLATE, PROBE_TIMEOUT_MS, MODEL_FILENAMES, MODEL_DISK_SIZES;
+var import_node_child_process3, import_node_fs24, import_node_path20, import_promises3, import_node_stream2, import_node_os4, WHISPER_MODELS_DIR, WHISPER_BIN_DIR, HF_MODEL_URL_TEMPLATE, MODELSCOPE_MODEL_URL_TEMPLATE, PROBE_TIMEOUT_MS, MODEL_FILENAMES, MODEL_DISK_SIZES;
 var init_whisper_local = __esm({
   "src/recording/whisper-local.ts"() {
     "use strict";
     import_node_child_process3 = require("child_process");
-    import_node_fs25 = require("fs");
-    import_node_path21 = require("path");
+    import_node_fs24 = require("fs");
+    import_node_path20 = require("path");
     import_promises3 = require("stream/promises");
     import_node_stream2 = require("stream");
     import_node_os4 = require("os");
@@ -1273,7 +1273,7 @@ async function initializeAsr(config, dataDir, logger) {
   }
 }
 async function transcribeAudio(audioFilePath, config, logger, options = {}) {
-  if (!(0, import_node_fs26.existsSync)(audioFilePath)) {
+  if (!(0, import_node_fs25.existsSync)(audioFilePath)) {
     return { ok: false, error: `\u97F3\u9891\u6587\u4EF6\u4E0D\u5B58\u5728: ${audioFilePath}` };
   }
   logger.info(
@@ -1419,8 +1419,8 @@ async function runTranscriptionWorkflow(params) {
     createdAt
   );
   const transcriptDataFilename = buildTranscriptDataFilename(recordingId);
-  const transcriptDataPath = (0, import_node_path22.join)(transcriptDataDir, transcriptDataFilename);
-  (0, import_node_fs26.writeFileSync)(
+  const transcriptDataPath = (0, import_node_path21.join)(transcriptDataDir, transcriptDataFilename);
+  (0, import_node_fs25.writeFileSync)(
     transcriptDataPath,
     JSON.stringify(transcriptData, null, 2),
     "utf-8"
@@ -1428,14 +1428,14 @@ async function runTranscriptionWorkflow(params) {
   logger.info(`[asr] \u8F6C\u5199 JSON \u5DF2\u5199\u5165: ${transcriptDataPath}`);
   const safeSummary = title.replace(/[/\\:*?"<>|]/g, "").trim().slice(0, 20);
   const filename = safeSummary ? `${recordingId}_${safeSummary}.md` : `${recordingId}.md`;
-  const filePath = (0, import_node_path22.join)(transcriptsDir, filename);
-  (0, import_node_fs26.writeFileSync)(filePath, markdown, "utf-8");
+  const filePath = (0, import_node_path21.join)(transcriptsDir, filename);
+  (0, import_node_fs25.writeFileSync)(filePath, markdown, "utf-8");
   logger.info(`[asr] \u8F6C\u5199\u6587\u672C\u5DF2\u5199\u5165: ${filePath}`);
   let summaryFilename;
   if (summary) {
     summaryFilename = `${recordingId}.md`;
-    const summaryFilePath = (0, import_node_path22.join)(summariesDir, summaryFilename);
-    (0, import_node_fs26.writeFileSync)(summaryFilePath, summary, "utf-8");
+    const summaryFilePath = (0, import_node_path21.join)(summariesDir, summaryFilename);
+    (0, import_node_fs25.writeFileSync)(summaryFilePath, summary, "utf-8");
     logger.info(`[asr] \u6458\u8981\u6587\u672C\u5DF2\u5199\u5165: ${summaryFilePath}`);
   }
   return {
@@ -1521,7 +1521,7 @@ async function transcribeWithModelProxy(audioOssUrl, audioDurationMs, apiConfig,
 }
 async function transcribeWithWhisperLocal2(audioFilePath, config, logger) {
   const { transcribeWithWhisperLocal: runLocal } = await Promise.resolve().then(() => (init_whisper_local(), whisper_local_exports));
-  const dataDir = process.env.OPENCLAW_STATE_DIR ?? process.env.QCLAW_STATE_DIR ?? (0, import_node_path22.join)(audioFilePath, "..", "..", "..");
+  const dataDir = process.env.OPENCLAW_STATE_DIR ?? process.env.QCLAW_STATE_DIR ?? (0, import_node_path21.join)(audioFilePath, "..", "..", "..");
   const localConfig = config.local ?? {};
   const result = await runLocal(
     audioFilePath,
@@ -1830,12 +1830,12 @@ function formatTranscriptSegmentText(segment) {
   }
   return text;
 }
-var import_node_fs26, import_node_path22, DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS, DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS, LONG_RECORDING_RUNNING_STATUSES, LONG_RECORDING_TERMINAL_FAILURE_STATUSES;
+var import_node_fs25, import_node_path21, DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS, DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS, LONG_RECORDING_RUNNING_STATUSES, LONG_RECORDING_TERMINAL_FAILURE_STATUSES;
 var init_asr = __esm({
   "src/recording/asr.ts"() {
     "use strict";
-    import_node_fs26 = require("fs");
-    import_node_path22 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path21 = require("path");
     init_credentials();
     init_env();
     init_transcript_document();
@@ -5480,7 +5480,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.11.4-beta.2".trim();
+  const version = "1.11.4-beta.4".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -7097,109 +7097,6 @@ function resolveLightTitle(title, reason, segments) {
   return `Effect: ${modeDesc || "custom"}`;
 }
 
-// src/light-rules/local-matcher.ts
-var CONTACT_PREFIXES = ["\u91CD\u8981\u8054\u7CFB\u4EBA", "\u8054\u7CFB\u4EBA"];
-var CONTACT_ACTION_RE = /(给我)?发(?:来)?消息|(给我)?发信息|来消息|回复(?:我)?|回应(?:我)?|私聊(?:我)?/u;
-var LEADING_SENDER_RE = /^(.{1,40}?)(?:\s+回应)?\s*[:：]/u;
-function matchNotificationsLocally(notifications, rules) {
-  const parsedRules = rules.map((rule) => parseContactRule(rule)).filter((item) => item !== null);
-  if (parsedRules.length === 0) {
-    return [];
-  }
-  const results = [];
-  notifications.forEach((notification, notificationIndex) => {
-    const senders = collectSenderCandidates(notification);
-    if (senders.length === 0) {
-      return;
-    }
-    parsedRules.forEach((rule) => {
-      if (senders.some((sender) => senderMatchesContact(sender, rule.contactName))) {
-        results.push({ notificationIndex, ruleName: rule.ruleName });
-      }
-    });
-  });
-  return results;
-}
-function parseContactRule(rule) {
-  const contactName = extractImportantContact(rule.description);
-  if (!contactName) {
-    return null;
-  }
-  return {
-    ruleName: rule.name,
-    contactName
-  };
-}
-function extractImportantContact(description) {
-  const text = description.trim();
-  if (!text) {
-    return null;
-  }
-  for (const prefix of CONTACT_PREFIXES) {
-    const start = text.indexOf(prefix);
-    if (start < 0) {
-      continue;
-    }
-    const tail = text.slice(start + prefix.length);
-    const actionMatch = CONTACT_ACTION_RE.exec(tail);
-    if (!actionMatch || actionMatch.index === 0) {
-      continue;
-    }
-    const rawName = tail.slice(0, actionMatch.index).trim();
-    const cleaned = trimContactName(rawName);
-    if (cleaned) {
-      return cleaned;
-    }
-  }
-  return null;
-}
-function trimContactName(value) {
-  const cleaned = value.replace(/^[是为叫做名为\s]+/u, "").replace(/[，。,.；;].*$/u, "").trim();
-  return cleaned || null;
-}
-function collectSenderCandidates(notification) {
-  const candidates = [
-    notification.senderName,
-    notification.title,
-    notification.conversationName,
-    extractLeadingSender(notification.content)
-  ];
-  const deduped = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    if (!candidate) {
-      continue;
-    }
-    const normalized = normalizeComparableName(candidate);
-    if (normalized.length < 2) {
-      continue;
-    }
-    deduped.set(normalized, candidate);
-  }
-  return Array.from(deduped.values());
-}
-function extractLeadingSender(content) {
-  const text = content.trim();
-  if (!text) {
-    return null;
-  }
-  const match = LEADING_SENDER_RE.exec(text);
-  if (!match) {
-    return null;
-  }
-  return match[1]?.trim() || null;
-}
-function senderMatchesContact(sender, contactName) {
-  const normalizedSender = normalizeComparableName(sender);
-  const normalizedContact = normalizeComparableName(contactName);
-  if (!normalizedSender || !normalizedContact) {
-    return false;
-  }
-  return normalizedSender.includes(normalizedContact) || normalizedContact.includes(normalizedSender);
-}
-function normalizeComparableName(value) {
-  return value.normalize("NFKC").replace(new RegExp("\\p{Extended_Pictographic}", "gu"), "").replace(/\s+/gu, "").replace(/[^\p{L}\p{N}]/gu, "");
-}
-
 // src/light-rules/inline-evaluator.ts
 var InlineLightRuleEvaluator = class {
   logger;
@@ -7219,40 +7116,8 @@ var InlineLightRuleEvaluator = class {
     if (notifications.length === 0) return true;
     const rules = this.registry.getEnabled();
     if (rules.length === 0) return true;
-    const localMatches = matchNotificationsLocally(notifications, rules);
-    const localMatchedRuleNames = new Set(localMatches.map((match) => match.ruleName));
-    const llmCandidateRules = rules.filter((rule) => !localMatchedRuleNames.has(rule.name));
-    const combinedMatches = /* @__PURE__ */ new Map();
-    for (const match of localMatches) {
-      combinedMatches.set(
-        `${match.notificationIndex}:${match.ruleName}`,
-        match
-      );
-    }
-    if (localMatches.length > 0) {
-      this.logger.info(
-        `lightrules: local matched ${localMatchedRuleNames.size} rule(s) (notifications=${notifications.length}, remainingRules=${llmCandidateRules.length})`
-      );
-    }
-    if (llmCandidateRules.length > 0) {
-      const llmMatches = await this.invoker.matchNotifications(notifications, llmCandidateRules);
-      if (llmMatches === null) {
-        if (combinedMatches.size === 0) {
-          return false;
-        }
-        this.logger.warn(
-          `lightrules: invoker failed; using ${combinedMatches.size} local fallback match(es)`
-        );
-      } else {
-        for (const match of llmMatches) {
-          combinedMatches.set(
-            `${match.notificationIndex}:${match.ruleName}`,
-            match
-          );
-        }
-      }
-    }
-    const matches = Array.from(combinedMatches.values());
+    const matches = await this.invoker.matchNotifications(notifications, rules);
+    if (matches === null) return false;
     if (matches.length === 0) {
       this.logger.info(
         `lightrules: 0 matches (notifications=${notifications.length}, rules=${rules.length})`
@@ -7465,15 +7330,35 @@ function buildSystemPrompt(rules) {
     lines.push("");
   });
   lines.push(
-    "\u4EFB\u52A1\uFF1A\u5BF9\u7528\u6237\u63A5\u4E0B\u6765\u53D1\u6765\u7684\u6BCF\u6761\u901A\u77E5\uFF0C\u5224\u65AD\u5B83\u547D\u4E2D\u4E86\u54EA\u4E9B\u89C4\u5219\u3002",
+    "\u5DE5\u4F5C\u6B65\u9AA4\uFF08\u5FC5\u987B\u6309\u987A\u5E8F\u6267\u884C\uFF09\uFF1A",
+    "",
+    "1. \u5148\u628A\u6BCF\u6761\u89C4\u5219\u6309 description \u5F52\u7C7B\uFF1A",
+    '   - \u53D1\u4EF6\u4EBA\u578B\uFF1A\u63CF\u8FF0\u91CC\u51FA\u73B0\u5177\u4F53\u4EBA\u540D/\u79F0\u8C13\uFF08\u542B"\u91CD\u8981\u8054\u7CFB\u4EBA X""\u8001\u5A46""\u5F20\u67D0\u67D0"\u7B49\uFF09+ "\u53D1\u6D88\u606F/\u6765\u6D88\u606F/\u56DE\u590D/\u79C1\u804A"\u7B49\u52A8\u4F5C',
+    "   - \u5173\u952E\u8BCD\u578B\uFF1A\u63CF\u8FF0\u8981\u6C42\u6D88\u606F\u4E2D\u5305\u542B\u7279\u5B9A\u5B57\u773C/\u8BDD\u9898",
+    "   - \u8BED\u4E49\u578B\uFF1A\u9700\u8981\u7406\u89E3\u6D88\u606F\u542B\u4E49\u624D\u80FD\u5224\u65AD\uFF08\u60C5\u7EEA\u3001\u610F\u56FE\u3001\u573A\u666F\u7B49\uFF09",
     "",
-    "\u8F93\u51FA\u5FC5\u987B\u662F\u7EAF JSON\uFF08\u4E0D\u8981 Markdown \u4EE3\u7801\u5757\u3001\u4E0D\u8981\u4EFB\u4F55\u89E3\u91CA\u6587\u5B57\uFF09\uFF1A",
+    "2. \u6309\u7C7B\u578B\u5224\u65AD\u6BCF\u6761\u901A\u77E5\u662F\u5426\u547D\u4E2D\uFF1A",
+    '   - \u53D1\u4EF6\u4EBA\u578B\uFF1A\u4F9D\u6B21\u6BD4\u5BF9 sender \u2192 conversation_name \u2192 title \u2192 content \u5F00\u5934\u7684 "X:"/"X\uFF1A" \u524D\u7F00\u3002',
+    "     \u6BD4\u8F83\u524D\u5148\u5F52\u4E00\u5316\uFF08NFKC\u3001\u53BB\u7A7A\u767D\u3001\u53BB emoji\u3001\u5FFD\u7565\u4E2D\u82F1\u6587\u6807\u70B9\u5DEE\u5F02\uFF09\u3002",
+    "     \u4EFB\u4E00\u5B57\u6BB5\u4E0E\u63CF\u8FF0\u4E2D\u7684\u4EBA\u540D\u4E92\u76F8\u5305\u542B\uFF08A \u662F B \u7684\u5B50\u4E32\u6216\u53CD\u4E4B\uFF09\u5373\u89C6\u4E3A\u547D\u4E2D\u3002",
+    '     \u4E0D\u8981\u6C42\u901A\u77E5\u91CC\u51FA\u73B0"\u91CD\u8981\u8054\u7CFB\u4EBA"\u7B49\u4FEE\u9970\u8BCD\uFF0C\u53EA\u8981\u540D\u5B57\u5BF9\u5F97\u4E0A\u5C31\u89E6\u53D1\u3002',
+    "   - \u5173\u952E\u8BCD\u578B\uFF1A\u5728 title + content \u4E2D\u67E5\u627E\u5173\u952E\u8BCD\uFF08\u540C\u6837\u5F52\u4E00\u5316\u540E\u6BD4\u8F83\uFF0C\u652F\u6301\u540C\u4E49/\u8FD1\u4E49\u5339\u914D\uFF09",
+    "   - \u8BED\u4E49\u578B\uFF1A\u7EFC\u5408\u7406\u89E3 title + content \u540E\u5224\u65AD\uFF1B\u8FD9\u4E00\u7C7B\u62FF\u4E0D\u51C6\u65F6\u503E\u5411\u4E8E\u4E0D\u89E6\u53D1",
+    "",
+    "3. \u8F93\u51FA JSON\u3002",
+    "",
+    "\u8F93\u51FA\u683C\u5F0F\uFF08\u7EAF JSON\uFF0C\u4E0D\u8981 Markdown \u4EE3\u7801\u5757\u3001\u4E0D\u8981\u4EFB\u4F55\u89E3\u91CA\u6587\u5B57\uFF09\uFF1A",
     '{"matches":[{"i":<\u901A\u77E5\u4E0B\u6807>,"rule":"<\u89C4\u5219name>"}]}',
     "",
     '- \u547D\u4E2D 0 \u6761 \u2192 \u8F93\u51FA {"matches":[]}',
-    "- \u4E00\u6761\u901A\u77E5\u53EF\u80FD\u547D\u4E2D\u591A\u6761\u89C4\u5219 \u2192 \u6BCF\u4E2A\u7EC4\u5408\u4E00\u4E2A\u6761\u76EE",
-    '- \u4E25\u683C\u6309\u89C4\u5219 description \u5224\u65AD\uFF0C\u62FF\u4E0D\u51C6\u65F6\u503E\u5411\u4E8E"\u4E0D\u89E6\u53D1"',
-    "- rule \u5FC5\u987B\u7CBE\u786E\u7B49\u4E8E\u4E0A\u9762\u5217\u51FA\u7684 name \u5B57\u7B26\u4E32"
+    "- \u4E00\u6761\u901A\u77E5\u53EF\u547D\u4E2D\u591A\u6761\u89C4\u5219 \u2192 \u6BCF\u4E2A\u7EC4\u5408\u4E00\u4E2A\u6761\u76EE",
+    "- rule \u5FC5\u987B\u7CBE\u786E\u7B49\u4E8E\u4E0A\u9762\u5217\u51FA\u7684 name \u5B57\u7B26\u4E32",
+    "",
+    "\u793A\u4F8B\uFF08\u4EC5\u4F9B\u53C2\u8003\u5339\u914D\u7B56\u7565\uFF0C\u4E0D\u4EE3\u8868\u5F53\u524D\u89C4\u5219\uFF09\uFF1A",
+    '  \u89C4\u5219 description: "\u91CD\u8981\u8054\u7CFB\u4EBA \u7814\u53D1\u5C0F\u52A9\u7406 \u53D1\u6D88\u606F\u65F6\u63D0\u9192"',
+    '    \u901A\u77E5 sender="\u7814\u53D1\u5C0F\u52A9\u7406\u{1F990}" \u2192 \u547D\u4E2D\uFF08\u53BB emoji \u540E\u540D\u5B57\u76F8\u540C\uFF09',
+    '    \u901A\u77E5 sender="\u674E\u56DB", content="\u7814\u53D1\u5C0F\u52A9\u7406 \u56DE\u5E94: \u6536\u5230" \u2192 \u547D\u4E2D\uFF08content \u5934\u90E8\u524D\u7F00\u5339\u914D\uFF09',
+    '    \u901A\u77E5 sender="\u738B\u4E94", content="\u7814\u53D1\u5C0F\u52A9\u7406\u8FD9\u4E2A\u4EA7\u54C1\u633A\u597D" \u2192 \u4E0D\u547D\u4E2D\uFF08\u540D\u5B57\u51FA\u73B0\u5728\u6B63\u6587\u4F46\u4E0D\u662F\u53D1\u4EF6\u4EBA\uFF09'
   );
   return lines.join("\n");
 }
@@ -7542,6 +7427,43 @@ function resolveUpdateChannel(params) {
 // src/update/index.ts
 var import_node_path8 = require("path");
 
+// src/plugin/runtime-state.ts
+init_host();
+
+// src/plugin/shared.ts
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function trimToUndefined2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+
+// src/plugin/runtime-state.ts
+function tryResolveRuntimeStateDir(api) {
+  const runtimeState = api?.runtime?.state;
+  const resolveStateDir2 = runtimeState?.resolveStateDir;
+  if (typeof resolveStateDir2 !== "function") {
+    return void 0;
+  }
+  try {
+    return trimToUndefined2(resolveStateDir2.call(runtimeState));
+  } catch {
+    return void 0;
+  }
+}
+function resolvePluginStateDir(api) {
+  return tryResolveRuntimeStateDir(api) ?? resolveStateDir();
+}
+
 // src/update/checker.ts
 function parseSemver(v) {
   const [main, pre = null] = v.split("-", 2);
@@ -7762,7 +7684,7 @@ function resolveTargetDir(api) {
     if (installPath) return installPath;
   } catch {
   }
-  return (0, import_node_path8.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
+  return (0, import_node_path8.join)(resolvePluginStateDir(api), "extensions", PLUGIN_ID);
 }
 async function updateConfigRecord(api, version, targetDir, tgzUrl) {
   const configApi = api.runtime.config;
@@ -7972,7 +7894,7 @@ function registerAutoUpdateLifecycle(deps) {
 }
 
 // src/plugin/cli.ts
-var import_node_path16 = require("path");
+var import_node_path15 = require("path");
 
 // src/cli/auth.ts
 var import_node_fs9 = require("fs");
@@ -8647,21 +8569,155 @@ function registerLightSetupTools(light) {
 }
 
 // src/cli/tunnel-status.ts
-var import_node_fs13 = require("fs");
-var import_node_path12 = require("path");
 init_credentials();
 init_env();
-var STATUS_REL_PATH = (0, import_node_path12.join)("plugins", "phone-notifications", "tunnel-status.json");
-function readTunnelStatus(ctx) {
-  if (!ctx.stateDir) return null;
-  const filePath = (0, import_node_path12.join)(ctx.stateDir, STATUS_REL_PATH);
-  if (!(0, import_node_fs13.existsSync)(filePath)) return null;
+
+// src/tunnel/status.ts
+var import_node_fs13 = require("fs");
+var import_node_path12 = require("path");
+var TUNNEL_STATUS_REL_PATH = (0, import_node_path12.join)(
+  "plugins",
+  "phone-notifications",
+  "tunnel-status.json"
+);
+var TUNNEL_LOCK_REL_PATH = (0, import_node_path12.join)(
+  "plugins",
+  "phone-notifications",
+  "relay-tunnel.lock"
+);
+function isTunnelState(value) {
+  return value === "connected" || value === "connecting" || value === "disconnected" || value === "stopped";
+}
+function isTunnelStatusInfo(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const obj = value;
+  return isTunnelState(obj.state) && typeof obj.since === "string" && typeof obj.reconnectAttempt === "number" && (obj.lastDisconnectReason === void 0 || typeof obj.lastDisconnectReason === "string");
+}
+function parseTunnelLockInfo(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const obj = value;
+  return typeof obj.pid === "number" && typeof obj.startedAt === "string" ? { pid: obj.pid, startedAt: obj.startedAt } : null;
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err2) {
+    return err2?.code === "EPERM";
+  }
+}
+function isStatusOlderThanLock(statusSince, lockStartedAt) {
+  const statusTs = Date.parse(statusSince);
+  const lockTs = Date.parse(lockStartedAt);
+  if (Number.isNaN(statusTs) || Number.isNaN(lockTs)) return false;
+  return statusTs + 1e3 < lockTs;
+}
+function staleStatusMessage(status, lock) {
+  const prefix = `\u96A7\u9053\u72B6\u6001\u6587\u4EF6\u663E\u793A\u5DF2\u8FDE\u63A5\uFF08\u81EA ${status.since}\uFF09`;
+  if (!lock.exists) {
+    return `${prefix}\uFF0C\u4F46\u672A\u627E\u5230\u672C\u5730\u8FD0\u884C\u9501\uFF0C\u72B6\u6001\u53EF\u80FD\u5DF2\u8FC7\u671F\u3002\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B\u3002`;
+  }
+  if (lock.pid === null || lock.startedAt === null) {
+    return `${prefix}\uFF0C\u4F46\u672C\u5730\u8FD0\u884C\u9501\u5185\u5BB9\u4E0D\u5B8C\u6574\uFF0C\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D\u8FDE\u63A5\u662F\u5426\u4ECD\u7136\u6709\u6548\u3002\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B\u3002`;
+  }
+  if (lock.active === false) {
+    return `${prefix}\uFF0C\u4F46\u672C\u5730\u8FD0\u884C\u9501\u4ECD\u6307\u5411\u5DF2\u9000\u51FA\u7684\u8FDB\u7A0B pid=${lock.pid}\uFF0C\u72B6\u6001\u53EF\u80FD\u5DF2\u8FC7\u671F\u3002\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B\u3002`;
+  }
+  return `${prefix}\uFF0C\u4F46\u5F53\u524D\u8FD0\u884C\u9501\u542F\u52A8\u4E8E ${lock.startedAt}\uFF0C\u665A\u4E8E\u72B6\u6001\u65F6\u95F4\uFF0C\u8BF4\u660E\u72B6\u6001\u672A\u968F\u65B0\u8FDB\u7A0B\u5237\u65B0\u3002\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B\u3002`;
+}
+function assessTunnelStatus(stateDir) {
+  const statusFilePath = (0, import_node_path12.join)(stateDir, TUNNEL_STATUS_REL_PATH);
+  const lockFilePath = (0, import_node_path12.join)(stateDir, TUNNEL_LOCK_REL_PATH);
+  if (!(0, import_node_fs13.existsSync)(statusFilePath)) {
+    return {
+      status: null,
+      issueCode: "STATUS_NOT_FOUND",
+      issueMessage: "\u672A\u627E\u5230\u96A7\u9053\u72B6\u6001\u6587\u4EF6\uFF0C\u96A7\u9053\u670D\u52A1\u53EF\u80FD\u5C1A\u672A\u542F\u52A8\u8FC7\u3002\u8BF7\u786E\u8BA4 openclaw \u4E3B\u8FDB\u7A0B\u6B63\u5728\u8FD0\u884C\u3002",
+      statusFilePath,
+      lockFilePath,
+      lock: {
+        exists: (0, import_node_fs13.existsSync)(lockFilePath),
+        pid: null,
+        startedAt: null,
+        active: null
+      }
+    };
+  }
+  let rawStatus;
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)(filePath, "utf-8"));
+    rawStatus = JSON.parse((0, import_node_fs13.readFileSync)(statusFilePath, "utf-8"));
   } catch {
-    return null;
+    return {
+      status: null,
+      issueCode: "STATUS_INVALID",
+      issueMessage: "\u96A7\u9053\u72B6\u6001\u6587\u4EF6\u89E3\u6790\u5931\u8D25\uFF0C\u6587\u4EF6\u5185\u5BB9\u635F\u574F\u6216\u683C\u5F0F\u4E0D\u6B63\u786E\u3002\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B\u3002",
+      statusFilePath,
+      lockFilePath,
+      lock: {
+        exists: (0, import_node_fs13.existsSync)(lockFilePath),
+        pid: null,
+        startedAt: null,
+        active: null
+      }
+    };
+  }
+  if (!isTunnelStatusInfo(rawStatus)) {
+    return {
+      status: null,
+      issueCode: "STATUS_INVALID",
+      issueMessage: "\u96A7\u9053\u72B6\u6001\u6587\u4EF6\u7F3A\u5C11\u5FC5\u8981\u5B57\u6BB5\u6216\u5B57\u6BB5\u7C7B\u578B\u4E0D\u6B63\u786E\u3002\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B\u3002",
+      statusFilePath,
+      lockFilePath,
+      lock: {
+        exists: (0, import_node_fs13.existsSync)(lockFilePath),
+        pid: null,
+        startedAt: null,
+        active: null
+      }
+    };
   }
+  const status = rawStatus;
+  const lockExists = (0, import_node_fs13.existsSync)(lockFilePath);
+  let lockInfo = null;
+  if (lockExists) {
+    try {
+      lockInfo = parseTunnelLockInfo(JSON.parse((0, import_node_fs13.readFileSync)(lockFilePath, "utf-8")));
+    } catch {
+      lockInfo = null;
+    }
+  }
+  const lock = {
+    exists: lockExists,
+    pid: lockInfo?.pid ?? null,
+    startedAt: lockInfo?.startedAt ?? null,
+    active: lockInfo ? isProcessAlive(lockInfo.pid) : null
+  };
+  if (status.state === "connected") {
+    const isStale = !lock.exists || lock.pid === null || lock.startedAt === null || lock.active === false || isStatusOlderThanLock(status.since, lock.startedAt);
+    if (isStale) {
+      return {
+        status,
+        issueCode: "STATUS_STALE",
+        issueMessage: staleStatusMessage(status, lock),
+        statusFilePath,
+        lockFilePath,
+        lock
+      };
+    }
+  }
+  return {
+    status,
+    issueCode: null,
+    issueMessage: null,
+    statusFilePath,
+    lockFilePath,
+    lock
+  };
 }
+
+// src/cli/tunnel-status.ts
 function formatMessage(status) {
   switch (status.state) {
     case "connected":
@@ -8692,13 +8748,23 @@ function registerTunnelStatus(ntf, ctx) {
         "API Key \u672A\u8BBE\u7F6E\uFF0C\u96A7\u9053\u65E0\u6CD5\u8FDE\u63A5\u3002\u8BF7\u6267\u884C openclaw ntf auth set-api-key <apiKey>"
       );
     }
-    const status = readTunnelStatus(ctx);
+    if (!ctx.stateDir) {
+      exitError(
+        "STATE_DIR_UNAVAILABLE",
+        "\u65E0\u6CD5\u786E\u5B9A\u72B6\u6001\u76EE\u5F55\uFF0C\u65E0\u6CD5\u68C0\u67E5\u96A7\u9053\u72B6\u6001\u3002\u8BF7\u5728 openclaw \u4E3B\u73AF\u5883\u4E2D\u6267\u884C\u8BE5\u547D\u4EE4\u3002"
+      );
+    }
+    const assessment = assessTunnelStatus(ctx.stateDir);
+    const status = assessment.status;
     if (!status) {
       exitError(
-        "STATUS_NOT_FOUND",
-        "\u672A\u627E\u5230\u96A7\u9053\u72B6\u6001\u6587\u4EF6\uFF0C\u96A7\u9053\u670D\u52A1\u53EF\u80FD\u5C1A\u672A\u542F\u52A8\u8FC7\u3002\u8BF7\u786E\u8BA4 openclaw \u4E3B\u8FDB\u7A0B\u6B63\u5728\u8FD0\u884C\u3002"
+        assessment.issueCode ?? "STATUS_NOT_FOUND",
+        assessment.issueMessage ?? "\u672A\u627E\u5230\u96A7\u9053\u72B6\u6001\u6587\u4EF6\uFF0C\u96A7\u9053\u670D\u52A1\u53EF\u80FD\u5C1A\u672A\u542F\u52A8\u8FC7\u3002\u8BF7\u786E\u8BA4 openclaw \u4E3B\u8FDB\u7A0B\u6B63\u5728\u8FD0\u884C\u3002"
       );
     }
+    if (assessment.issueCode) {
+      exitError(assessment.issueCode, assessment.issueMessage ?? formatMessage(status));
+    }
     const ok2 = status.state === "connected";
     output({
       ok: ok2,
@@ -8709,6 +8775,11 @@ function registerTunnelStatus(ntf, ctx) {
         reconnectAttempt: status.reconnectAttempt,
         lastDisconnectReason: status.lastDisconnectReason
       },
+      runtime: {
+        lockOwnerPid: assessment.lock.pid,
+        lockOwnerStartedAt: assessment.lock.startedAt,
+        lockOwnerActive: assessment.lock.active
+      },
       message: formatMessage(status)
     });
     if (!ok2) process.exit(1);
@@ -8888,7 +8959,7 @@ function registerEnvCli(ntf, deps = {}) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs18 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_readline = require("readline");
 init_host();
 
@@ -9037,39 +9108,40 @@ var checkCredentials = () => {
 };
 
 // src/cli/doctor/check-tunnel.ts
-var import_node_fs17 = require("fs");
-var import_node_path14 = require("path");
-var STATUS_REL_PATH2 = (0, import_node_path14.join)(
-  "plugins",
-  "phone-notifications",
-  "tunnel-status.json"
-);
 var checkTunnel = ({ stateDir }) => {
-  const filePath = (0, import_node_path14.join)(stateDir, STATUS_REL_PATH2);
-  if (!(0, import_node_fs17.existsSync)(filePath)) {
+  const assessment = assessTunnelStatus(stateDir);
+  const status = assessment.status;
+  if (assessment.issueCode === "STATUS_NOT_FOUND") {
     return {
       id: "tunnel",
       severity: "warn",
       title: "\u96A7\u9053\u72B6\u6001\u6587\u4EF6\u4E0D\u5B58\u5728",
-      detail: "\u96A7\u9053\u670D\u52A1\u53EF\u80FD\u5C1A\u672A\u542F\u52A8\u8FC7\uFF0C\u6216\u72B6\u6001\u6587\u4EF6\u5DF2\u88AB\u5220\u9664\u3002",
+      detail: assessment.issueMessage ?? "\u96A7\u9053\u670D\u52A1\u53EF\u80FD\u5C1A\u672A\u542F\u52A8\u8FC7\uFF0C\u6216\u72B6\u6001\u6587\u4EF6\u5DF2\u88AB\u5220\u9664\u3002",
       fixDescription: "\u8BF7\u786E\u8BA4 openclaw \u4E3B\u8FDB\u7A0B\u6B63\u5728\u8FD0\u884C",
       fix: null
     };
   }
-  let status;
-  try {
-    status = JSON.parse((0, import_node_fs17.readFileSync)(filePath, "utf-8"));
-  } catch {
+  if (assessment.issueCode === "STATUS_INVALID") {
     return {
       id: "tunnel",
       severity: "warn",
       title: "\u96A7\u9053\u72B6\u6001\u6587\u4EF6\u89E3\u6790\u5931\u8D25",
-      detail: "\u6587\u4EF6\u5185\u5BB9\u635F\u574F\u6216\u683C\u5F0F\u4E0D\u6B63\u786E\u3002",
+      detail: assessment.issueMessage ?? "\u6587\u4EF6\u5185\u5BB9\u635F\u574F\u6216\u683C\u5F0F\u4E0D\u6B63\u786E\u3002",
       fixDescription: "\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B",
       fix: null
     };
   }
-  if (status.state === "connected") return null;
+  if (assessment.issueCode === "STATUS_STALE") {
+    return {
+      id: "tunnel",
+      severity: "warn",
+      title: "\u96A7\u9053\u72B6\u6001\u5DF2\u8FC7\u671F",
+      detail: assessment.issueMessage ?? "\u96A7\u9053\u72B6\u6001\u6587\u4EF6\u4ECD\u663E\u793A\u5DF2\u8FDE\u63A5\uFF0C\u4F46\u8FD0\u884C\u65F6\u72B6\u6001\u5DF2\u5931\u6548\u3002",
+      fixDescription: "\u8BF7\u91CD\u542F openclaw \u4E3B\u8FDB\u7A0B",
+      fix: null
+    };
+  }
+  if (!status || status.state === "connected") return null;
   const reasonSuffix = status.lastDisconnectReason ? `\uFF0C\u539F\u56E0: ${status.lastDisconnectReason}` : "";
   return {
     id: "tunnel",
@@ -9151,9 +9223,9 @@ function isObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function readConfig(configPath) {
-  if (!(0, import_node_fs18.existsSync)(configPath)) return {};
+  if (!(0, import_node_fs17.existsSync)(configPath)) return {};
   try {
-    const parsed = JSON.parse((0, import_node_fs18.readFileSync)(configPath, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(configPath, "utf-8"));
     return isObject5(parsed) ? parsed : {};
   } catch {
     return {};
@@ -9356,7 +9428,7 @@ function registerRecStoragePath(rec, ctx) {
 
 // src/cli/rec-setup.ts
 var import_node_readline2 = require("readline");
-var import_node_fs19 = require("fs");
+var import_node_fs18 = require("fs");
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
@@ -9442,9 +9514,9 @@ async function setupLocal(rl) {
 function registerRecSetup(rec, ctx) {
   rec.command("setup").description("\u4EA4\u4E92\u5F0F\u914D\u7F6E ASR \u8F6C\u5199\u53C2\u6570\uFF0C\u4FDD\u5B58\u5230\u672C\u5730\u914D\u7F6E\u6587\u4EF6").action(async () => {
     const configPath = resolveAsrConfigPath(ctx);
-    if ((0, import_node_fs19.existsSync)(configPath)) {
+    if ((0, import_node_fs18.existsSync)(configPath)) {
       try {
-        const existing = JSON.parse((0, import_node_fs19.readFileSync)(configPath, "utf-8"));
+        const existing = JSON.parse((0, import_node_fs18.readFileSync)(configPath, "utf-8"));
         process.stderr.write(`\u5F53\u524D\u5DF2\u6709\u914D\u7F6E\uFF1Amode = ${existing.mode}`);
         if (existing.updatedAt) process.stderr.write(`\uFF0C\u66F4\u65B0\u4E8E ${existing.updatedAt}`);
         process.stderr.write("\n");
@@ -9457,7 +9529,7 @@ function registerRecSetup(rec, ctx) {
       const modeIdx = await askChoice(rl, "\u9009\u62E9\u6A21\u5F0F", ["api\uFF08\u4E91\u7AEF model-proxy \u957F\u5F55\u97F3\uFF09", "local\uFF08\u672C\u5730 Whisper\uFF09"]);
       const config = modeIdx === 0 ? await setupApi(rl) : await setupLocal(rl);
       const stored = { ...config, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      (0, import_node_fs19.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
+      (0, import_node_fs18.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
       process.stderr.write(`
 \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${configPath}
 
@@ -9471,8 +9543,8 @@ function registerRecSetup(rec, ctx) {
 
 // src/cli/update.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs20 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs19 = require("fs");
+var import_node_path14 = require("path");
 var import_node_os3 = __toESM(require("os"), 1);
 init_host();
 var BASE_URL2 = "https://artifact.yoooclaw.com/plugin";
@@ -9531,9 +9603,9 @@ async function runUpdate(ctx, opts) {
 `);
     process.exit(1);
   }
-  const tmpScript = (0, import_node_path15.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
+  const tmpScript = (0, import_node_path14.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
   try {
-    (0, import_node_fs20.writeFileSync)(tmpScript, installScript, "utf-8");
+    (0, import_node_fs19.writeFileSync)(tmpScript, installScript, "utf-8");
   } catch (err2) {
     const msg = `\u5199\u5165\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${err2?.message ?? String(err2)}`;
     if (json) {
@@ -9551,7 +9623,7 @@ async function runUpdate(ctx, opts) {
     { stdio: "inherit" }
   );
   try {
-    (0, import_node_fs20.unlinkSync)(tmpScript);
+    (0, import_node_fs19.unlinkSync)(tmpScript);
   } catch {
   }
   if (result.error) {
@@ -9615,17 +9687,17 @@ function inferOpenClawRootDir(workspaceDir) {
   if (!workspaceDir) {
     return void 0;
   }
-  if ((0, import_node_path16.basename)(workspaceDir) !== "workspace") {
+  if ((0, import_node_path15.basename)(workspaceDir) !== "workspace") {
     return void 0;
   }
-  return (0, import_node_path16.dirname)(workspaceDir);
+  return (0, import_node_path15.dirname)(workspaceDir);
 }
 function registerPluginCli(api, params) {
   const { logger, openclawDir } = params;
   const registerAlias = (command) => {
     api.registerCli(
       (ctx) => {
-        const effectiveStateDir = openclawDir ?? inferOpenClawRootDir(ctx.workspaceDir);
+        const effectiveStateDir = openclawDir ?? ctx.stateDir ?? inferOpenClawRootDir(ctx.workspaceDir);
         registerAllCli(
           ctx.program,
           {
@@ -9869,12 +9941,12 @@ function registerLightControlTool(api, logger) {
 }
 
 // src/plugin/lifecycle.ts
-var import_node_fs30 = require("fs");
+var import_node_fs29 = require("fs");
 init_host();
 
 // src/notification/app-name-map.ts
-var import_node_fs21 = require("fs");
-var import_node_path17 = require("path");
+var import_node_fs20 = require("fs");
+var import_node_path16 = require("path");
 init_credentials();
 init_env();
 var PLUGIN_STATE_DIR = "phone-notifications";
@@ -9895,7 +9967,7 @@ function isAppNameMapApiResponse(v) {
   );
 }
 function getCachePath(stateDir) {
-  return (0, import_node_path17.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+  return (0, import_node_path16.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
 }
 function createAppNameMapProvider(opts) {
   const { stateDir, logger } = opts;
@@ -9907,9 +9979,9 @@ function createAppNameMapProvider(opts) {
   let inFlightFetch = null;
   function loadFromDisk() {
     const path2 = getCachePath(stateDir);
-    if (!(0, import_node_fs21.existsSync)(path2)) return;
+    if (!(0, import_node_fs20.existsSync)(path2)) return;
     try {
-      const raw = JSON.parse((0, import_node_fs21.readFileSync)(path2, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs20.readFileSync)(path2, "utf-8"));
       if (!isRecordOfStrings(raw)) return;
       map.clear();
       for (const [k, v] of Object.entries(raw)) map.set(k, v);
@@ -9953,10 +10025,10 @@ function createAppNameMapProvider(opts) {
         logger.warn("[app-name-map] refresh succeeded but got 0 entries");
         return;
       }
-      const dir = (0, import_node_path17.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
-      (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_node_path16.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
+      (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
       const cachePath = getCachePath(stateDir);
-      (0, import_node_fs21.writeFileSync)(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      (0, import_node_fs20.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);
@@ -10000,9 +10072,9 @@ function createAppNameMapProvider(opts) {
 }
 
 // src/notification/storage.ts
-var import_node_fs22 = require("fs");
+var import_node_fs21 = require("fs");
 var import_node_crypto2 = require("crypto");
-var import_node_path18 = require("path");
+var import_node_path17 = require("path");
 
 // src/notification/feishu-normalize.ts
 function normalizeOptionalText(value) {
@@ -10130,7 +10202,7 @@ var NOTIFICATION_DIR_NAME = "notifications";
 var ID_INDEX_DIR_NAME = ".ids";
 var CONTENT_KEY_INDEX_DIR_NAME = ".keys";
 function getStateFallbackNotificationDir(stateDir) {
-  return (0, import_node_path18.join)(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
+  return (0, import_node_path17.join)(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
 }
 function buildFallbackContent(n) {
   const body = n.body?.trim();
@@ -10148,8 +10220,8 @@ function buildFallbackContent(n) {
 }
 function ensureWritableDirectory(dir) {
   try {
-    (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs22.accessSync)(dir, import_node_fs22.constants.R_OK | import_node_fs22.constants.W_OK);
+    (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs21.accessSync)(dir, import_node_fs21.constants.R_OK | import_node_fs21.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -10162,7 +10234,7 @@ function resolveNotificationStorageDir(ctx, logger) {
     return stateNotifDir;
   }
   if (ctx.workspaceDir) {
-    const workspaceDir = (0, import_node_path18.join)(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
+    const workspaceDir = (0, import_node_path17.join)(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
     if (ensureWritableDirectory(workspaceDir)) {
       logger.warn(
         `stateDir \u4E0D\u53EF\u7528\uFF0C\u901A\u77E5\u5DF2\u56DE\u9000\u5230 workspace \u8DEF\u5F84: ${workspaceDir}`
@@ -10177,8 +10249,8 @@ var NotificationStorage = class {
     this.config = config;
     this.logger = logger;
     this.dir = dir;
-    this.idIndexDir = (0, import_node_path18.join)(dir, ID_INDEX_DIR_NAME);
-    this.contentKeyIndexDir = (0, import_node_path18.join)(dir, CONTENT_KEY_INDEX_DIR_NAME);
+    this.idIndexDir = (0, import_node_path17.join)(dir, ID_INDEX_DIR_NAME);
+    this.contentKeyIndexDir = (0, import_node_path17.join)(dir, CONTENT_KEY_INDEX_DIR_NAME);
     this.resolveDisplayName = resolveDisplayName;
   }
   dir;
@@ -10189,10 +10261,10 @@ var NotificationStorage = class {
   dateWriteChains = /* @__PURE__ */ new Map();
   resolveDisplayName;
   async init() {
-    (0, import_node_fs22.mkdirSync)(this.dir, { recursive: true });
-    (0, import_node_fs22.mkdirSync)(this.idIndexDir, { recursive: true });
-    (0, import_node_fs22.rmSync)(this.contentKeyIndexDir, { recursive: true, force: true });
-    (0, import_node_fs22.mkdirSync)(this.contentKeyIndexDir, { recursive: true });
+    (0, import_node_fs21.mkdirSync)(this.dir, { recursive: true });
+    (0, import_node_fs21.mkdirSync)(this.idIndexDir, { recursive: true });
+    (0, import_node_fs21.rmSync)(this.contentKeyIndexDir, { recursive: true, force: true });
+    (0, import_node_fs21.mkdirSync)(this.contentKeyIndexDir, { recursive: true });
   }
   async ingest(items) {
     const result = {
@@ -10231,7 +10303,7 @@ var NotificationStorage = class {
       return { kind: "invalid" };
     }
     const dateKey = this.formatDate(ts);
-    const filePath = (0, import_node_path18.join)(this.dir, `${dateKey}.json`);
+    const filePath = (0, import_node_path17.join)(this.dir, `${dateKey}.json`);
     const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
     const entry = this.buildStoredNotification(n);
     return this.withDateWriteLock(dateKey, async () => {
@@ -10248,7 +10320,7 @@ var NotificationStorage = class {
       };
       const arr = this.readStoredNotifications(filePath);
       arr.push(storedEntry);
-      (0, import_node_fs22.writeFileSync)(filePath, JSON.stringify(arr, null, 2), "utf-8");
+      (0, import_node_fs21.writeFileSync)(filePath, JSON.stringify(arr, null, 2), "utf-8");
       if (normalizedId) {
         this.recordNotificationId(dateKey, normalizedId);
       }
@@ -10282,7 +10354,7 @@ var NotificationStorage = class {
     return `${year}-${month}-${day}`;
   }
   getIdIndexPath(dateKey) {
-    return (0, import_node_path18.join)(this.idIndexDir, `${dateKey}.ids`);
+    return (0, import_node_path17.join)(this.idIndexDir, `${dateKey}.ids`);
   }
   getIdSet(dateKey) {
     const cached = this.idCache.get(dateKey);
@@ -10291,8 +10363,8 @@ var NotificationStorage = class {
     }
     const idPath = this.getIdIndexPath(dateKey);
     const ids = /* @__PURE__ */ new Set();
-    if ((0, import_node_fs22.existsSync)(idPath)) {
-      const lines = (0, import_node_fs22.readFileSync)(idPath, "utf-8").split(/\r?\n/);
+    if ((0, import_node_fs21.existsSync)(idPath)) {
+      const lines = (0, import_node_fs21.readFileSync)(idPath, "utf-8").split(/\r?\n/);
       for (const line of lines) {
         const id = line.trim();
         if (id) {
@@ -10307,7 +10379,7 @@ var NotificationStorage = class {
     return this.getIdSet(dateKey).has(id);
   }
   getContentKeyIndexPath(dateKey) {
-    return (0, import_node_path18.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
+    return (0, import_node_path17.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
   }
   getContentKeySet(dateKey, filePath) {
     const cached = this.contentKeyCache.get(dateKey);
@@ -10316,16 +10388,16 @@ var NotificationStorage = class {
     }
     const keyPath = this.getContentKeyIndexPath(dateKey);
     const keys = /* @__PURE__ */ new Set();
-    if ((0, import_node_fs22.existsSync)(filePath)) {
+    if ((0, import_node_fs21.existsSync)(filePath)) {
       for (const item of this.readStoredNotifications(filePath)) {
         keys.add(this.buildNotificationContentKey(item));
       }
     }
     if (keys.size > 0) {
-      (0, import_node_fs22.writeFileSync)(keyPath, `${Array.from(keys).join("\n")}
+      (0, import_node_fs21.writeFileSync)(keyPath, `${Array.from(keys).join("\n")}
 `, "utf-8");
-    } else if ((0, import_node_fs22.existsSync)(keyPath)) {
-      (0, import_node_fs22.rmSync)(keyPath, { force: true });
+    } else if ((0, import_node_fs21.existsSync)(keyPath)) {
+      (0, import_node_fs21.rmSync)(keyPath, { force: true });
     }
     this.contentKeyCache.set(dateKey, keys);
     return keys;
@@ -10340,7 +10412,7 @@ var NotificationStorage = class {
     if (ids.has(id)) {
       return;
     }
-    (0, import_node_fs22.appendFileSync)(this.getIdIndexPath(dateKey), `${id}
+    (0, import_node_fs21.appendFileSync)(this.getIdIndexPath(dateKey), `${id}
 `, "utf-8");
     ids.add(id);
   }
@@ -10350,7 +10422,7 @@ var NotificationStorage = class {
     if (keys.has(key)) {
       return;
     }
-    (0, import_node_fs22.appendFileSync)(this.getContentKeyIndexPath(dateKey), `${key}
+    (0, import_node_fs21.appendFileSync)(this.getContentKeyIndexPath(dateKey), `${key}
 `, "utf-8");
     keys.add(key);
   }
@@ -10358,11 +10430,11 @@ var NotificationStorage = class {
     return (0, import_node_crypto2.createHash)("sha256").update(entry.appName).update("").update(entry.title).update("").update(entry.content).update("").update(entry.timestamp).digest("hex");
   }
   readStoredNotifications(filePath) {
-    if (!(0, import_node_fs22.existsSync)(filePath)) {
+    if (!(0, import_node_fs21.existsSync)(filePath)) {
       return [];
     }
     try {
-      const parsed = JSON.parse((0, import_node_fs22.readFileSync)(filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs21.readFileSync)(filePath, "utf-8"));
       return Array.isArray(parsed) ? parsed : [];
     } catch {
       return [];
@@ -10402,14 +10474,14 @@ var NotificationStorage = class {
     const dateFilePattern = /^(\d{4}-\d{2}-\d{2})\.(json|md)$/;
     const dateDirPattern = /^\d{4}-\d{2}-\d{2}$/;
     try {
-      for (const entry of (0, import_node_fs22.readdirSync)(this.dir, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs21.readdirSync)(this.dir, { withFileTypes: true })) {
         if (entry.isFile()) {
           const match = dateFilePattern.exec(entry.name);
           if (match && match[1] < cutoffDate) {
-            (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.name), { force: true });
+            (0, import_node_fs21.rmSync)((0, import_node_path17.join)(this.dir, entry.name), { force: true });
           }
         } else if (entry.isDirectory() && dateDirPattern.test(entry.name) && entry.name < cutoffDate) {
-          (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.name), { recursive: true, force: true });
+          (0, import_node_fs21.rmSync)((0, import_node_path17.join)(this.dir, entry.name), { recursive: true, force: true });
         }
       }
     } catch {
@@ -10418,11 +10490,11 @@ var NotificationStorage = class {
   /** Remove expired .ids index files */
   pruneIdIndex(cutoffDate) {
     try {
-      for (const entry of (0, import_node_fs22.readdirSync)(this.idIndexDir, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs21.readdirSync)(this.idIndexDir, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         const match = /^(\d{4}-\d{2}-\d{2})\.ids$/.exec(entry.name);
         if (match && match[1] < cutoffDate) {
-          (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.idIndexDir, entry.name), { force: true });
+          (0, import_node_fs21.rmSync)((0, import_node_path17.join)(this.idIndexDir, entry.name), { force: true });
           this.idCache.delete(match[1]);
         }
       }
@@ -10431,11 +10503,11 @@ var NotificationStorage = class {
   }
   pruneContentKeyIndex(cutoffDate) {
     try {
-      for (const entry of (0, import_node_fs22.readdirSync)(this.contentKeyIndexDir, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs21.readdirSync)(this.contentKeyIndexDir, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         const match = /^(\d{4}-\d{2}-\d{2})\.keys$/.exec(entry.name);
         if (match && match[1] < cutoffDate) {
-          (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.contentKeyIndexDir, entry.name), { force: true });
+          (0, import_node_fs21.rmSync)((0, import_node_path17.join)(this.contentKeyIndexDir, entry.name), { force: true });
           this.contentKeyCache.delete(match[1]);
         }
       }
@@ -10450,8 +10522,8 @@ var NotificationStorage = class {
 };
 
 // src/recording/storage.ts
-var import_node_fs23 = require("fs");
-var import_node_path19 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path18 = require("path");
 
 // src/recording/state-machine.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -10513,7 +10585,7 @@ function stripMarkdownFence(markdown) {
 }
 function deriveTitleFromTranscriptPath(transcriptFile, recordingId) {
   if (!transcriptFile) return void 0;
-  const name = (0, import_node_path19.basename)(transcriptFile, ".md");
+  const name = (0, import_node_path18.basename)(transcriptFile, ".md");
   const prefix = `${recordingId}_`;
   if (name.startsWith(prefix)) {
     const derived = name.slice(prefix.length).trim();
@@ -10541,22 +10613,22 @@ function extractTranscriptContent(markdown) {
   return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 function resolveRecordingStorageDir(ctx, logger) {
-  const stateRecDir = (0, import_node_path19.join)(
+  const stateRecDir = (0, import_node_path18.join)(
     ctx.stateDir,
     "plugins",
     "phone-notifications",
     RECORDINGS_DIR
   );
   try {
-    (0, import_node_fs23.mkdirSync)(stateRecDir, { recursive: true });
+    (0, import_node_fs22.mkdirSync)(stateRecDir, { recursive: true });
     logger.info(`\u5F55\u97F3\u5C06\u5199\u5165 stateDir \u8DEF\u5F84: ${stateRecDir}`);
     return stateRecDir;
   } catch {
   }
   if (ctx.workspaceDir) {
-    const wsRecDir = (0, import_node_path19.join)(ctx.workspaceDir, RECORDINGS_DIR);
+    const wsRecDir = (0, import_node_path18.join)(ctx.workspaceDir, RECORDINGS_DIR);
     try {
-      (0, import_node_fs23.mkdirSync)(wsRecDir, { recursive: true });
+      (0, import_node_fs22.mkdirSync)(wsRecDir, { recursive: true });
       logger.warn(`stateDir \u4E0D\u53EF\u7528\uFF0C\u5F55\u97F3\u5DF2\u56DE\u9000\u5230 workspace \u8DEF\u5F84: ${wsRecDir}`);
       return wsRecDir;
     } catch {
@@ -10568,11 +10640,11 @@ var RecordingStorage = class {
   constructor(dir, logger) {
     this.logger = logger;
     this.dir = dir;
-    this.audioDir = (0, import_node_path19.join)(dir, AUDIO_DIR);
-    this.transcriptDataDir = (0, import_node_path19.join)(dir, TRANSCRIPT_DATA_DIR);
-    this.transcriptsDir = (0, import_node_path19.join)(dir, TRANSCRIPTS_DIR);
-    this.summariesDir = (0, import_node_path19.join)(dir, SUMMARIES_DIR);
-    this.indexPath = (0, import_node_path19.join)(dir, INDEX_FILE);
+    this.audioDir = (0, import_node_path18.join)(dir, AUDIO_DIR);
+    this.transcriptDataDir = (0, import_node_path18.join)(dir, TRANSCRIPT_DATA_DIR);
+    this.transcriptsDir = (0, import_node_path18.join)(dir, TRANSCRIPTS_DIR);
+    this.summariesDir = (0, import_node_path18.join)(dir, SUMMARIES_DIR);
+    this.indexPath = (0, import_node_path18.join)(dir, INDEX_FILE);
   }
   dir;
   audioDir;
@@ -10583,10 +10655,10 @@ var RecordingStorage = class {
   index = { recordings: [] };
   /** 初始化目录结构并加载索引 */
   async init() {
-    (0, import_node_fs23.mkdirSync)(this.audioDir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.transcriptDataDir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.transcriptsDir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.summariesDir, { recursive: true });
+    (0, import_node_fs22.mkdirSync)(this.audioDir, { recursive: true });
+    (0, import_node_fs22.mkdirSync)(this.transcriptDataDir, { recursive: true });
+    (0, import_node_fs22.mkdirSync)(this.transcriptsDir, { recursive: true });
+    (0, import_node_fs22.mkdirSync)(this.summariesDir, { recursive: true });
     this.loadIndex();
     this.logger.info(
       `\u5F55\u97F3\u5B58\u50A8\u5DF2\u521D\u59CB\u5316: ${this.dir}\uFF08\u5171 ${this.index.recordings.length} \u6761\u8BB0\u5F55\uFF09`
@@ -10630,13 +10702,13 @@ var RecordingStorage = class {
         return id;
       }
       if (existing.transcriptDataFile) {
-        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptDataFile), { force: true });
+        (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, existing.transcriptDataFile), { force: true });
       }
       if (existing.transcriptFile) {
-        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptFile), { force: true });
+        (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, existing.transcriptFile), { force: true });
       }
       if (existing.summaryFile) {
-        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.summaryFile), { force: true });
+        (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, existing.summaryFile), { force: true });
       }
       existing.metadata = metadata;
       existing.status = "syncing_openclaw";
@@ -10705,7 +10777,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptDataFile = `${TRANSCRIPT_DATA_DIR}/${filename}`;
     if (entry.transcriptDataFile && entry.transcriptDataFile !== nextTranscriptDataFile) {
-      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptDataFile), { force: true });
+      (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.transcriptDataFile), { force: true });
     }
     entry.transcriptDataFile = nextTranscriptDataFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10719,7 +10791,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptFile = `${TRANSCRIPTS_DIR}/${filename}`;
     if (entry.transcriptFile && entry.transcriptFile !== nextTranscriptFile) {
-      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptFile), { force: true });
+      (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.transcriptFile), { force: true });
     }
     entry.transcriptFile = nextTranscriptFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10733,7 +10805,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextSummaryFile = `${SUMMARIES_DIR}/${filename}`;
     if (entry.summaryFile && entry.summaryFile !== nextSummaryFile) {
-      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.summaryFile), { force: true });
+      (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.summaryFile), { force: true });
     }
     entry.summaryFile = nextSummaryFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10841,24 +10913,24 @@ var RecordingStorage = class {
     const entry = this.findById(recordingId);
     if (!entry) return false;
     if (entry.audioFile) {
-      const audioPath = (0, import_node_path19.join)(this.dir, entry.audioFile);
-      (0, import_node_fs23.rmSync)(audioPath, { force: true });
+      const audioPath = (0, import_node_path18.join)(this.dir, entry.audioFile);
+      (0, import_node_fs22.rmSync)(audioPath, { force: true });
     }
     if (entry.srtFile) {
-      const srtPath = (0, import_node_path19.join)(this.dir, entry.srtFile);
-      (0, import_node_fs23.rmSync)(srtPath, { force: true });
+      const srtPath = (0, import_node_path18.join)(this.dir, entry.srtFile);
+      (0, import_node_fs22.rmSync)(srtPath, { force: true });
     }
     if (entry.transcriptDataFile) {
-      const transcriptDataPath = (0, import_node_path19.join)(this.dir, entry.transcriptDataFile);
-      (0, import_node_fs23.rmSync)(transcriptDataPath, { force: true });
+      const transcriptDataPath = (0, import_node_path18.join)(this.dir, entry.transcriptDataFile);
+      (0, import_node_fs22.rmSync)(transcriptDataPath, { force: true });
     }
     if (entry.transcriptFile) {
-      const transcriptPath = (0, import_node_path19.join)(this.dir, entry.transcriptFile);
-      (0, import_node_fs23.rmSync)(transcriptPath, { force: true });
+      const transcriptPath = (0, import_node_path18.join)(this.dir, entry.transcriptFile);
+      (0, import_node_fs22.rmSync)(transcriptPath, { force: true });
     }
     if (entry.summaryFile) {
-      const summaryPath = (0, import_node_path19.join)(this.dir, entry.summaryFile);
-      (0, import_node_fs23.rmSync)(summaryPath, { force: true });
+      const summaryPath = (0, import_node_path18.join)(this.dir, entry.summaryFile);
+      (0, import_node_fs22.rmSync)(summaryPath, { force: true });
     }
     if (opts?.localOnly) {
       entry.audioFile = void 0;
@@ -10916,34 +10988,34 @@ var RecordingStorage = class {
    * 获取音频文件的绝对路径。ossUrl 用于推断文件扩展名
    */
   getAudioFilePath(recordingId, ossUrl) {
-    return (0, import_node_path19.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
+    return (0, import_node_path18.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
   }
   /**
    * 获取打点文件的绝对路径
    */
   getSrtFilePath(recordingId) {
-    return (0, import_node_path19.join)(this.audioDir, this.buildSrtFilename(recordingId));
+    return (0, import_node_path18.join)(this.audioDir, this.buildSrtFilename(recordingId));
   }
   /**
    * 获取转写 JSON 文件的绝对路径
    */
   getTranscriptDataFilePath(recordingId) {
-    return (0, import_node_path19.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
+    return (0, import_node_path18.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
   }
   /**
    * 获取摘要文件的绝对路径
    */
   getSummaryFilePath(recordingId) {
-    return (0, import_node_path19.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
+    return (0, import_node_path18.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
   }
   // ─── Persistence ───
   loadIndex() {
-    if (!(0, import_node_fs23.existsSync)(this.indexPath)) {
+    if (!(0, import_node_fs22.existsSync)(this.indexPath)) {
       this.index = { recordings: [] };
       return;
     }
     try {
-      const raw = JSON.parse((0, import_node_fs23.readFileSync)(this.indexPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs22.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) => {
@@ -10981,8 +11053,8 @@ var RecordingStorage = class {
                 segments: []
               });
               const transcriptDataFilename = this.buildTranscriptDataFilename(compacted.id);
-              (0, import_node_fs23.writeFileSync)(
-                (0, import_node_path19.join)(this.transcriptDataDir, transcriptDataFilename),
+              (0, import_node_fs22.writeFileSync)(
+                (0, import_node_path18.join)(this.transcriptDataDir, transcriptDataFilename),
                 JSON.stringify(transcriptDoc, null, 2),
                 "utf-8"
               );
@@ -10994,8 +11066,8 @@ var RecordingStorage = class {
             compacted.summaryFile = entry.summaryFile;
           } else if (typeof entry.summary === "string" && entry.summary.trim()) {
             const summaryFilename = this.buildSummaryFilename(entry.id);
-            (0, import_node_fs23.writeFileSync)(
-              (0, import_node_path19.join)(this.summariesDir, summaryFilename),
+            (0, import_node_fs22.writeFileSync)(
+              (0, import_node_path18.join)(this.summariesDir, summaryFilename),
               entry.summary.trim(),
               "utf-8"
             );
@@ -11005,8 +11077,8 @@ var RecordingStorage = class {
             const summaryFromDocument = extractTranscriptSummaryFromDocument(transcriptDoc);
             if (summaryFromDocument) {
               const summaryFilename = this.buildSummaryFilename(entry.id);
-              (0, import_node_fs23.writeFileSync)(
-                (0, import_node_path19.join)(this.summariesDir, summaryFilename),
+              (0, import_node_fs22.writeFileSync)(
+                (0, import_node_path18.join)(this.summariesDir, summaryFilename),
                 summaryFromDocument,
                 "utf-8"
               );
@@ -11049,7 +11121,7 @@ var RecordingStorage = class {
   }
   readRelativeTextFile(relativePath) {
     try {
-      return (0, import_node_fs23.readFileSync)((0, import_node_path19.join)(this.dir, relativePath), "utf-8");
+      return (0, import_node_fs22.readFileSync)((0, import_node_path18.join)(this.dir, relativePath), "utf-8");
     } catch {
       return void 0;
     }
@@ -11062,7 +11134,7 @@ var RecordingStorage = class {
     return parseTranscriptDocument(raw);
   }
   saveIndex() {
-    (0, import_node_fs23.writeFileSync)(
+    (0, import_node_fs22.writeFileSync)(
       this.indexPath,
       JSON.stringify(this.index, null, 2),
       "utf-8"
@@ -11076,8 +11148,8 @@ var RecordingStorage = class {
 init_transcript_document();
 
 // src/recording/downloader.ts
-var import_node_fs24 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path19 = require("path");
 var import_promises2 = require("stream/promises");
 var import_node_stream = require("stream");
 var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
@@ -11087,7 +11159,7 @@ async function downloadFile(url, destPath, logger, options) {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
   const retryBackoffMs = options?.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
-  (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(destPath), { recursive: true });
+  (0, import_node_fs23.mkdirSync)((0, import_node_path19.dirname)(destPath), { recursive: true });
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     const startMs = Date.now();
@@ -11105,11 +11177,11 @@ async function downloadFile(url, destPath, logger, options) {
         if (!res.body) {
           throw new Error("\u54CD\u5E94\u4F53\u4E3A\u7A7A");
         }
-        const writeStream = (0, import_node_fs24.createWriteStream)(destPath);
+        const writeStream = (0, import_node_fs23.createWriteStream)(destPath);
         const readable = import_node_stream.Readable.fromWeb(res.body);
         await (0, import_promises2.pipeline)(readable, writeStream);
         const elapsed = Date.now() - startMs;
-        const fileSize = (0, import_node_fs24.existsSync)(destPath) ? (0, import_node_fs24.statSync)(destPath).size : 0;
+        const fileSize = (0, import_node_fs23.existsSync)(destPath) ? (0, import_node_fs23.statSync)(destPath).size : 0;
         logger.info(
           `[downloader] \u4E0B\u8F7D\u5B8C\u6210: ${destPath} (${formatBytes(fileSize)}, ${elapsed}ms)`
         );
@@ -11120,7 +11192,7 @@ async function downloadFile(url, destPath, logger, options) {
     } catch (err2) {
       lastError = err2?.message ?? String(err2);
       try {
-        if ((0, import_node_fs24.existsSync)(destPath)) (0, import_node_fs24.unlinkSync)(destPath);
+        if ((0, import_node_fs23.existsSync)(destPath)) (0, import_node_fs23.unlinkSync)(destPath);
       } catch {
       }
       const isAbort = err2?.name === "AbortError";
@@ -11436,13 +11508,13 @@ async function triggerTranscription(recordingId, storage, asrConfig, logger, opt
 }
 
 // src/tunnel/service.ts
-var import_node_fs29 = require("fs");
-var import_node_path25 = require("path");
+var import_node_fs28 = require("fs");
+var import_node_path24 = require("path");
 init_credentials();
 
 // src/tunnel/relay-client.ts
-var import_node_fs27 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs26 = require("fs");
+var import_node_path22 = require("path");
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -11486,8 +11558,8 @@ var RelayClient = class {
       lastDisconnectReason
     };
     try {
-      (0, import_node_fs27.mkdirSync)((0, import_node_path23.dirname)(this.opts.statusFilePath), { recursive: true });
-      (0, import_node_fs27.writeFileSync)(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      (0, import_node_fs26.mkdirSync)((0, import_node_path22.dirname)(this.opts.statusFilePath), { recursive: true });
+      (0, import_node_fs26.writeFileSync)(this.opts.statusFilePath, JSON.stringify(info, null, 2));
     } catch {
     }
   }
@@ -11869,8 +11941,8 @@ init_host();
 
 // src/tunnel/device-identity.ts
 var import_node_crypto3 = __toESM(require("crypto"), 1);
-var import_node_fs28 = __toESM(require("fs"), 1);
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_fs27 = __toESM(require("fs"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 init_host();
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 function base64UrlEncode(buf) {
@@ -11915,10 +11987,10 @@ function resolveClientStateDir(stateDir) {
   return stateDir ?? resolveStateDir();
 }
 function ensureDir(filePath) {
-  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
+  import_node_fs27.default.mkdirSync(import_node_path23.default.dirname(filePath), { recursive: true });
 }
 function resolveIdentityPath(stateDir) {
-  return import_node_path24.default.join(stateDir, "identity", "device.json");
+  return import_node_path23.default.join(stateDir, "identity", "device.json");
 }
 function normalizeDeviceAuthRole(role) {
   return role.trim();
@@ -11934,12 +12006,12 @@ function normalizeDeviceAuthScopes(scopes) {
   return [...out].sort();
 }
 function resolveDeviceAuthPath(stateDir) {
-  return import_node_path24.default.join(stateDir, "identity", "device-auth.json");
+  return import_node_path23.default.join(stateDir, "identity", "device-auth.json");
 }
 function readDeviceAuthStore(filePath) {
   try {
-    if (!import_node_fs28.default.existsSync(filePath)) return null;
-    const raw = import_node_fs28.default.readFileSync(filePath, "utf8");
+    if (!import_node_fs27.default.existsSync(filePath)) return null;
+    const raw = import_node_fs27.default.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || typeof parsed.deviceId !== "string") return null;
     if (!parsed.tokens || typeof parsed.tokens !== "object") return null;
@@ -11950,12 +12022,12 @@ function readDeviceAuthStore(filePath) {
 }
 function writeDeviceAuthStore(filePath, store) {
   ensureDir(filePath);
-  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
+  import_node_fs27.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
   try {
-    import_node_fs28.default.chmodSync(filePath, 384);
+    import_node_fs27.default.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -12002,8 +12074,8 @@ function clearDeviceAuthToken(params) {
 function loadOrCreateDeviceIdentity(stateDir) {
   const filePath = resolveIdentityPath(stateDir);
   try {
-    if (import_node_fs28.default.existsSync(filePath)) {
-      const raw = import_node_fs28.default.readFileSync(filePath, "utf8");
+    if (import_node_fs27.default.existsSync(filePath)) {
+      const raw = import_node_fs27.default.readFileSync(filePath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed?.version === 1 && typeof parsed.deviceId === "string" && typeof parsed.publicKeyPem === "string" && typeof parsed.privateKeyPem === "string") {
         const derivedId = fingerprintPublicKey(parsed.publicKeyPem);
@@ -12024,14 +12096,14 @@ function loadOrCreateDeviceIdentity(stateDir) {
     publicKeyPem,
     privateKeyPem
   };
-  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
+  import_node_fs27.default.mkdirSync(import_node_path23.default.dirname(filePath), { recursive: true });
   const stored = {
     version: 1,
     ...identity,
     createdAtMs: Date.now()
   };
   ensureDir(filePath);
-  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
+  import_node_fs27.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
 `, {
     mode: 384
   });
@@ -12915,7 +12987,7 @@ function createTunnelService(opts) {
     );
     client.sendRaw(frame);
   }
-  function isProcessAlive(pid) {
+  function isProcessAlive2(pid) {
     if (!Number.isInteger(pid) || pid <= 0) return false;
     if (pid === process.pid) return true;
     try {
@@ -12927,7 +12999,7 @@ function createTunnelService(opts) {
   }
   function readLockOwner(filePath) {
     try {
-      const parsed = JSON.parse((0, import_node_fs29.readFileSync)(filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs28.readFileSync)(filePath, "utf-8"));
       return typeof parsed.pid === "number" ? parsed.pid : null;
     } catch {
       return null;
@@ -12940,23 +13012,23 @@ function createTunnelService(opts) {
     lockFd = null;
     if (fd !== null) {
       try {
-        (0, import_node_fs29.closeSync)(fd);
+        (0, import_node_fs28.closeSync)(fd);
       } catch {
       }
     }
     if (filePath) {
       try {
-        (0, import_node_fs29.unlinkSync)(filePath);
+        (0, import_node_fs28.unlinkSync)(filePath);
       } catch {
       }
     }
   }
   function acquireLock(filePath) {
-    (0, import_node_fs29.mkdirSync)((0, import_node_path25.dirname)(filePath), { recursive: true });
+    (0, import_node_fs28.mkdirSync)((0, import_node_path24.dirname)(filePath), { recursive: true });
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const fd = (0, import_node_fs29.openSync)(filePath, "wx", 384);
-        (0, import_node_fs29.writeFileSync)(
+        const fd = (0, import_node_fs28.openSync)(filePath, "wx", 384);
+        (0, import_node_fs28.writeFileSync)(
           fd,
           JSON.stringify({
             pid: process.pid,
@@ -12975,12 +13047,12 @@ function createTunnelService(opts) {
           return false;
         }
         const ownerPid = readLockOwner(filePath);
-        if (ownerPid && !isProcessAlive(ownerPid)) {
+        if (ownerPid && !isProcessAlive2(ownerPid)) {
           opts.logger.warn(
             `Relay tunnel: removing stale local lock owned by dead pid=${ownerPid}`
           );
           try {
-            (0, import_node_fs29.unlinkSync)(filePath);
+            (0, import_node_fs28.unlinkSync)(filePath);
           } catch {
           }
           continue;
@@ -13025,12 +13097,12 @@ function createTunnelService(opts) {
         return;
       }
       const { logger } = opts;
-      const baseStateDir = (0, import_node_path25.join)(ctx.stateDir, "plugins", "phone-notifications");
+      const baseStateDir = (0, import_node_path24.join)(ctx.stateDir, "plugins", "phone-notifications");
       logger.info(
         `Relay tunnel: starting (pid=${process.pid}, url=${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 = (0, import_node_path25.join)(baseStateDir, "tunnel-status.json");
-      const lockPath = (0, import_node_path25.join)(baseStateDir, "relay-tunnel.lock");
+      const statusFilePath = (0, import_node_path24.join)(baseStateDir, "tunnel-status.json");
+      const lockPath = (0, import_node_path24.join)(baseStateDir, "relay-tunnel.lock");
       if (!acquireLock(lockPath)) {
         return;
       }
@@ -13095,25 +13167,6 @@ function createTunnelService(opts) {
 
 // src/plugin/lifecycle.ts
 init_env();
-
-// src/plugin/shared.ts
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
-    req.on("error", reject);
-  });
-}
-function trimToUndefined2(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  return trimmed || void 0;
-}
-
-// src/plugin/lifecycle.ts
 function registerStorageLifecycle(deps) {
   const {
     api,
@@ -13170,7 +13223,7 @@ function readHostGatewayConfig(params) {
   let configData;
   if (configPath) {
     try {
-      configData = JSON.parse((0, import_node_fs30.readFileSync)(configPath, "utf-8"));
+      configData = JSON.parse((0, import_node_fs29.readFileSync)(configPath, "utf-8"));
     } catch (err2) {
       if (err2?.code !== "ENOENT") {
         params.logger.warn(
@@ -13847,7 +13900,7 @@ var index_default = {
     let broadcastFn = null;
     let autoUpdateLifecycle = null;
     let tunnelService = null;
-    const openclawDir = api.runtime.state.resolveStateDir();
+    const openclawDir = resolvePluginStateDir(api);
     const logger = openclawDir ? new PluginFileLogger(api.logger, openclawDir) : createVersionAwareLogger(api.logger);
     const lightRuleCtx = {
       stateDir: openclawDir