@yoooclaw/phone-notifications 1.11.1 → 1.11.2-beta.0

package/dist/index.cjs

@@ -535,20 +535,20 @@ function selectModelByMemory(availableGB, isAppleSilicon = false) {
   return "tiny";
 }
 function resolveModelsDir(dataDir) {
-  const dir = (0, import_node_path22.join)(dataDir, WHISPER_MODELS_DIR);
-  (0, import_node_fs26.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path21.join)(dataDir, WHISPER_MODELS_DIR);
+  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function resolveBinDir(dataDir) {
-  const dir = (0, import_node_path22.join)(dataDir, WHISPER_BIN_DIR);
-  (0, import_node_fs26.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path21.join)(dataDir, WHISPER_BIN_DIR);
+  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function isModelDownloaded(modelsDir, modelSize) {
-  const modelPath = (0, import_node_path22.join)(modelsDir, MODEL_FILENAMES[modelSize]);
-  if (!(0, import_node_fs26.existsSync)(modelPath)) return false;
+  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  if (!(0, import_node_fs25.existsSync)(modelPath)) return false;
   try {
-    const stat = (0, import_node_fs26.statSync)(modelPath);
+    const stat = (0, import_node_fs25.statSync)(modelPath);
     const expectedSize = MODEL_DISK_SIZES[modelSize];
     return stat.size >= expectedSize * 0.8;
   } catch {
@@ -557,7 +557,7 @@ function isModelDownloaded(modelsDir, modelSize) {
 }
 async function downloadModel(modelsDir, modelSize, logger, modelSource, mirrorUrl) {
   const filename = MODEL_FILENAMES[modelSize];
-  const modelPath = (0, import_node_path22.join)(modelsDir, filename);
+  const modelPath = (0, import_node_path21.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 };
@@ -623,7 +623,7 @@ async function probeUrl(url, logger) {
 async function downloadFromUrl(url, modelPath, logger) {
   const tmpPath = `${modelPath}.downloading`;
   try {
-    (0, import_node_fs26.mkdirSync)((0, import_node_path22.dirname)(modelPath), { recursive: true });
+    (0, import_node_fs25.mkdirSync)((0, import_node_path21.dirname)(modelPath), { recursive: true });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 30 * 60 * 1e3);
     try {
@@ -639,7 +639,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_fs26.createWriteStream)(tmpPath);
+      const writeStream = (0, import_node_fs25.createWriteStream)(tmpPath);
       const readable = import_node_stream2.Readable.fromWeb(res.body);
       let downloaded = 0;
       let lastLogPercent = 0;
@@ -661,14 +661,14 @@ async function downloadFromUrl(url, modelPath, logger) {
     }
     const { renameSync: renameSync2 } = await import("fs");
     renameSync2(tmpPath, modelPath);
-    const fileSize = (0, import_node_fs26.statSync)(modelPath).size;
+    const fileSize = (0, import_node_fs25.statSync)(modelPath).size;
     logger.info(
-      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path22.basename)(modelPath)} (${formatBytes2(fileSize)})`
+      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path21.basename)(modelPath)} (${formatBytes2(fileSize)})`
     );
     return { ok: true, modelPath };
   } catch (err2) {
     try {
-      if ((0, import_node_fs26.existsSync)(tmpPath)) (0, import_node_fs26.unlinkSync)(tmpPath);
+      if ((0, import_node_fs25.existsSync)(tmpPath)) (0, import_node_fs25.unlinkSync)(tmpPath);
     } catch {
     }
     const msg = err2?.name === "AbortError" ? "\u6A21\u578B\u4E0B\u8F7D\u8D85\u65F6\uFF0830 \u5206\u949F\uFF09" : err2?.message ?? String(err2);
@@ -680,8 +680,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_path22.join)(binDir, name);
-    if ((0, import_node_fs26.existsSync)(binPath)) {
+    const binPath = (0, import_node_path21.join)(binDir, name);
+    if ((0, import_node_fs25.existsSync)(binPath)) {
       logger.info(`[whisper-local] \u627E\u5230\u672C\u5730\u4E8C\u8FDB\u5236: ${binPath}`);
       return binPath;
     }
@@ -732,7 +732,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_path22.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
   let inputPath = audioFilePath;
   let tmpWavPath = null;
   const actualFmt = detectAudioFormat(audioFilePath);
@@ -784,10 +784,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_fs26.existsSync)(jsonPath)) {
-      jsonContent = (0, import_node_fs26.readFileSync)(jsonPath, "utf-8");
+    if ((0, import_node_fs25.existsSync)(jsonPath)) {
+      jsonContent = (0, import_node_fs25.readFileSync)(jsonPath, "utf-8");
       try {
-        (0, import_node_fs26.unlinkSync)(jsonPath);
+        (0, import_node_fs25.unlinkSync)(jsonPath);
       } catch {
       }
     } else {
@@ -865,10 +865,10 @@ function getPhysicalCoreCount() {
 }
 function detectAudioFormat(filePath) {
   try {
-    const fd = (0, import_node_fs26.openSync)(filePath, "r");
+    const fd = (0, import_node_fs25.openSync)(filePath, "r");
     const buf = Buffer.alloc(12);
-    (0, import_node_fs26.readSync)(fd, buf, 0, 12, 0);
-    (0, import_node_fs26.closeSync)(fd);
+    (0, import_node_fs25.readSync)(fd, buf, 0, 12, 0);
+    (0, import_node_fs25.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";
@@ -903,7 +903,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
       timeout: 12e4,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (ffmpegResult.status === 0 && (0, import_node_fs26.existsSync)(outputPath)) {
+    if (ffmpegResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
       logger.info(`[whisper-local] ffmpeg \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
       return { ok: true };
     }
@@ -916,7 +916,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_fs26.existsSync)(outputPath)) {
+      if (opusResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
         logger.info(`[whisper-local] opusdec \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
         return { ok: true };
       }
@@ -930,7 +930,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
     if (detectedExt && !inputPath.endsWith(detectedExt)) {
       tmpCopy = inputPath + ".detected" + detectedExt;
       try {
-        (0, import_node_fs26.copyFileSync)(inputPath, tmpCopy);
+        (0, import_node_fs25.copyFileSync)(inputPath, tmpCopy);
         actualInputPath = tmpCopy;
         logger.info(
           `[whisper-local] \u68C0\u6D4B\u5230\u5B9E\u9645\u683C\u5F0F ${detectedExt}\uFF0C\u4E34\u65F6\u91CD\u547D\u540D`
@@ -954,22 +954,22 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
         timeout: 12e4,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      if (tmpCopy && (0, import_node_fs26.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs26.unlinkSync)(tmpCopy);
+          (0, import_node_fs25.unlinkSync)(tmpCopy);
         } catch {
         }
       }
-      if (afResult.status === 0 && (0, import_node_fs26.existsSync)(outputPath)) {
+      if (afResult.status === 0 && (0, import_node_fs25.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_fs26.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs26.unlinkSync)(tmpCopy);
+          (0, import_node_fs25.unlinkSync)(tmpCopy);
         } catch {
         }
       }
@@ -980,9 +980,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_fs26.existsSync)(path2)) {
+  if (path2 && (0, import_node_fs25.existsSync)(path2)) {
     try {
-      (0, import_node_fs26.unlinkSync)(path2);
+      (0, import_node_fs25.unlinkSync)(path2);
     } catch {
     }
   }
@@ -1068,13 +1068,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_process2, import_node_fs26, import_node_path22, 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_process2, 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 init_whisper_local = __esm({
   "src/recording/whisper-local.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
-    import_node_fs26 = require("fs");
-    import_node_path22 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path21 = require("path");
     import_promises3 = require("stream/promises");
     import_node_stream2 = require("stream");
     import_node_os4 = require("os");
@@ -1229,7 +1229,7 @@ async function initializeAsr(config, dataDir, logger) {
   }
 }
 async function transcribeAudio(audioFilePath, config, logger, options = {}) {
-  if (!(0, import_node_fs27.existsSync)(audioFilePath)) {
+  if (!(0, import_node_fs26.existsSync)(audioFilePath)) {
     return { ok: false, error: `\u97F3\u9891\u6587\u4EF6\u4E0D\u5B58\u5728: ${audioFilePath}` };
   }
   logger.info(
@@ -1240,6 +1240,7 @@ async function transcribeAudio(audioFilePath, config, logger, options = {}) {
       case "api":
         return await transcribeWithModelProxy(
           options.audioOssUrl,
+          options.audioDurationMs,
           config.api,
           logger
         );
@@ -1339,7 +1340,8 @@ async function runTranscriptionWorkflow(params) {
     logger
   } = params;
   const result = await transcribeAudio(audioFilePath, config, logger, {
-    audioOssUrl
+    audioOssUrl,
+    audioDurationMs: Math.max(0, Math.round(durationSec * 1e3))
   });
   if (!result.ok) {
     return { ok: false, error: result.error };
@@ -1373,8 +1375,8 @@ async function runTranscriptionWorkflow(params) {
     createdAt
   );
   const transcriptDataFilename = buildTranscriptDataFilename(recordingId);
-  const transcriptDataPath = (0, import_node_path23.join)(transcriptDataDir, transcriptDataFilename);
-  (0, import_node_fs27.writeFileSync)(
+  const transcriptDataPath = (0, import_node_path22.join)(transcriptDataDir, transcriptDataFilename);
+  (0, import_node_fs26.writeFileSync)(
     transcriptDataPath,
     JSON.stringify(transcriptData, null, 2),
     "utf-8"
@@ -1382,14 +1384,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_path23.join)(transcriptsDir, filename);
-  (0, import_node_fs27.writeFileSync)(filePath, markdown, "utf-8");
+  const filePath = (0, import_node_path22.join)(transcriptsDir, filename);
+  (0, import_node_fs26.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_path23.join)(summariesDir, summaryFilename);
-    (0, import_node_fs27.writeFileSync)(summaryFilePath, summary, "utf-8");
+    const summaryFilePath = (0, import_node_path22.join)(summariesDir, summaryFilename);
+    (0, import_node_fs26.writeFileSync)(summaryFilePath, summary, "utf-8");
     logger.info(`[asr] \u6458\u8981\u6587\u672C\u5DF2\u5199\u5165: ${summaryFilePath}`);
   }
   return {
@@ -1402,7 +1404,7 @@ async function runTranscriptionWorkflow(params) {
     title
   };
 }
-async function transcribeWithModelProxy(audioOssUrl, apiConfig, logger) {
+async function transcribeWithModelProxy(audioOssUrl, audioDurationMs, apiConfig, logger) {
   const normalizedAudioOssUrl = normalizeOptionalText2(audioOssUrl);
   if (!normalizedAudioOssUrl) {
     return { ok: false, error: "API \u6A21\u5F0F\u7F3A\u5C11 audioOssUrl\uFF0C\u65E0\u6CD5\u8C03\u7528 model-proxy" };
@@ -1468,13 +1470,14 @@ async function transcribeWithModelProxy(audioOssUrl, apiConfig, logger) {
     apiKey,
     taskId,
     initialRequestId: requestId,
+    audioDurationMs,
     apiConfig,
     logger
   });
 }
 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_path23.join)(audioFilePath, "..", "..", "..");
+  const dataDir = process.env.OPENCLAW_STATE_DIR ?? process.env.QCLAW_STATE_DIR ?? (0, import_node_path22.join)(audioFilePath, "..", "..", "..");
   const localConfig = config.local ?? {};
   const result = await runLocal(
     audioFilePath,
@@ -1530,6 +1533,7 @@ async function pollLongRecordingTaskResult(params) {
     apiKey,
     taskId,
     initialRequestId,
+    audioDurationMs,
     apiConfig,
     logger
   } = params;
@@ -1577,7 +1581,13 @@ async function pollLongRecordingTaskResult(params) {
       lastStatus = status;
     }
     if (status === "SUCCEEDED") {
-      return buildLongRecordingSuccessResult(taskId, requestId, data, logger);
+      return buildLongRecordingSuccessResult(
+        taskId,
+        requestId,
+        data,
+        audioDurationMs,
+        logger
+      );
     }
     if (LONG_RECORDING_TERMINAL_FAILURE_STATUSES.has(status)) {
       return {
@@ -1600,11 +1610,11 @@ async function pollLongRecordingTaskResult(params) {
     error: `Model Proxy ASR \u8F6E\u8BE2\u8D85\u65F6: taskId=${taskId}, waited=${DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS * DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS}ms`
   };
 }
-function buildLongRecordingSuccessResult(taskId, requestId, data, logger) {
+function buildLongRecordingSuccessResult(taskId, requestId, data, audioDurationMs, logger) {
   const sourceTextList = normalizeLongRecordingSourceTextList(
     data?.recordResult?.sourceTextList
   );
-  const listResult = extractLongRecordingTextFromList(sourceTextList);
+  const listResult = extractLongRecordingTextFromList(sourceTextList, audioDurationMs);
   const sourceText = normalizeOptionalText2(data?.recordResult?.sourceText);
   const summaryText = normalizeOptionalText2(data?.recordResult?.summaryResult) ?? "";
   const title = normalizeOptionalText2(data?.recordResult?.title);
@@ -1701,11 +1711,12 @@ function normalizeLongRecordingSourceTextList(value) {
     return [{
       content,
       speakerId: normalizeOptionalInteger2(record.speakerId),
-      startTime: normalizeOptionalNonNegativeNumber(record.startTime)
+      startTime: normalizeOptionalNonNegativeNumber(record.startTime),
+      endTime: normalizeOptionalNonNegativeNumber(record.endTime)
     }];
   });
 }
-function extractLongRecordingTextFromList(items) {
+function extractLongRecordingTextFromList(items, finalFallbackEndMs) {
   if (items.length === 0) {
     return {
       segments: []
@@ -1713,10 +1724,13 @@ function extractLongRecordingTextFromList(items) {
   }
   const segments = items.map((item, index) => {
     const startMs = item.startTime ?? 0;
+    const explicitEndMs = item.endTime;
     const nextStart = items[index + 1]?.startTime;
+    const fallbackEndMs = index === items.length - 1 ? normalizeOptionalNonNegativeNumber(finalFallbackEndMs) : void 0;
+    const endMs = explicitEndMs ?? nextStart ?? fallbackEndMs ?? startMs;
     return {
       start_ms: startMs,
-      end_ms: nextStart ?? startMs,
+      end_ms: Math.max(startMs, endMs),
       text: item.content,
       speaker_id: item.speakerId
     };
@@ -1772,12 +1786,12 @@ function formatTranscriptSegmentText(segment) {
   }
   return text;
 }
-var import_node_fs27, import_node_path23, DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS, DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS, LONG_RECORDING_RUNNING_STATUSES, LONG_RECORDING_TERMINAL_FAILURE_STATUSES;
+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 init_asr = __esm({
   "src/recording/asr.ts"() {
     "use strict";
-    import_node_fs27 = require("fs");
-    import_node_path23 = require("path");
+    import_node_fs26 = require("fs");
+    import_node_path22 = require("path");
     init_credentials();
     init_env();
     init_transcript_document();
@@ -5422,7 +5436,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.11.1".trim();
+  const version = "1.11.2-beta.0".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -6035,20 +6049,17 @@ function readOptionalString(value) {
   const trimmed = value.trim();
   return trimmed || void 0;
 }
-function isLegacyLightRuleWithoutType(raw) {
-  return raw.type === void 0 && readOptionalString(raw.name) !== void 0 && readOptionalString(raw.description) !== void 0 && Array.isArray(raw.segments);
-}
 function readMeta(taskDir) {
   const metaPath = (0, import_node_path3.join)(taskDir, "meta.json");
   if (!(0, import_node_fs4.existsSync)(metaPath)) return null;
   try {
     const raw = JSON.parse((0, import_node_fs4.readFileSync)(metaPath, "utf-8"));
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-    if (raw.type !== "light-rule" && !isLegacyLightRuleWithoutType(raw)) return null;
+    if (raw.type !== "light-rule") return null;
     if (!Array.isArray(raw.segments)) return null;
     const name = readOptionalString(raw.name) ?? (0, import_node_path3.basename)(taskDir);
     const title = readOptionalString(raw.title) ?? name;
-    const description = readOptionalString(raw.description) ?? readOptionalString(raw.reason) ?? name;
+    const description = readOptionalString(raw.description) ?? name;
     const createdAt = readOptionalString(raw.createdAt) ?? (0, import_node_fs4.statSync)(metaPath).birthtime.toISOString();
     const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
     const repeatTimes = normalizeRepeatTimes({
@@ -7075,115 +7086,6 @@ var InlineLightRuleEvaluator = class {
   }
 };
 
-// src/light-rules/migration.ts
-var import_node_fs8 = require("fs");
-var import_node_path7 = require("path");
-var NO_MATCH_FETCH_PY = `#!/usr/bin/env python3
-# \u6B64\u6587\u4EF6\u7531\u8FC1\u79FB\u5DE5\u5177\u751F\u6210\u3002
-# \u706F\u6548\u89C4\u5219\u5DF2\u8FC1\u79FB\u81F3\u4E8B\u4EF6\u9A71\u52A8\u67B6\u6784\uFF0C\u6B64 cron job \u4E0D\u518D\u6267\u884C\u5B9E\u9645\u5DE5\u4F5C\u3002
-print("NO_MATCH")
-`;
-function normalizeScriptText(text) {
-  return text.replace(/\r\n/g, "\n").trim();
-}
-function resolveTasksDir(ctx) {
-  if (ctx.workspaceDir) return (0, import_node_path7.join)(ctx.workspaceDir, "tasks");
-  if (ctx.stateDir) {
-    const inferredWorkspaceDir = (0, import_node_path7.join)(ctx.stateDir, "workspace");
-    if ((0, import_node_fs8.existsSync)(inferredWorkspaceDir)) return (0, import_node_path7.join)(inferredWorkspaceDir, "tasks");
-    return (0, import_node_path7.join)(ctx.stateDir, "tasks");
-  }
-  return null;
-}
-function migrateLegacyLightRuleTasks(ctx, logger) {
-  const tasksDir3 = resolveTasksDir(ctx);
-  if (!tasksDir3 || !(0, import_node_fs8.existsSync)(tasksDir3)) return;
-  try {
-    for (const entry of (0, import_node_fs8.readdirSync)(tasksDir3, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      migrateTaskDir((0, import_node_path7.join)(tasksDir3, String(entry.name)), logger);
-    }
-  } catch (err2) {
-    logger.warn(`migration: failed to read tasks dir: ${err2?.message}`);
-  }
-}
-function migrateTaskDir(taskDir, logger) {
-  const metaPath = (0, import_node_path7.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs8.existsSync)(metaPath)) return;
-  let meta;
-  try {
-    meta = JSON.parse((0, import_node_fs8.readFileSync)(metaPath, "utf-8"));
-  } catch {
-    return;
-  }
-  if (meta.type !== "light-rule") return;
-  const name = typeof meta.name === "string" ? meta.name : taskDir;
-  cleanupLegacyMetaFields(meta, name, metaPath, logger);
-  replaceFetchPy(taskDir, name, logger);
-  for (const filename of ["README.md", "checkpoint.json"]) {
-    removeFile((0, import_node_path7.join)(taskDir, filename), name, filename, logger);
-  }
-}
-function cleanupLegacyMetaFields(meta, name, metaPath, logger) {
-  const cleaned = [];
-  if (mergeMatchRulesIntoDescription(meta)) cleaned.push("matchRules");
-  if (meta.cronSchedule !== void 0) {
-    delete meta.cronSchedule;
-    cleaned.push("cronSchedule");
-  }
-  if (cleaned.length === 0) return;
-  try {
-    (0, import_node_fs8.writeFileSync)(metaPath, JSON.stringify(meta, null, 2), "utf-8");
-    logger.info(
-      `migration: cleaned deprecated field(s) [${cleaned.join(", ")}] in meta.json for light rule: ${name}`
-    );
-  } catch (err2) {
-    logger.warn(`migration: failed to update meta.json for ${name}: ${err2?.message}`);
-  }
-}
-function mergeMatchRulesIntoDescription(meta) {
-  const matchRules = meta.matchRules;
-  if (!matchRules || typeof matchRules !== "object") return false;
-  const rules = matchRules;
-  const parts = [];
-  if (rules.appName) parts.push(`app=${rules.appName}`);
-  if (rules.senderKeywords?.length) {
-    parts.push(`\u53D1\u4EF6\u4EBA\u5173\u952E\u8BCD=${rules.senderKeywords.join("\u3001")}`);
-  }
-  if (rules.contentKeywords?.length) {
-    parts.push(`\u5185\u5BB9\u5173\u952E\u8BCD=${rules.contentKeywords.join("\u3001")}`);
-  }
-  if (parts.length > 0) {
-    const existing = typeof meta.description === "string" ? meta.description.trim() : "";
-    meta.description = existing ? `${existing}\u3002\u5339\u914D\u89C4\u5219\uFF1A${parts.join("\uFF0C")}` : `\u5339\u914D\u89C4\u5219\uFF1A${parts.join("\uFF0C")}`;
-  }
-  delete meta.matchRules;
-  return true;
-}
-function replaceFetchPy(taskDir, name, logger) {
-  const fetchPyPath = (0, import_node_path7.join)(taskDir, "fetch.py");
-  if (!(0, import_node_fs8.existsSync)(fetchPyPath)) return;
-  try {
-    const existing = (0, import_node_fs8.readFileSync)(fetchPyPath, "utf-8");
-    if (normalizeScriptText(existing) === normalizeScriptText(NO_MATCH_FETCH_PY)) {
-      return;
-    }
-    (0, import_node_fs8.writeFileSync)(fetchPyPath, NO_MATCH_FETCH_PY, "utf-8");
-    logger.info(`migration: replaced fetch.py with NO_MATCH placeholder for ${name}`);
-  } catch (err2) {
-    logger.warn(`migration: failed to replace fetch.py for ${name}: ${err2?.message}`);
-  }
-}
-function removeFile(filePath, ruleName, filename, logger) {
-  if (!(0, import_node_fs8.existsSync)(filePath)) return;
-  try {
-    (0, import_node_fs8.rmSync)(filePath);
-    logger.info(`migration: removed ${filename} for light rule: ${ruleName}`);
-  } catch (err2) {
-    logger.warn(`migration: failed to remove ${filename} for ${ruleName}: ${err2?.message}`);
-  }
-}
-
 // src/light-rules/pi-invoker.ts
 var import_agent_runtime = require("openclaw/plugin-sdk/agent-runtime");
 var DEFAULT_PROVIDER = "anthropic";
@@ -7365,7 +7267,7 @@ function resolveUpdateChannel(params) {
 }
 
 // src/update/index.ts
-var import_node_path9 = require("path");
+var import_node_path8 = require("path");
 
 // src/update/checker.ts
 function parseSemver(v) {
@@ -7467,8 +7369,8 @@ var UpdateChecker = class {
 };
 
 // src/update/executor.ts
-var import_node_fs9 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path7 = require("path");
 var import_node_os = require("os");
 var VERSION_PATTERN = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 var BASE_URL = "https://artifact.yoooclaw.com/plugin";
@@ -7478,9 +7380,9 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
   }
   const tgzUrl = `${BASE_URL}/v${version}/yoooclaw-phone-notifications-${version}.tgz`;
   logger.info(`\u6267\u884C\u66F4\u65B0: ${tgzUrl} \u2192 ${targetDir}`);
-  const workDir = (0, import_node_fs9.mkdtempSync)((0, import_node_path8.join)((0, import_node_os.tmpdir)(), ".openclaw-plugin-update-"));
-  const tgzPath = (0, import_node_path8.join)(workDir, "plugin.tgz");
-  const stagingDir = (0, import_node_path8.join)(workDir, "staged");
+  const workDir = (0, import_node_fs8.mkdtempSync)((0, import_node_path7.join)((0, import_node_os.tmpdir)(), ".openclaw-plugin-update-"));
+  const tgzPath = (0, import_node_path7.join)(workDir, "plugin.tgz");
+  const stagingDir = (0, import_node_path7.join)(workDir, "staged");
   let backupDir = null;
   try {
     logger.info("\u4E0B\u8F7D\u63D2\u4EF6\u5305...");
@@ -7489,9 +7391,9 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
       return { success: false, message: `\u4E0B\u8F7D\u5931\u8D25 (HTTP ${response.status}): ${tgzUrl}` };
     }
     const buffer = Buffer.from(await response.arrayBuffer());
-    (0, import_node_fs9.writeFileSync)(tgzPath, buffer);
+    (0, import_node_fs8.writeFileSync)(tgzPath, buffer);
     logger.info(`\u4E0B\u8F7D\u5B8C\u6210 (${buffer.length} bytes)`);
-    (0, import_node_fs9.mkdirSync)(stagingDir, { recursive: true });
+    (0, import_node_fs8.mkdirSync)(stagingDir, { recursive: true });
     const tarResult = await runCommand(
       ["tar", "-xzf", tgzPath, "-C", stagingDir, "--strip-components=1"],
       { timeoutMs: 3e4 }
@@ -7500,14 +7402,14 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
       const err2 = tarResult.stderr || tarResult.stdout || "unknown error";
       return { success: false, message: `\u89E3\u538B\u5931\u8D25: ${err2}` };
     }
-    (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(targetDir), { recursive: true });
+    (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(targetDir), { recursive: true });
     try {
       backupDir = `${targetDir}.bak.${Date.now()}`;
-      (0, import_node_fs9.renameSync)(targetDir, backupDir);
+      (0, import_node_fs8.renameSync)(targetDir, backupDir);
     } catch {
       backupDir = null;
     }
-    (0, import_node_fs9.renameSync)(stagingDir, targetDir);
+    (0, import_node_fs8.renameSync)(stagingDir, targetDir);
     try {
       await updateConfigRecord2(version, tgzUrl);
     } catch (err2) {
@@ -7515,18 +7417,18 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
     }
     if (backupDir) {
       try {
-        (0, import_node_fs9.rmSync)(backupDir, { force: true, recursive: true });
+        (0, import_node_fs8.rmSync)(backupDir, { force: true, recursive: true });
       } catch {
       }
     }
-    const msg = `\u5DF2\u66F4\u65B0\u5230 ${version}\uFF0C\u8BF7\u91CD\u542F gateway \u751F\u6548`;
+    const msg = `\u5DF2\u66F4\u65B0\u5230 ${version}`;
     logger.info(msg);
-    return { success: true, message: msg };
+    return { success: true, message: msg, version };
   } catch (err2) {
     if (backupDir) {
       try {
-        (0, import_node_fs9.rmSync)(targetDir, { force: true, recursive: true });
-        (0, import_node_fs9.renameSync)(backupDir, targetDir);
+        (0, import_node_fs8.rmSync)(targetDir, { force: true, recursive: true });
+        (0, import_node_fs8.renameSync)(backupDir, targetDir);
         logger.info("\u5DF2\u56DE\u6EDA\u5230\u4E4B\u524D\u7248\u672C");
       } catch (rollbackErr) {
         logger.error(`\u56DE\u6EDA\u5931\u8D25: ${String(rollbackErr)}`);
@@ -7537,12 +7439,47 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
     return { success: false, message: errMsg };
   } finally {
     try {
-      (0, import_node_fs9.rmSync)(workDir, { force: true, recursive: true });
+      (0, import_node_fs8.rmSync)(workDir, { force: true, recursive: true });
     } catch {
     }
   }
 }
 
+// src/update/restart.ts
+function scheduleGatewayRestart(logger, deps = {}) {
+  try {
+    const cfg = deps.loadConfig?.();
+    if (cfg?.commands?.restart === false) {
+      logger.warn("\u66F4\u65B0\u540E\u8DF3\u8FC7 gateway \u91CD\u542F: commands.restart=false");
+      return { scheduled: false };
+    }
+  } catch (err2) {
+    logger.warn(`\u66F4\u65B0\u540E\u68C0\u67E5 gateway \u91CD\u542F\u914D\u7F6E\u5931\u8D25: ${String(err2)}`);
+  }
+  const getListenerCount = deps.getListenerCount ?? ((signal) => process.listenerCount(signal));
+  if (getListenerCount("SIGUSR1") < 1) {
+    logger.warn("\u66F4\u65B0\u540E\u8DF3\u8FC7 gateway \u91CD\u542F: \u5F53\u524D\u8FDB\u7A0B\u672A\u6CE8\u518C SIGUSR1 \u76D1\u542C\u5668");
+    return { scheduled: false };
+  }
+  const emitSignal = deps.emitSignal ?? ((signal) => process.emit(signal));
+  const schedule = deps.schedule ?? ((task) => {
+    setTimeout(task, 0);
+  });
+  schedule(() => {
+    try {
+      const accepted = emitSignal("SIGUSR1");
+      if (accepted) {
+        logger.info("\u66F4\u65B0\u5B8C\u6210\uFF0C\u5DF2\u89E6\u53D1 gateway SIGUSR1 \u91CD\u542F");
+      } else {
+        logger.warn("\u66F4\u65B0\u5B8C\u6210\uFF0C\u4F46 gateway SIGUSR1 \u4FE1\u53F7\u672A\u88AB\u5904\u7406");
+      }
+    } catch (err2) {
+      logger.warn(`\u66F4\u65B0\u540E\u89E6\u53D1 gateway \u91CD\u542F\u5931\u8D25: ${String(err2)}`);
+    }
+  });
+  return { scheduled: true };
+}
+
 // src/update/index.ts
 var PLUGIN_ID = "phone-notifications";
 function resolveTargetDir(api) {
@@ -7552,7 +7489,7 @@ function resolveTargetDir(api) {
     if (installPath) return installPath;
   } catch {
   }
-  return (0, import_node_path9.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
+  return (0, import_node_path8.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
 }
 async function updateConfigRecord(api, version, targetDir, tgzUrl) {
   const configApi = api.runtime.config;
@@ -7570,6 +7507,23 @@ async function updateConfigRecord(api, version, targetDir, tgzUrl) {
   };
   await configApi.writeConfigFile(cfg);
 }
+function finalizeUpdateResult(api, logger, result) {
+  if (!result.success) {
+    return result;
+  }
+  const restart = scheduleGatewayRestart(logger, {
+    loadConfig: () => {
+      const configApi = api.runtime.config;
+      return configApi?.loadConfig?.();
+    }
+  });
+  const version = result.version ?? "\u76EE\u6807\u7248\u672C";
+  return {
+    ...result,
+    restartScheduled: restart.scheduled,
+    message: restart.scheduled ? `\u5DF2\u66F4\u65B0\u5230 ${version}\uFF0C\u5DF2\u89E6\u53D1 gateway \u91CD\u542F` : `\u5DF2\u66F4\u65B0\u5230 ${version}\uFF0C\u8BF7\u624B\u52A8\u91CD\u542F gateway \u751F\u6548`
+  };
+}
 function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast, externalUpdateNotifier) {
   if (config.enabled === false) {
     logger.info("\u81EA\u52A8\u66F4\u65B0\u5DF2\u7981\u7528 (autoUpdate.enabled = false)");
@@ -7601,7 +7555,7 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
   api.registerTool({
     name: "plugin-update",
     label: "Plugin Update",
-    description: "\u5C06 phone-notifications \u63D2\u4EF6\u66F4\u65B0\u5230\u6307\u5B9A\u7248\u672C\u3002\u4EC5\u5728\u7528\u6237\u660E\u786E\u540C\u610F\u66F4\u65B0\u540E\u8C03\u7528\u3002\u66F4\u65B0\u5B8C\u6210\u540E\u9700\u91CD\u542F gateway \u751F\u6548\u3002",
+    description: "\u5C06 phone-notifications \u63D2\u4EF6\u66F4\u65B0\u5230\u6307\u5B9A\u7248\u672C\u3002\u4EC5\u5728\u7528\u6237\u660E\u786E\u540C\u610F\u66F4\u65B0\u540E\u8C03\u7528\u3002\u66F4\u65B0\u5B8C\u6210\u540E\u4F1A\u81EA\u52A8\u5C1D\u8BD5\u91CD\u542F gateway\uFF1B\u5982\u5BBF\u4E3B\u4E0D\u652F\u6301\uFF0C\u5219\u9700\u624B\u52A8\u91CD\u542F\u3002",
     parameters: {
       type: "object",
       required: ["version"],
@@ -7623,13 +7577,14 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
         targetDir,
         (v, url) => updateConfigRecord(api, v, targetDir, url)
       );
-      if (result.success) {
+      const finalResult = finalizeUpdateResult(api, logger, result);
+      if (finalResult.success) {
         pendingUpdate = null;
         externalUpdateNotifier?.clearPendingUpdate();
       }
       return {
-        content: [{ type: "text", text: result.message }],
-        details: result
+        content: [{ type: "text", text: finalResult.message }],
+        details: finalResult
       };
     }
   });
@@ -7651,16 +7606,20 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
       targetDir,
       (v, url) => updateConfigRecord(api, v, targetDir, url)
     );
-    if (result.success) {
+    const finalResult = finalizeUpdateResult(api, logger, result);
+    if (finalResult.success) {
       pendingUpdate = null;
       externalUpdateNotifier?.clearPendingUpdate();
     }
-    if (result.success) {
-      respond(true, { message: result.message });
+    if (finalResult.success) {
+      respond(true, {
+        message: finalResult.message,
+        restartScheduled: finalResult.restartScheduled === true
+      });
     } else {
       respond(false, void 0, {
         code: "UPDATE_FAILED",
-        message: result.message
+        message: finalResult.message
       });
     }
   });
@@ -7740,10 +7699,10 @@ function registerAutoUpdateLifecycle(deps) {
 }
 
 // src/plugin/cli.ts
-var import_node_path17 = require("path");
+var import_node_path16 = require("path");
 
 // src/cli/auth.ts
-var import_node_fs10 = require("fs");
+var import_node_fs9 = require("fs");
 init_credentials();
 function registerAuthCli(program) {
   const auth = program.command("auth").description("\u7528\u6237\u8BA4\u8BC1\u7BA1\u7406");
@@ -7779,12 +7738,12 @@ function registerAuthCli(program) {
   });
   auth.command("clear").description("\u6E05\u9664\u5DF2\u4FDD\u5B58\u7684\u8BA4\u8BC1\u4FE1\u606F").action(() => {
     const path2 = credentialsPath();
-    if ((0, import_node_fs10.existsSync)(path2)) {
+    if ((0, import_node_fs9.existsSync)(path2)) {
       const creds = readCredentials();
       delete creds.apiKey;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
-        (0, import_node_fs10.rmSync)(path2, { force: true });
+        (0, import_node_fs9.rmSync)(path2, { force: true });
       } else {
         writeCredentials(creds);
       }
@@ -7916,23 +7875,23 @@ function registerNtfStats(ntf, ctx) {
 }
 
 // src/cli/ntf-sync.ts
-var import_node_fs11 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path9 = require("path");
 var SYNC_FETCH_LIMIT = 300;
 function checkpointPath(dir) {
-  return (0, import_node_path10.join)(dir, ".checkpoint.json");
+  return (0, import_node_path9.join)(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!(0, import_node_fs11.existsSync)(p)) return {};
+  if (!(0, import_node_fs10.existsSync)(p)) return {};
   try {
-    return JSON.parse((0, import_node_fs11.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_node_fs10.readFileSync)(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCheckpoint(dir, data) {
-  (0, import_node_fs11.writeFileSync)(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
+  (0, import_node_fs10.writeFileSync)(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
 }
 function registerNtfSync(ntf, ctx) {
   const sync = ntf.command("sync").description("\u540C\u6B65\u901A\u77E5\u5230\u8BB0\u5FC6\u7CFB\u7EDF");
@@ -8025,8 +7984,8 @@ function registerNtfSync(ntf, ctx) {
 }
 
 // src/cli/ntf-monitor.ts
-var import_node_fs12 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path10 = require("path");
 
 // src/monitor/fetch-gen.ts
 function generateFetchPy(name, matchRules) {
@@ -8111,19 +8070,19 @@ function pyLiteral(value) {
 function tasksDir2(ctx) {
   const base = ctx.workspaceDir || ctx.stateDir;
   if (!base) throw new Error("workspaceDir and stateDir both unavailable");
-  return (0, import_node_path11.join)(base, "tasks");
+  return (0, import_node_path10.join)(base, "tasks");
 }
 function readMeta2(taskDir) {
-  const metaPath = (0, import_node_path11.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs12.existsSync)(metaPath)) return null;
+  const metaPath = (0, import_node_path10.join)(taskDir, "meta.json");
+  if (!(0, import_node_fs11.existsSync)(metaPath)) return null;
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)(metaPath, "utf-8"));
+    return JSON.parse((0, import_node_fs11.readFileSync)(metaPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeMeta2(taskDir, meta) {
-  (0, import_node_fs12.writeFileSync)((0, import_node_path11.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  (0, import_node_fs11.writeFileSync)((0, import_node_path10.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function generateReadme(name, description) {
   return `# Monitor Task: ${name}
@@ -8142,27 +8101,27 @@ function registerNtfMonitor(ntf, ctx) {
   const monitor = ntf.command("monitor").description("\u901A\u77E5\u76D1\u63A7\u4EFB\u52A1\u7BA1\u7406");
   monitor.command("list").description("\u5217\u51FA\u6240\u6709\u76D1\u63A7\u4EFB\u52A1").action(() => {
     const dir = tasksDir2(ctx);
-    if (!(0, import_node_fs12.existsSync)(dir)) {
+    if (!(0, import_node_fs11.existsSync)(dir)) {
       output({ ok: true, tasks: [] });
       return;
     }
     const tasks = [];
-    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const meta = readMeta2((0, import_node_path11.join)(dir, entry.name));
+      const meta = readMeta2((0, import_node_path10.join)(dir, entry.name));
       if (meta) tasks.push(meta);
     }
     output({ ok: true, tasks });
   });
   monitor.command("show <name>").description("\u67E5\u770B\u76D1\u63A7\u4EFB\u52A1\u8BE6\u60C5").action((name) => {
-    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path10.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
-    const checkpointPath2 = (0, import_node_path11.join)(taskDir, "checkpoint.json");
+    const checkpointPath2 = (0, import_node_path10.join)(taskDir, "checkpoint.json");
     let checkpoint = {};
-    if ((0, import_node_fs12.existsSync)(checkpointPath2)) {
+    if ((0, import_node_fs11.existsSync)(checkpointPath2)) {
       try {
-        checkpoint = JSON.parse((0, import_node_fs12.readFileSync)(checkpointPath2, "utf-8"));
+        checkpoint = JSON.parse((0, import_node_fs11.readFileSync)(checkpointPath2, "utf-8"));
       } catch {
       }
     }
@@ -8177,8 +8136,8 @@ function registerNtfMonitor(ntf, ctx) {
   monitor.command("create <name>").description("\u521B\u5EFA\u76D1\u63A7\u4EFB\u52A1").requiredOption("--description <text>", "\u4EFB\u52A1\u63CF\u8FF0").requiredOption("--match-rules <json>", "\u5339\u914D\u89C4\u5219 JSON").requiredOption("--schedule <cron>", "cron \u8868\u8FBE\u5F0F").action(
     (name, opts) => {
       const dir = tasksDir2(ctx);
-      const taskDir = (0, import_node_path11.join)(dir, name);
-      if ((0, import_node_fs12.existsSync)(taskDir)) {
+      const taskDir = (0, import_node_path10.join)(dir, name);
+      if ((0, import_node_fs11.existsSync)(taskDir)) {
         exitError("ALREADY_EXISTS", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u5DF2\u5B58\u5728`);
       }
       let matchRules;
@@ -8190,7 +8149,7 @@ function registerNtfMonitor(ntf, ctx) {
           "match-rules \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON"
         );
       }
-      (0, import_node_fs12.mkdirSync)(taskDir, { recursive: true });
+      (0, import_node_fs11.mkdirSync)(taskDir, { recursive: true });
       const meta = {
         name,
         description: opts.description,
@@ -8200,13 +8159,13 @@ function registerNtfMonitor(ntf, ctx) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeMeta2(taskDir, meta);
-      (0, import_node_fs12.writeFileSync)(
-        (0, import_node_path11.join)(taskDir, "fetch.py"),
+      (0, import_node_fs11.writeFileSync)(
+        (0, import_node_path10.join)(taskDir, "fetch.py"),
         generateFetchPy(name, matchRules),
         "utf-8"
       );
-      (0, import_node_fs12.writeFileSync)(
-        (0, import_node_path11.join)(taskDir, "README.md"),
+      (0, import_node_fs11.writeFileSync)(
+        (0, import_node_path10.join)(taskDir, "README.md"),
         generateReadme(name, opts.description),
         "utf-8"
       );
@@ -8234,8 +8193,8 @@ function registerNtfMonitor(ntf, ctx) {
     }
   );
   monitor.command("delete <name>").description("\u5220\u9664\u76D1\u63A7\u4EFB\u52A1").option("--yes", "\u8DF3\u8FC7\u786E\u8BA4").action((name, opts) => {
-    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
-    if (!(0, import_node_fs12.existsSync)(taskDir)) {
+    const taskDir = (0, import_node_path10.join)(tasksDir2(ctx), name);
+    if (!(0, import_node_fs11.existsSync)(taskDir)) {
       exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     }
     if (!opts.yes) {
@@ -8248,7 +8207,7 @@ function registerNtfMonitor(ntf, ctx) {
       });
       process.exit(1);
     }
-    (0, import_node_fs12.rmSync)(taskDir, { recursive: true, force: true });
+    (0, import_node_fs11.rmSync)(taskDir, { recursive: true, force: true });
     output({
       ok: true,
       name,
@@ -8260,7 +8219,7 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("enable <name>").description("\u542F\u7528\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path10.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = true;
@@ -8268,7 +8227,7 @@ function registerNtfMonitor(ntf, ctx) {
     output({ ok: true, name, enabled: true });
   });
   monitor.command("disable <name>").description("\u6682\u505C\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path10.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = false;
@@ -8312,9 +8271,9 @@ function registerLightSend(light) {
 }
 
 // src/cli/light-setup-tools.ts
-var import_node_fs13 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path12 = require("path");
+var import_node_path11 = require("path");
 function isObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -8328,7 +8287,7 @@ function ensureArray(obj, key) {
 function resolveConfigPath2() {
   const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
   if (fromEnv) return fromEnv;
-  return (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
+  return (0, import_node_path11.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
 }
 var LIGHT_TOOLS = [
   "light_control",
@@ -8375,12 +8334,12 @@ function upsertLightControlAlsoAllow(cfg) {
 function registerLightSetupTools(light) {
   light.command("setup").description("\u81EA\u52A8\u653E\u884C light_control\uFF08\u5199\u5165 tools.alsoAllow \u4E0E agents.main.tools.alsoAllow\uFF09").action(() => {
     const configPath = resolveConfigPath2();
-    if (!(0, import_node_fs13.existsSync)(configPath)) {
+    if (!(0, import_node_fs12.existsSync)(configPath)) {
       exitError("CONFIG_NOT_FOUND", `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
     }
     let cfg = {};
     try {
-      const raw = (0, import_node_fs13.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs12.readFileSync)(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (isObject(parsed)) cfg = parsed;
     } catch (err2) {
@@ -8388,8 +8347,8 @@ function registerLightSetupTools(light) {
     }
     const result = upsertLightControlAlsoAllow(cfg);
     try {
-      (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(configPath), { recursive: true });
-      (0, import_node_fs13.writeFileSync)(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+      (0, import_node_fs12.mkdirSync)((0, import_node_path11.dirname)(configPath), { recursive: true });
+      (0, import_node_fs12.writeFileSync)(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
     } catch (err2) {
       exitError("WRITE_FAILED", `\u5199\u5165\u914D\u7F6E\u5931\u8D25: ${err2?.message ?? String(err2)}`);
     }
@@ -8407,17 +8366,17 @@ function registerLightSetupTools(light) {
 }
 
 // src/cli/tunnel-status.ts
-var import_node_fs14 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_path12 = require("path");
 init_credentials();
 init_env();
-var STATUS_REL_PATH = (0, import_node_path13.join)("plugins", "phone-notifications", "tunnel-status.json");
+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_path13.join)(ctx.stateDir, STATUS_REL_PATH);
-  if (!(0, import_node_fs14.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path12.join)(ctx.stateDir, STATUS_REL_PATH);
+  if (!(0, import_node_fs13.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs14.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs13.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -8485,24 +8444,24 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-var import_node_fs15 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs14 = require("fs");
+var import_node_path13 = require("path");
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = (0, import_node_path14.join)(
+    const dir = (0, import_node_path13.join)(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "logs"
     );
-    if ((0, import_node_fs15.existsSync)(dir)) return dir;
+    if ((0, import_node_fs14.existsSync)(dir)) return dir;
   }
   return null;
 }
 function listLogDateKeys(dir) {
   const pattern = /^(\d{4}-\d{2}-\d{2})\.log$/;
   const keys = [];
-  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true })) {
     if (!entry.isFile()) continue;
     const m = pattern.exec(entry.name);
     if (m) keys.push(m[1]);
@@ -8510,9 +8469,9 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = (0, import_node_path14.join)(dir, `${dateKey}.log`);
-  if (!(0, import_node_fs15.existsSync)(filePath)) return;
-  const content = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
+  const filePath = (0, import_node_path13.join)(dir, `${dateKey}.log`);
+  if (!(0, import_node_fs14.existsSync)(filePath)) return;
+  const content = (0, import_node_fs14.readFileSync)(filePath, "utf-8");
   const lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split("\n")) {
     if (collected.length >= limit) return;
@@ -8579,12 +8538,12 @@ function registerEnvCli(ntf) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs19 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_readline = require("readline");
 init_host();
 
 // src/cli/doctor/check-dangerous-flags.ts
-var import_node_fs16 = require("fs");
+var import_node_fs15 = require("fs");
 function isObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
@@ -8601,13 +8560,13 @@ var checkDangerousFlags = ({ cfg, configPath }) => {
     detail: "\u8FD9\u4F1A\u5173\u95ED Control UI \u7684\u8BBE\u5907\u8EAB\u4EFD\u9A8C\u8BC1\uFF0C\u4EFB\u4F55\u4EBA\u90FD\u53EF\u4EE5\u8BBF\u95EE\u63A7\u5236\u9762\u677F\u3002",
     fixDescription: "\u8BBE\u4E3A false",
     fix: () => {
-      const raw = (0, import_node_fs16.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs15.readFileSync)(configPath, "utf-8");
       const config = JSON.parse(raw);
       const gw = config.gateway;
       const cui = gw.controlUi;
       cui.dangerouslyDisableDeviceAuth = false;
-      (0, import_node_fs16.copyFileSync)(configPath, configPath + ".bak");
-      (0, import_node_fs16.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      (0, import_node_fs15.copyFileSync)(configPath, configPath + ".bak");
+      (0, import_node_fs15.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     }
   };
 };
@@ -8655,11 +8614,11 @@ function warnEmpty() {
 }
 
 // src/cli/doctor/check-state-dir-perms.ts
-var import_node_fs17 = require("fs");
+var import_node_fs16 = require("fs");
 var checkStateDirPerms = ({ stateDir }) => {
   let mode;
   try {
-    mode = (0, import_node_fs17.statSync)(stateDir).mode;
+    mode = (0, import_node_fs16.statSync)(stateDir).mode;
   } catch {
     return null;
   }
@@ -8673,7 +8632,7 @@ var checkStateDirPerms = ({ stateDir }) => {
     detail: "\u5176\u4ED6\u7528\u6237\u53EF\u4EE5\u8BFB\u53D6\u8BE5\u76EE\u5F55\u4E0B\u7684\u51ED\u8BC1\u548C\u914D\u7F6E\u6587\u4EF6\u3002",
     fixDescription: "chmod 700 " + stateDir,
     fix: () => {
-      (0, import_node_fs17.chmodSync)(stateDir, 448);
+      (0, import_node_fs16.chmodSync)(stateDir, 448);
     }
   };
 };
@@ -8728,16 +8687,16 @@ var checkCredentials = () => {
 };
 
 // src/cli/doctor/check-tunnel.ts
-var import_node_fs18 = require("fs");
-var import_node_path15 = require("path");
-var STATUS_REL_PATH2 = (0, import_node_path15.join)(
+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_path15.join)(stateDir, STATUS_REL_PATH2);
-  if (!(0, import_node_fs18.existsSync)(filePath)) {
+  const filePath = (0, import_node_path14.join)(stateDir, STATUS_REL_PATH2);
+  if (!(0, import_node_fs17.existsSync)(filePath)) {
     return {
       id: "tunnel",
       severity: "warn",
@@ -8749,7 +8708,7 @@ var checkTunnel = ({ stateDir }) => {
   }
   let status;
   try {
-    status = JSON.parse((0, import_node_fs18.readFileSync)(filePath, "utf-8"));
+    status = JSON.parse((0, import_node_fs17.readFileSync)(filePath, "utf-8"));
   } catch {
     return {
       id: "tunnel",
@@ -8842,9 +8801,9 @@ function isObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function readConfig(configPath) {
-  if (!(0, import_node_fs19.existsSync)(configPath)) return {};
+  if (!(0, import_node_fs18.existsSync)(configPath)) return {};
   try {
-    const parsed = JSON.parse((0, import_node_fs19.readFileSync)(configPath, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs18.readFileSync)(configPath, "utf-8"));
     return isObject5(parsed) ? parsed : {};
   } catch {
     return {};
@@ -9045,7 +9004,7 @@ function registerRecStoragePath(rec, ctx) {
 
 // src/cli/rec-setup.ts
 var import_node_readline2 = require("readline");
-var import_node_fs20 = require("fs");
+var import_node_fs19 = require("fs");
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
@@ -9131,9 +9090,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_fs20.existsSync)(configPath)) {
+    if ((0, import_node_fs19.existsSync)(configPath)) {
       try {
-        const existing = JSON.parse((0, import_node_fs20.readFileSync)(configPath, "utf-8"));
+        const existing = JSON.parse((0, import_node_fs19.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");
@@ -9146,7 +9105,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_fs20.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
+      (0, import_node_fs19.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
       process.stderr.write(`
 \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${configPath}
 
@@ -9160,8 +9119,8 @@ function registerRecSetup(rec, ctx) {
 
 // src/cli/update.ts
 var import_node_child_process = require("child_process");
-var import_node_fs21 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs20 = require("fs");
+var import_node_path15 = require("path");
 var import_node_os3 = __toESM(require("os"), 1);
 init_host();
 var BASE_URL2 = "https://artifact.yoooclaw.com/plugin";
@@ -9220,9 +9179,9 @@ async function runUpdate(ctx, opts) {
 `);
     process.exit(1);
   }
-  const tmpScript = (0, import_node_path16.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
+  const tmpScript = (0, import_node_path15.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
   try {
-    (0, import_node_fs21.writeFileSync)(tmpScript, installScript, "utf-8");
+    (0, import_node_fs20.writeFileSync)(tmpScript, installScript, "utf-8");
   } catch (err2) {
     const msg = `\u5199\u5165\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${err2?.message ?? String(err2)}`;
     if (json) {
@@ -9240,7 +9199,7 @@ async function runUpdate(ctx, opts) {
     { stdio: "inherit" }
   );
   try {
-    (0, import_node_fs21.unlinkSync)(tmpScript);
+    (0, import_node_fs20.unlinkSync)(tmpScript);
   } catch {
   }
   if (result.error) {
@@ -9304,10 +9263,10 @@ function inferOpenClawRootDir(workspaceDir) {
   if (!workspaceDir) {
     return void 0;
   }
-  if ((0, import_node_path17.basename)(workspaceDir) !== "workspace") {
+  if ((0, import_node_path16.basename)(workspaceDir) !== "workspace") {
     return void 0;
   }
-  return (0, import_node_path17.dirname)(workspaceDir);
+  return (0, import_node_path16.dirname)(workspaceDir);
 }
 function registerPluginCli(api, params) {
   const { logger, openclawDir } = params;
@@ -9558,12 +9517,12 @@ function registerLightControlTool(api, logger) {
 }
 
 // src/plugin/lifecycle.ts
-var import_node_fs31 = require("fs");
+var import_node_fs30 = require("fs");
 init_host();
 
 // src/notification/app-name-map.ts
-var import_node_fs22 = require("fs");
-var import_node_path18 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path17 = require("path");
 init_credentials();
 init_env();
 var PLUGIN_STATE_DIR = "phone-notifications";
@@ -9584,7 +9543,7 @@ function isAppNameMapApiResponse(v) {
   );
 }
 function getCachePath(stateDir) {
-  return (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+  return (0, import_node_path17.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
 }
 function createAppNameMapProvider(opts) {
   const { stateDir, logger } = opts;
@@ -9596,9 +9555,9 @@ function createAppNameMapProvider(opts) {
   let inFlightFetch = null;
   function loadFromDisk() {
     const path2 = getCachePath(stateDir);
-    if (!(0, import_node_fs22.existsSync)(path2)) return;
+    if (!(0, import_node_fs21.existsSync)(path2)) return;
     try {
-      const raw = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs21.readFileSync)(path2, "utf-8"));
       if (!isRecordOfStrings(raw)) return;
       map.clear();
       for (const [k, v] of Object.entries(raw)) map.set(k, v);
@@ -9642,10 +9601,10 @@ function createAppNameMapProvider(opts) {
         logger.warn("[app-name-map] refresh succeeded but got 0 entries");
         return;
       }
-      const dir = (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
-      (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_node_path17.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
+      (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
       const cachePath = getCachePath(stateDir);
-      (0, import_node_fs22.writeFileSync)(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      (0, import_node_fs21.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);
@@ -9689,19 +9648,19 @@ function createAppNameMapProvider(opts) {
 }
 
 // src/notification/storage.ts
-var import_node_fs23 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_crypto2 = require("crypto");
-var import_node_path19 = require("path");
+var import_node_path18 = require("path");
 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_path19.join)(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
+  return (0, import_node_path18.join)(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
 }
 function ensureWritableDirectory(dir) {
   try {
-    (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs23.accessSync)(dir, import_node_fs23.constants.R_OK | import_node_fs23.constants.W_OK);
+    (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);
     return true;
   } catch {
     return false;
@@ -9714,7 +9673,7 @@ function resolveNotificationStorageDir(ctx, logger) {
     return stateNotifDir;
   }
   if (ctx.workspaceDir) {
-    const workspaceDir = (0, import_node_path19.join)(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
+    const workspaceDir = (0, import_node_path18.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}`
@@ -9729,8 +9688,8 @@ var NotificationStorage = class {
     this.config = config;
     this.logger = logger;
     this.dir = dir;
-    this.idIndexDir = (0, import_node_path19.join)(dir, ID_INDEX_DIR_NAME);
-    this.contentKeyIndexDir = (0, import_node_path19.join)(dir, CONTENT_KEY_INDEX_DIR_NAME);
+    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.resolveDisplayName = resolveDisplayName;
   }
   dir;
@@ -9741,10 +9700,10 @@ var NotificationStorage = class {
   dateWriteChains = /* @__PURE__ */ new Map();
   resolveDisplayName;
   async init() {
-    (0, import_node_fs23.mkdirSync)(this.dir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.idIndexDir, { recursive: true });
-    (0, import_node_fs23.rmSync)(this.contentKeyIndexDir, { recursive: true, force: true });
-    (0, import_node_fs23.mkdirSync)(this.contentKeyIndexDir, { recursive: true });
+    (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 });
   }
   async ingest(items) {
     const result = {
@@ -9783,7 +9742,7 @@ var NotificationStorage = class {
       return { kind: "invalid" };
     }
     const dateKey = this.formatDate(ts);
-    const filePath = (0, import_node_path19.join)(this.dir, `${dateKey}.json`);
+    const filePath = (0, import_node_path18.join)(this.dir, `${dateKey}.json`);
     const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
     const entry = this.buildStoredNotification(n);
     return this.withDateWriteLock(dateKey, async () => {
@@ -9800,7 +9759,7 @@ var NotificationStorage = class {
       };
       const arr = this.readStoredNotifications(filePath);
       arr.push(storedEntry);
-      (0, import_node_fs23.writeFileSync)(filePath, JSON.stringify(arr, null, 2), "utf-8");
+      (0, import_node_fs22.writeFileSync)(filePath, JSON.stringify(arr, null, 2), "utf-8");
       if (normalizedId) {
         this.recordNotificationId(dateKey, normalizedId);
       }
@@ -9837,7 +9796,7 @@ var NotificationStorage = class {
     return `${year}-${month}-${day}`;
   }
   getIdIndexPath(dateKey) {
-    return (0, import_node_path19.join)(this.idIndexDir, `${dateKey}.ids`);
+    return (0, import_node_path18.join)(this.idIndexDir, `${dateKey}.ids`);
   }
   getIdSet(dateKey) {
     const cached = this.idCache.get(dateKey);
@@ -9846,8 +9805,8 @@ var NotificationStorage = class {
     }
     const idPath = this.getIdIndexPath(dateKey);
     const ids = /* @__PURE__ */ new Set();
-    if ((0, import_node_fs23.existsSync)(idPath)) {
-      const lines = (0, import_node_fs23.readFileSync)(idPath, "utf-8").split(/\r?\n/);
+    if ((0, import_node_fs22.existsSync)(idPath)) {
+      const lines = (0, import_node_fs22.readFileSync)(idPath, "utf-8").split(/\r?\n/);
       for (const line of lines) {
         const id = line.trim();
         if (id) {
@@ -9862,7 +9821,7 @@ var NotificationStorage = class {
     return this.getIdSet(dateKey).has(id);
   }
   getContentKeyIndexPath(dateKey) {
-    return (0, import_node_path19.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
+    return (0, import_node_path18.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
   }
   getContentKeySet(dateKey, filePath) {
     const cached = this.contentKeyCache.get(dateKey);
@@ -9871,16 +9830,16 @@ var NotificationStorage = class {
     }
     const keyPath = this.getContentKeyIndexPath(dateKey);
     const keys = /* @__PURE__ */ new Set();
-    if ((0, import_node_fs23.existsSync)(filePath)) {
+    if ((0, import_node_fs22.existsSync)(filePath)) {
       for (const item of this.readStoredNotifications(filePath)) {
         keys.add(this.buildNotificationContentKey(item));
       }
     }
     if (keys.size > 0) {
-      (0, import_node_fs23.writeFileSync)(keyPath, `${Array.from(keys).join("\n")}
+      (0, import_node_fs22.writeFileSync)(keyPath, `${Array.from(keys).join("\n")}
 `, "utf-8");
-    } else if ((0, import_node_fs23.existsSync)(keyPath)) {
-      (0, import_node_fs23.rmSync)(keyPath, { force: true });
+    } else if ((0, import_node_fs22.existsSync)(keyPath)) {
+      (0, import_node_fs22.rmSync)(keyPath, { force: true });
     }
     this.contentKeyCache.set(dateKey, keys);
     return keys;
@@ -9895,7 +9854,7 @@ var NotificationStorage = class {
     if (ids.has(id)) {
       return;
     }
-    (0, import_node_fs23.appendFileSync)(this.getIdIndexPath(dateKey), `${id}
+    (0, import_node_fs22.appendFileSync)(this.getIdIndexPath(dateKey), `${id}
 `, "utf-8");
     ids.add(id);
   }
@@ -9905,7 +9864,7 @@ var NotificationStorage = class {
     if (keys.has(key)) {
       return;
     }
-    (0, import_node_fs23.appendFileSync)(this.getContentKeyIndexPath(dateKey), `${key}
+    (0, import_node_fs22.appendFileSync)(this.getContentKeyIndexPath(dateKey), `${key}
 `, "utf-8");
     keys.add(key);
   }
@@ -9913,11 +9872,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_fs23.existsSync)(filePath)) {
+    if (!(0, import_node_fs22.existsSync)(filePath)) {
       return [];
     }
     try {
-      const parsed = JSON.parse((0, import_node_fs23.readFileSync)(filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs22.readFileSync)(filePath, "utf-8"));
       return Array.isArray(parsed) ? parsed : [];
     } catch {
       return [];
@@ -9957,14 +9916,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_fs23.readdirSync)(this.dir, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs22.readdirSync)(this.dir, { withFileTypes: true })) {
         if (entry.isFile()) {
           const match = dateFilePattern.exec(entry.name);
           if (match && match[1] < cutoffDate) {
-            (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.name), { force: true });
+            (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.name), { force: true });
           }
         } else if (entry.isDirectory() && dateDirPattern.test(entry.name) && entry.name < cutoffDate) {
-          (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.name), { recursive: true, force: true });
+          (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.dir, entry.name), { recursive: true, force: true });
         }
       }
     } catch {
@@ -9973,11 +9932,11 @@ var NotificationStorage = class {
   /** Remove expired .ids index files */
   pruneIdIndex(cutoffDate) {
     try {
-      for (const entry of (0, import_node_fs23.readdirSync)(this.idIndexDir, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs22.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_fs23.rmSync)((0, import_node_path19.join)(this.idIndexDir, entry.name), { force: true });
+          (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.idIndexDir, entry.name), { force: true });
           this.idCache.delete(match[1]);
         }
       }
@@ -9986,11 +9945,11 @@ var NotificationStorage = class {
   }
   pruneContentKeyIndex(cutoffDate) {
     try {
-      for (const entry of (0, import_node_fs23.readdirSync)(this.contentKeyIndexDir, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs22.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_fs23.rmSync)((0, import_node_path19.join)(this.contentKeyIndexDir, entry.name), { force: true });
+          (0, import_node_fs22.rmSync)((0, import_node_path18.join)(this.contentKeyIndexDir, entry.name), { force: true });
           this.contentKeyCache.delete(match[1]);
         }
       }
@@ -10005,8 +9964,8 @@ var NotificationStorage = class {
 };
 
 // src/recording/storage.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");
 
 // src/recording/state-machine.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -10067,7 +10026,7 @@ function stripMarkdownFence(markdown) {
 }
 function deriveTitleFromTranscriptPath(transcriptFile, recordingId) {
   if (!transcriptFile) return void 0;
-  const name = (0, import_node_path20.basename)(transcriptFile, ".md");
+  const name = (0, import_node_path19.basename)(transcriptFile, ".md");
   const prefix = `${recordingId}_`;
   if (name.startsWith(prefix)) {
     const derived = name.slice(prefix.length).trim();
@@ -10095,22 +10054,22 @@ function extractTranscriptContent(markdown) {
   return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 function resolveRecordingStorageDir(ctx, logger) {
-  const stateRecDir = (0, import_node_path20.join)(
+  const stateRecDir = (0, import_node_path19.join)(
     ctx.stateDir,
     "plugins",
     "phone-notifications",
     RECORDINGS_DIR
   );
   try {
-    (0, import_node_fs24.mkdirSync)(stateRecDir, { recursive: true });
+    (0, import_node_fs23.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_path20.join)(ctx.workspaceDir, RECORDINGS_DIR);
+    const wsRecDir = (0, import_node_path19.join)(ctx.workspaceDir, RECORDINGS_DIR);
     try {
-      (0, import_node_fs24.mkdirSync)(wsRecDir, { recursive: true });
+      (0, import_node_fs23.mkdirSync)(wsRecDir, { recursive: true });
       logger.warn(`stateDir \u4E0D\u53EF\u7528\uFF0C\u5F55\u97F3\u5DF2\u56DE\u9000\u5230 workspace \u8DEF\u5F84: ${wsRecDir}`);
       return wsRecDir;
     } catch {
@@ -10122,11 +10081,11 @@ var RecordingStorage = class {
   constructor(dir, logger) {
     this.logger = logger;
     this.dir = dir;
-    this.audioDir = (0, import_node_path20.join)(dir, AUDIO_DIR);
-    this.transcriptDataDir = (0, import_node_path20.join)(dir, TRANSCRIPT_DATA_DIR);
-    this.transcriptsDir = (0, import_node_path20.join)(dir, TRANSCRIPTS_DIR);
-    this.summariesDir = (0, import_node_path20.join)(dir, SUMMARIES_DIR);
-    this.indexPath = (0, import_node_path20.join)(dir, INDEX_FILE);
+    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);
   }
   dir;
   audioDir;
@@ -10137,10 +10096,10 @@ var RecordingStorage = class {
   index = { recordings: [] };
   /** 初始化目录结构并加载索引 */
   async init() {
-    (0, import_node_fs24.mkdirSync)(this.audioDir, { recursive: true });
-    (0, import_node_fs24.mkdirSync)(this.transcriptDataDir, { recursive: true });
-    (0, import_node_fs24.mkdirSync)(this.transcriptsDir, { recursive: true });
-    (0, import_node_fs24.mkdirSync)(this.summariesDir, { recursive: true });
+    (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 });
     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`
@@ -10184,13 +10143,13 @@ var RecordingStorage = class {
         return id;
       }
       if (existing.transcriptDataFile) {
-        (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, existing.transcriptDataFile), { force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptDataFile), { force: true });
       }
       if (existing.transcriptFile) {
-        (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, existing.transcriptFile), { force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptFile), { force: true });
       }
       if (existing.summaryFile) {
-        (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, existing.summaryFile), { force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.summaryFile), { force: true });
       }
       existing.metadata = metadata;
       existing.status = "syncing_openclaw";
@@ -10258,7 +10217,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptDataFile = `${TRANSCRIPT_DATA_DIR}/${filename}`;
     if (entry.transcriptDataFile && entry.transcriptDataFile !== nextTranscriptDataFile) {
-      (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, entry.transcriptDataFile), { force: true });
+      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptDataFile), { force: true });
     }
     entry.transcriptDataFile = nextTranscriptDataFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10272,7 +10231,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptFile = `${TRANSCRIPTS_DIR}/${filename}`;
     if (entry.transcriptFile && entry.transcriptFile !== nextTranscriptFile) {
-      (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, entry.transcriptFile), { force: true });
+      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptFile), { force: true });
     }
     entry.transcriptFile = nextTranscriptFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10286,7 +10245,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextSummaryFile = `${SUMMARIES_DIR}/${filename}`;
     if (entry.summaryFile && entry.summaryFile !== nextSummaryFile) {
-      (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, entry.summaryFile), { force: true });
+      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.summaryFile), { force: true });
     }
     entry.summaryFile = nextSummaryFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10384,24 +10343,24 @@ var RecordingStorage = class {
     const entry = this.findById(recordingId);
     if (!entry) return false;
     if (entry.audioFile) {
-      const audioPath = (0, import_node_path20.join)(this.dir, entry.audioFile);
-      (0, import_node_fs24.rmSync)(audioPath, { force: true });
+      const audioPath = (0, import_node_path19.join)(this.dir, entry.audioFile);
+      (0, import_node_fs23.rmSync)(audioPath, { force: true });
     }
     if (entry.srtFile) {
-      const srtPath = (0, import_node_path20.join)(this.dir, entry.srtFile);
-      (0, import_node_fs24.rmSync)(srtPath, { force: true });
+      const srtPath = (0, import_node_path19.join)(this.dir, entry.srtFile);
+      (0, import_node_fs23.rmSync)(srtPath, { force: true });
     }
     if (entry.transcriptDataFile) {
-      const transcriptDataPath = (0, import_node_path20.join)(this.dir, entry.transcriptDataFile);
-      (0, import_node_fs24.rmSync)(transcriptDataPath, { force: true });
+      const transcriptDataPath = (0, import_node_path19.join)(this.dir, entry.transcriptDataFile);
+      (0, import_node_fs23.rmSync)(transcriptDataPath, { force: true });
     }
     if (entry.transcriptFile) {
-      const transcriptPath = (0, import_node_path20.join)(this.dir, entry.transcriptFile);
-      (0, import_node_fs24.rmSync)(transcriptPath, { force: true });
+      const transcriptPath = (0, import_node_path19.join)(this.dir, entry.transcriptFile);
+      (0, import_node_fs23.rmSync)(transcriptPath, { force: true });
     }
     if (entry.summaryFile) {
-      const summaryPath = (0, import_node_path20.join)(this.dir, entry.summaryFile);
-      (0, import_node_fs24.rmSync)(summaryPath, { force: true });
+      const summaryPath = (0, import_node_path19.join)(this.dir, entry.summaryFile);
+      (0, import_node_fs23.rmSync)(summaryPath, { force: true });
     }
     if (opts?.localOnly) {
       entry.audioFile = void 0;
@@ -10459,34 +10418,34 @@ var RecordingStorage = class {
    * 获取音频文件的绝对路径。ossUrl 用于推断文件扩展名
    */
   getAudioFilePath(recordingId, ossUrl) {
-    return (0, import_node_path20.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
+    return (0, import_node_path19.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
   }
   /**
    * 获取打点文件的绝对路径
    */
   getSrtFilePath(recordingId) {
-    return (0, import_node_path20.join)(this.audioDir, this.buildSrtFilename(recordingId));
+    return (0, import_node_path19.join)(this.audioDir, this.buildSrtFilename(recordingId));
   }
   /**
    * 获取转写 JSON 文件的绝对路径
    */
   getTranscriptDataFilePath(recordingId) {
-    return (0, import_node_path20.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
+    return (0, import_node_path19.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
   }
   /**
    * 获取摘要文件的绝对路径
    */
   getSummaryFilePath(recordingId) {
-    return (0, import_node_path20.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
+    return (0, import_node_path19.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
   }
   // ─── Persistence ───
   loadIndex() {
-    if (!(0, import_node_fs24.existsSync)(this.indexPath)) {
+    if (!(0, import_node_fs23.existsSync)(this.indexPath)) {
       this.index = { recordings: [] };
       return;
     }
     try {
-      const raw = JSON.parse((0, import_node_fs24.readFileSync)(this.indexPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs23.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) => {
@@ -10524,8 +10483,8 @@ var RecordingStorage = class {
                 segments: []
               });
               const transcriptDataFilename = this.buildTranscriptDataFilename(compacted.id);
-              (0, import_node_fs24.writeFileSync)(
-                (0, import_node_path20.join)(this.transcriptDataDir, transcriptDataFilename),
+              (0, import_node_fs23.writeFileSync)(
+                (0, import_node_path19.join)(this.transcriptDataDir, transcriptDataFilename),
                 JSON.stringify(transcriptDoc, null, 2),
                 "utf-8"
               );
@@ -10537,8 +10496,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_fs24.writeFileSync)(
-              (0, import_node_path20.join)(this.summariesDir, summaryFilename),
+            (0, import_node_fs23.writeFileSync)(
+              (0, import_node_path19.join)(this.summariesDir, summaryFilename),
               entry.summary.trim(),
               "utf-8"
             );
@@ -10548,8 +10507,8 @@ var RecordingStorage = class {
             const summaryFromDocument = extractTranscriptSummaryFromDocument(transcriptDoc);
             if (summaryFromDocument) {
               const summaryFilename = this.buildSummaryFilename(entry.id);
-              (0, import_node_fs24.writeFileSync)(
-                (0, import_node_path20.join)(this.summariesDir, summaryFilename),
+              (0, import_node_fs23.writeFileSync)(
+                (0, import_node_path19.join)(this.summariesDir, summaryFilename),
                 summaryFromDocument,
                 "utf-8"
               );
@@ -10589,7 +10548,7 @@ var RecordingStorage = class {
   }
   readRelativeTextFile(relativePath) {
     try {
-      return (0, import_node_fs24.readFileSync)((0, import_node_path20.join)(this.dir, relativePath), "utf-8");
+      return (0, import_node_fs23.readFileSync)((0, import_node_path19.join)(this.dir, relativePath), "utf-8");
     } catch {
       return void 0;
     }
@@ -10602,7 +10561,7 @@ var RecordingStorage = class {
     return parseTranscriptDocument(raw);
   }
   saveIndex() {
-    (0, import_node_fs24.writeFileSync)(
+    (0, import_node_fs23.writeFileSync)(
       this.indexPath,
       JSON.stringify(this.index, null, 2),
       "utf-8"
@@ -10616,8 +10575,8 @@ var RecordingStorage = class {
 init_transcript_document();
 
 // src/recording/downloader.ts
-var import_node_fs25 = require("fs");
-var import_node_path21 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path20 = require("path");
 var import_promises2 = require("stream/promises");
 var import_node_stream = require("stream");
 var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
@@ -10627,7 +10586,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_fs25.mkdirSync)((0, import_node_path21.dirname)(destPath), { recursive: true });
+  (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(destPath), { recursive: true });
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     const startMs = Date.now();
@@ -10645,11 +10604,11 @@ async function downloadFile(url, destPath, logger, options) {
         if (!res.body) {
           throw new Error("\u54CD\u5E94\u4F53\u4E3A\u7A7A");
         }
-        const writeStream = (0, import_node_fs25.createWriteStream)(destPath);
+        const writeStream = (0, import_node_fs24.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_fs25.existsSync)(destPath) ? (0, import_node_fs25.statSync)(destPath).size : 0;
+        const fileSize = (0, import_node_fs24.existsSync)(destPath) ? (0, import_node_fs24.statSync)(destPath).size : 0;
         logger.info(
           `[downloader] \u4E0B\u8F7D\u5B8C\u6210: ${destPath} (${formatBytes(fileSize)}, ${elapsed}ms)`
         );
@@ -10660,7 +10619,7 @@ async function downloadFile(url, destPath, logger, options) {
     } catch (err2) {
       lastError = err2?.message ?? String(err2);
       try {
-        if ((0, import_node_fs25.existsSync)(destPath)) (0, import_node_fs25.unlinkSync)(destPath);
+        if ((0, import_node_fs24.existsSync)(destPath)) (0, import_node_fs24.unlinkSync)(destPath);
       } catch {
       }
       const isAbort = err2?.name === "AbortError";
@@ -10898,13 +10857,13 @@ async function triggerTranscription(recordingId, storage, asrConfig, logger, opt
 }
 
 // src/tunnel/service.ts
-var import_node_fs30 = require("fs");
-var import_node_path26 = require("path");
+var import_node_fs29 = require("fs");
+var import_node_path25 = require("path");
 init_credentials();
 
 // src/tunnel/relay-client.ts
-var import_node_fs28 = require("fs");
-var import_node_path24 = require("path");
+var import_node_fs27 = require("fs");
+var import_node_path23 = require("path");
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -10948,8 +10907,8 @@ var RelayClient = class {
       lastDisconnectReason
     };
     try {
-      (0, import_node_fs28.mkdirSync)((0, import_node_path24.dirname)(this.opts.statusFilePath), { recursive: true });
-      (0, import_node_fs28.writeFileSync)(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      (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));
     } catch {
     }
   }
@@ -11331,8 +11290,8 @@ init_host();
 
 // src/tunnel/device-identity.ts
 var import_node_crypto3 = __toESM(require("crypto"), 1);
-var import_node_fs29 = __toESM(require("fs"), 1);
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_fs28 = __toESM(require("fs"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 init_host();
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 function base64UrlEncode(buf) {
@@ -11377,10 +11336,10 @@ function resolveClientStateDir(stateDir) {
   return stateDir ?? resolveStateDir();
 }
 function ensureDir(filePath) {
-  import_node_fs29.default.mkdirSync(import_node_path25.default.dirname(filePath), { recursive: true });
+  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
 }
 function resolveIdentityPath(stateDir) {
-  return import_node_path25.default.join(stateDir, "identity", "device.json");
+  return import_node_path24.default.join(stateDir, "identity", "device.json");
 }
 function normalizeDeviceAuthRole(role) {
   return role.trim();
@@ -11396,12 +11355,12 @@ function normalizeDeviceAuthScopes(scopes) {
   return [...out].sort();
 }
 function resolveDeviceAuthPath(stateDir) {
-  return import_node_path25.default.join(stateDir, "identity", "device-auth.json");
+  return import_node_path24.default.join(stateDir, "identity", "device-auth.json");
 }
 function readDeviceAuthStore(filePath) {
   try {
-    if (!import_node_fs29.default.existsSync(filePath)) return null;
-    const raw = import_node_fs29.default.readFileSync(filePath, "utf8");
+    if (!import_node_fs28.default.existsSync(filePath)) return null;
+    const raw = import_node_fs28.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;
@@ -11412,12 +11371,12 @@ function readDeviceAuthStore(filePath) {
 }
 function writeDeviceAuthStore(filePath, store) {
   ensureDir(filePath);
-  import_node_fs29.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
+  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
   try {
-    import_node_fs29.default.chmodSync(filePath, 384);
+    import_node_fs28.default.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -11464,8 +11423,8 @@ function clearDeviceAuthToken(params) {
 function loadOrCreateDeviceIdentity(stateDir) {
   const filePath = resolveIdentityPath(stateDir);
   try {
-    if (import_node_fs29.default.existsSync(filePath)) {
-      const raw = import_node_fs29.default.readFileSync(filePath, "utf8");
+    if (import_node_fs28.default.existsSync(filePath)) {
+      const raw = import_node_fs28.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);
@@ -11486,14 +11445,14 @@ function loadOrCreateDeviceIdentity(stateDir) {
     publicKeyPem,
     privateKeyPem
   };
-  import_node_fs29.default.mkdirSync(import_node_path25.default.dirname(filePath), { recursive: true });
+  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
   const stored = {
     version: 1,
     ...identity,
     createdAtMs: Date.now()
   };
   ensureDir(filePath);
-  import_node_fs29.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
+  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
 `, {
     mode: 384
   });
@@ -12265,7 +12224,7 @@ function createTunnelService(opts) {
   }
   function readLockOwner(filePath) {
     try {
-      const parsed = JSON.parse((0, import_node_fs30.readFileSync)(filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs29.readFileSync)(filePath, "utf-8"));
       return typeof parsed.pid === "number" ? parsed.pid : null;
     } catch {
       return null;
@@ -12278,23 +12237,23 @@ function createTunnelService(opts) {
     lockFd = null;
     if (fd !== null) {
       try {
-        (0, import_node_fs30.closeSync)(fd);
+        (0, import_node_fs29.closeSync)(fd);
       } catch {
       }
     }
     if (filePath) {
       try {
-        (0, import_node_fs30.unlinkSync)(filePath);
+        (0, import_node_fs29.unlinkSync)(filePath);
       } catch {
       }
     }
   }
   function acquireLock(filePath) {
-    (0, import_node_fs30.mkdirSync)((0, import_node_path26.dirname)(filePath), { recursive: true });
+    (0, import_node_fs29.mkdirSync)((0, import_node_path25.dirname)(filePath), { recursive: true });
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const fd = (0, import_node_fs30.openSync)(filePath, "wx", 384);
-        (0, import_node_fs30.writeFileSync)(
+        const fd = (0, import_node_fs29.openSync)(filePath, "wx", 384);
+        (0, import_node_fs29.writeFileSync)(
           fd,
           JSON.stringify({
             pid: process.pid,
@@ -12318,7 +12277,7 @@ function createTunnelService(opts) {
             `Relay tunnel: removing stale local lock owned by dead pid=${ownerPid}`
           );
           try {
-            (0, import_node_fs30.unlinkSync)(filePath);
+            (0, import_node_fs29.unlinkSync)(filePath);
           } catch {
           }
           continue;
@@ -12363,12 +12322,12 @@ function createTunnelService(opts) {
         return;
       }
       const { logger } = opts;
-      const baseStateDir = (0, import_node_path26.join)(ctx.stateDir, "plugins", "phone-notifications");
+      const baseStateDir = (0, import_node_path25.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_path26.join)(baseStateDir, "tunnel-status.json");
-      const lockPath = (0, import_node_path26.join)(baseStateDir, "relay-tunnel.lock");
+      const statusFilePath = (0, import_node_path25.join)(baseStateDir, "tunnel-status.json");
+      const lockPath = (0, import_node_path25.join)(baseStateDir, "relay-tunnel.lock");
       if (!acquireLock(lockPath)) {
         return;
       }
@@ -12508,7 +12467,7 @@ function readHostGatewayConfig(params) {
   let configData;
   if (configPath) {
     try {
-      configData = JSON.parse((0, import_node_fs31.readFileSync)(configPath, "utf-8"));
+      configData = JSON.parse((0, import_node_fs30.readFileSync)(configPath, "utf-8"));
     } catch (err2) {
       if (err2?.code !== "ENOENT") {
         params.logger.warn(
@@ -13270,7 +13229,6 @@ var index_default = {
         recordingStorage = nextRecordingStorage;
       },
       onStorageReady() {
-        migrateLegacyLightRuleTasks(lightRuleCtx, logger);
         lightRuleRegistry.reload();
       }
     });