@yoooclaw/phone-notifications 1.11.0-beta.0 → 1.11.0-beta.2

package/dist/index.cjs

@@ -52,24 +52,24 @@ function expandUserPath(value) {
     return homeDir();
   }
   if (value.startsWith("~/")) {
-    return (0, import_node_path5.join)(homeDir(), value.slice(2));
+    return (0, import_node_path4.join)(homeDir(), value.slice(2));
   }
   return value;
 }
 function candidateMetaPaths() {
   const home = homeDir();
   return [
-    (0, import_node_path5.join)(home, ".qclaw", "qclaw.json"),
-    (0, import_node_path5.join)(home, ".qclow", "qclaw.json")
+    (0, import_node_path4.join)(home, ".qclaw", "qclaw.json"),
+    (0, import_node_path4.join)(home, ".qclow", "qclaw.json")
   ];
 }
 function loadQClawMeta() {
   for (const metaPath of candidateMetaPaths()) {
-    if (!(0, import_node_fs6.existsSync)(metaPath)) {
+    if (!(0, import_node_fs5.existsSync)(metaPath)) {
       continue;
     }
     try {
-      const parsed = JSON.parse((0, import_node_fs6.readFileSync)(metaPath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs5.readFileSync)(metaPath, "utf-8"));
       return {
         stateDir: expandUserPath(trimToUndefined(parsed?.stateDir)),
         configPath: expandUserPath(trimToUndefined(parsed?.configPath))
@@ -90,12 +90,12 @@ function resolveConfigPathFromEnv() {
   );
 }
 function hasOpenClawMarkers() {
-  const baseDir = (0, import_node_path5.join)(homeDir(), ".openclaw");
+  const baseDir = (0, import_node_path4.join)(homeDir(), ".openclaw");
   return [
-    (0, import_node_path5.join)(baseDir, "openclaw.json"),
-    (0, import_node_path5.join)(baseDir, "credentials.json"),
-    (0, import_node_path5.join)(baseDir, "extensions")
-  ].some((candidate) => (0, import_node_fs6.existsSync)(candidate));
+    (0, import_node_path4.join)(baseDir, "openclaw.json"),
+    (0, import_node_path4.join)(baseDir, "credentials.json"),
+    (0, import_node_path4.join)(baseDir, "extensions")
+  ].some((candidate) => (0, import_node_fs5.existsSync)(candidate));
 }
 function resolveStateDir() {
   const envDir = resolveStateDirFromEnv();
@@ -103,16 +103,16 @@ function resolveStateDir() {
     return envDir;
   }
   if (hasOpenClawMarkers()) {
-    return (0, import_node_path5.join)(homeDir(), ".openclaw");
+    return (0, import_node_path4.join)(homeDir(), ".openclaw");
   }
   const meta = loadQClawMeta();
   if (meta?.stateDir) {
     return meta.stateDir;
   }
   if (meta?.configPath) {
-    return (0, import_node_path5.dirname)(meta.configPath);
+    return (0, import_node_path4.dirname)(meta.configPath);
   }
-  return (0, import_node_path5.join)(homeDir(), ".openclaw");
+  return (0, import_node_path4.join)(homeDir(), ".openclaw");
 }
 function resolveConfigPath(stateDir = resolveStateDir()) {
   const envConfigPath = resolveConfigPathFromEnv();
@@ -123,17 +123,17 @@ function resolveConfigPath(stateDir = resolveStateDir()) {
   if (meta?.configPath && (!meta.stateDir || !stateDir || meta.stateDir === stateDir)) {
     return meta.configPath;
   }
-  return (0, import_node_path5.join)(stateDir, "openclaw.json");
+  return (0, import_node_path4.join)(stateDir, "openclaw.json");
 }
 function resolveStateFile(filename) {
-  return (0, import_node_path5.join)(resolveStateDir(), filename);
+  return (0, import_node_path4.join)(resolveStateDir(), filename);
 }
-var import_node_fs6, import_node_path5;
+var import_node_fs5, import_node_path4;
 var init_host = __esm({
   "src/host.ts"() {
     "use strict";
-    import_node_fs6 = require("fs");
-    import_node_path5 = require("path");
+    import_node_fs5 = require("fs");
+    import_node_path4 = require("path");
   }
 });
 
@@ -143,17 +143,17 @@ function credentialsPath() {
 }
 function readCredentials() {
   const path2 = credentialsPath();
-  if (!(0, import_node_fs7.existsSync)(path2)) return {};
+  if (!(0, import_node_fs6.existsSync)(path2)) return {};
   try {
-    return JSON.parse((0, import_node_fs7.readFileSync)(path2, "utf-8"));
+    return JSON.parse((0, import_node_fs6.readFileSync)(path2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCredentials(creds) {
   const path2 = credentialsPath();
-  (0, import_node_fs7.mkdirSync)((0, import_node_path6.dirname)(path2), { recursive: true, mode: 448 });
-  (0, import_node_fs7.writeFileSync)(path2, JSON.stringify(creds, null, 2), {
+  (0, import_node_fs6.mkdirSync)((0, import_node_path5.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs6.writeFileSync)(path2, JSON.stringify(creds, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
@@ -173,8 +173,8 @@ function requireApiKey() {
 }
 function watchCredentials(onChange) {
   const path2 = credentialsPath();
-  const dir = (0, import_node_path6.dirname)(path2);
-  const filename = (0, import_node_path6.basename)(path2);
+  const dir = (0, import_node_path5.dirname)(path2);
+  const filename = (0, import_node_path5.basename)(path2);
   let debounceTimer = null;
   const delayMs = 200;
   const listener = (_event, changedName) => {
@@ -187,7 +187,7 @@ function watchCredentials(onChange) {
   };
   let watcher = null;
   try {
-    watcher = (0, import_node_fs7.watch)(dir, { persistent: false }, listener);
+    watcher = (0, import_node_fs6.watch)(dir, { persistent: false }, listener);
   } catch {
   }
   return () => {
@@ -195,12 +195,12 @@ function watchCredentials(onChange) {
     watcher?.close();
   };
 }
-var import_node_fs7, import_node_path6;
+var import_node_fs6, import_node_path5;
 var init_credentials = __esm({
   "src/auth/credentials.ts"() {
     "use strict";
-    import_node_fs7 = require("fs");
-    import_node_path6 = require("path");
+    import_node_fs6 = require("fs");
+    import_node_path5 = require("path");
     init_host();
   }
 });
@@ -208,8 +208,8 @@ var init_credentials = __esm({
 // src/env.ts
 function writeDotEnv(key, value) {
   const path2 = resolveStateFile(".env");
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true });
-  const existing = (0, import_node_fs8.existsSync)(path2) ? (0, import_node_fs8.readFileSync)(path2, "utf-8") : "";
+  (0, import_node_fs7.mkdirSync)((0, import_node_path6.dirname)(path2), { recursive: true });
+  const existing = (0, import_node_fs7.existsSync)(path2) ? (0, import_node_fs7.readFileSync)(path2, "utf-8") : "";
   const lines = existing.split("\n");
   const prefix = `${key}=`;
   const idx = lines.findIndex((l) => l.startsWith(prefix));
@@ -220,13 +220,13 @@ function writeDotEnv(key, value) {
     if (existing && !existing.endsWith("\n")) lines.push("");
     lines.push(newLine);
   }
-  (0, import_node_fs8.writeFileSync)(path2, lines.join("\n"), "utf-8");
+  (0, import_node_fs7.writeFileSync)(path2, lines.join("\n"), "utf-8");
 }
 function readDotEnv() {
   const path2 = resolveStateFile(".env");
-  if (!(0, import_node_fs8.existsSync)(path2)) return {};
+  if (!(0, import_node_fs7.existsSync)(path2)) return {};
   return Object.fromEntries(
-    (0, import_node_fs8.readFileSync)(path2, "utf-8").split("\n").flatMap((line) => {
+    (0, import_node_fs7.readFileSync)(path2, "utf-8").split("\n").flatMap((line) => {
       const eq = line.indexOf("=");
       if (eq < 1) return [];
       return [[line.slice(0, eq).trim(), line.slice(eq + 1).trim()]];
@@ -256,12 +256,12 @@ function getEnvUrls(env) {
 function getAvailableEnvs() {
   return Object.keys(ENV_CONFIG);
 }
-var import_node_fs8, import_node_path7, ENV_CONFIG, VALID_ENVS;
+var import_node_fs7, import_node_path6, ENV_CONFIG, VALID_ENVS;
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
-    import_node_fs8 = require("fs");
-    import_node_path7 = require("path");
+    import_node_fs7 = require("fs");
+    import_node_path6 = require("path");
     init_credentials();
     init_host();
     ENV_CONFIG = {
@@ -290,7 +290,7 @@ function buildTranscriptDataFilename(recordingId) {
 }
 function buildTranscriptDocument(params) {
   const segments = normalizeSegments(params.segments);
-  const text = normalizeOptionalText(params.text) ?? joinSegmentsText(segments) ?? "";
+  const text = normalizePossiblyEmptyText(params.text) ?? joinSegmentsText(segments) ?? "";
   return {
     schemaVersion: TRANSCRIPT_DOCUMENT_SCHEMA_VERSION,
     recordingId: params.recordingId,
@@ -304,7 +304,7 @@ function buildTranscriptDocument(params) {
     normalized: {
       title: normalizeOptionalText(params.title),
       category: normalizeOptionalText(params.category),
-      summary: normalizeOptionalText(params.summary),
+      summary: normalizePossiblyEmptyText(params.summary),
       text,
       segments
     },
@@ -335,11 +335,11 @@ function parseTranscriptDocument(value) {
 }
 function extractTranscriptTextFromDocument(doc) {
   if (!doc) return void 0;
-  return normalizeOptionalText(doc.normalized.text) ?? joinSegmentsText(doc.normalized.segments);
+  return normalizePossiblyEmptyText(doc.normalized.text) ?? joinSegmentsText(doc.normalized.segments);
 }
 function extractTranscriptSummaryFromDocument(doc) {
   if (!doc) return void 0;
-  return normalizeOptionalText(doc.normalized.summary);
+  return normalizePossiblyEmptyText(doc.normalized.summary);
 }
 function extractTranscriptTitleFromDocument(doc) {
   if (!doc) return void 0;
@@ -392,14 +392,14 @@ function normalizeDocumentBody(value) {
   }
   const normalized = value;
   const segments = normalizeSegments(normalized.segments);
-  const text = normalizeOptionalText(normalized.text) ?? joinSegmentsText(segments);
-  if (!text) {
+  const text = normalizePossiblyEmptyText(normalized.text) ?? joinSegmentsText(segments);
+  if (text === void 0) {
     return void 0;
   }
   return {
     title: normalizeOptionalText(normalized.title),
     category: normalizeOptionalText(normalized.category),
-    summary: normalizeOptionalText(normalized.summary),
+    summary: normalizePossiblyEmptyText(normalized.summary),
     text,
     segments
   };
@@ -465,6 +465,9 @@ function extractRawSourceTextList(raw) {
 function normalizeOptionalText(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function normalizePossiblyEmptyText(value) {
+  return typeof value === "string" ? value.trim() : void 0;
+}
 function normalizeOptionalNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -1342,7 +1345,7 @@ async function runTranscriptionWorkflow(params) {
     return { ok: false, error: result.error };
   }
   const title = normalizeOptionalText2(result.summary) ? normalizeOptionalText2(result.summary) : extractSummary(result.text ?? "");
-  const summary = normalizeOptionalText2(result.summaryText);
+  const summary = result.summaryText ?? "";
   result.summary = title;
   const transcriptData = buildTranscriptDocument({
     recordingId,
@@ -1603,16 +1606,11 @@ function buildLongRecordingSuccessResult(taskId, requestId, data, logger) {
   );
   const listResult = extractLongRecordingTextFromList(sourceTextList);
   const sourceText = normalizeOptionalText2(data?.recordResult?.sourceText);
-  const summaryText = normalizeOptionalText2(data?.recordResult?.summaryResult);
+  const summaryText = normalizeOptionalText2(data?.recordResult?.summaryResult) ?? "";
   const title = normalizeOptionalText2(data?.recordResult?.title);
   const category = normalizeOptionalText2(data?.recordResult?.category);
   const text = listResult.text ?? sourceText ?? summaryText;
-  if (!text) {
-    return {
-      ok: false,
-      error: "Model Proxy ASR \u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u4F46\u672A\u8FD4\u56DE sourceTextList\u3001sourceText \u6216 summaryResult"
-    };
-  }
+  const status = normalizeLongRecordingStatus(data?.status) ?? "SUCCEEDED";
   if (!listResult.text && !sourceText && summaryText) {
     logger.warn(
       `[asr] Model Proxy \u957F\u5F55\u97F3\u7ED3\u679C\u7F3A\u5C11 sourceTextList/sourceText\uFF0C\u5DF2\u56DE\u9000\u4F7F\u7528 summaryResult \u4F5C\u4E3A\u8F6C\u5199\u6587\u672C: taskId=${taskId}`
@@ -1632,7 +1630,7 @@ function buildLongRecordingSuccessResult(taskId, requestId, data, logger) {
       provider: "model-proxy",
       taskId,
       requestId,
-      status: "SUCCEEDED"
+      status
     },
     rawResponse: data
   };
@@ -5424,7 +5422,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.11.0-beta.0".trim();
+  const version = "1.11.0-beta.2".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -5549,1103 +5547,787 @@ function formatLocalTimestamp(d) {
   return `${y}-${m}-${day}T${hh}:${mm}:${ss}.${ms}${sign}${offsetHours}:${offsetMins}`;
 }
 
-// src/notification/storage.ts
+// src/light/repeat.ts
+function normalizeRepeatTimes(input) {
+  if (typeof input === "boolean") {
+    return input ? 0 : 1;
+  }
+  if (typeof input === "number") {
+    return validateRepeatTimes(input);
+  }
+  if (!input) {
+    return 1;
+  }
+  if (input.repeat_times !== void 0) {
+    return validateRepeatTimes(input.repeat_times);
+  }
+  if (input.repeat !== void 0) {
+    return input.repeat ? 0 : 1;
+  }
+  return 1;
+}
+function assertAncsRepeatTimes(repeatTimes) {
+  if (repeatTimes !== 0 && repeatTimes !== 1) {
+    throw new Error(
+      "\u5F53\u524D ANCS \u8DEF\u5F84\u4EC5\u652F\u6301 repeat_times=0\uFF08\u65E0\u9650\u5FAA\u73AF\uFF09\u6216 1\uFF08\u64AD\u653E\u4E00\u8F6E\uFF09\uFF1BN>=2 \u9700\u975E ANCS \u8DEF\u5F84"
+    );
+  }
+}
+function validateRepeatTimes(value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error("repeat_times \u5FC5\u987B\u662F >=0 \u7684\u6574\u6570");
+  }
+  return value;
+}
+
+// src/cli/helpers.ts
 var import_node_fs3 = require("fs");
-var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
 var import_node_path2 = 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_path2.join)(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
+function resolveNotificationsDir(ctx) {
+  if (ctx.stateDir) {
+    const dir = (0, import_node_path2.join)(
+      ctx.stateDir,
+      "plugins",
+      "phone-notifications",
+      "notifications"
+    );
+    if ((0, import_node_fs3.existsSync)(dir)) return dir;
+  }
+  if (ctx.workspaceDir) {
+    const dir = (0, import_node_path2.join)(ctx.workspaceDir, "notifications");
+    if ((0, import_node_fs3.existsSync)(dir)) return dir;
+  }
+  return null;
 }
-function ensureWritableDirectory(dir) {
+function listDateKeys(dir) {
+  const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
+  const keys = [];
+  for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    const m = pattern.exec(entry.name);
+    if (m) keys.push(m[1]);
+  }
+  return keys.sort().reverse();
+}
+function readDateFile(dir, dateKey) {
+  const filePath = (0, import_node_path2.join)(dir, `${dateKey}.json`);
+  if (!(0, import_node_fs3.existsSync)(filePath)) return [];
   try {
-    (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs3.accessSync)(dir, import_node_fs3.constants.R_OK | import_node_fs3.constants.W_OK);
-    return true;
+    return JSON.parse((0, import_node_fs3.readFileSync)(filePath, "utf-8"));
   } catch {
-    return false;
+    return [];
   }
 }
-function resolveNotificationStorageDir(ctx, logger) {
-  const stateNotifDir = getStateFallbackNotificationDir(ctx.stateDir);
-  if (ensureWritableDirectory(stateNotifDir)) {
-    logger.info(`\u901A\u77E5\u5C06\u5199\u5165 stateDir \u8DEF\u5F84: ${stateNotifDir}`);
-    return stateNotifDir;
+function today() {
+  return formatDate2(/* @__PURE__ */ new Date());
+}
+function formatDate2(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function daysAgo(n) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - n);
+  return formatDate2(d);
+}
+function filterDateRange(keys, from, to) {
+  return keys.filter((k) => k >= from && k <= to);
+}
+function parseIsoTime(value, optionName) {
+  const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})$/;
+  if (!isoPattern.test(value)) {
+    exitError(
+      "INVALID_TIME",
+      `${optionName} \u5FC5\u987B\u662F ISO 8601 \u65F6\u95F4\uFF0C\u4F8B\u5982 2026-03-01T09:00:00+08:00`
+    );
+  }
+  const ts = Date.parse(value);
+  if (Number.isNaN(ts)) {
+    exitError(
+      "INVALID_TIME",
+      `${optionName} \u4E0D\u662F\u5408\u6CD5\u65F6\u95F4\uFF0C\u4F8B\u5982 2026-03-01T09:00:00+08:00`
+    );
+  }
+  return ts;
+}
+function sortNotificationsByTimestampDesc(items) {
+  return items.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+}
+async function listDateKeysAsync(dir) {
+  const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
+  const keys = [];
+  const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const m = pattern.exec(entry.name);
+    if (m) keys.push(m[1]);
+  }
+  return keys.sort().reverse();
+}
+async function readDateFileAsync(dir, dateKey) {
+  const filePath = (0, import_node_path2.join)(dir, `${dateKey}.json`);
+  if (!(0, import_node_fs3.existsSync)(filePath)) return [];
+  try {
+    const content = await (0, import_promises.readFile)(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function progress(message) {
+  process.stderr.write(message + "\n");
+}
+function output(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function exitError(code, message) {
+  output({ ok: false, error: { code, message } });
+  process.exit(1);
+}
+function resolveRecordingsDir(ctx) {
+  if (ctx.stateDir) {
+    const dir = (0, import_node_path2.join)(
+      ctx.stateDir,
+      "plugins",
+      "phone-notifications",
+      "recordings"
+    );
+    if ((0, import_node_fs3.existsSync)(dir)) return dir;
   }
   if (ctx.workspaceDir) {
-    const workspaceDir = (0, import_node_path2.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}`
-      );
-      return workspaceDir;
-    }
+    const dir = (0, import_node_path2.join)(ctx.workspaceDir, "recordings");
+    if ((0, import_node_fs3.existsSync)(dir)) return dir;
   }
-  throw new Error(`\u901A\u77E5\u5B58\u50A8\u76EE\u5F55\u4E0D\u53EF\u7528: ${stateNotifDir}`);
+  return null;
 }
-var NotificationStorage = class {
-  constructor(dir, config, logger, resolveDisplayName) {
-    this.config = config;
-    this.logger = logger;
-    this.dir = dir;
-    this.idIndexDir = (0, import_node_path2.join)(dir, ID_INDEX_DIR_NAME);
-    this.contentKeyIndexDir = (0, import_node_path2.join)(dir, CONTENT_KEY_INDEX_DIR_NAME);
-    this.resolveDisplayName = resolveDisplayName;
+function resolveAsrConfigPath(ctx) {
+  let base;
+  if (ctx.stateDir) {
+    base = (0, import_node_path2.join)(ctx.stateDir, "plugins", "phone-notifications", "recordings");
+  } else if (ctx.workspaceDir) {
+    base = (0, import_node_path2.join)(ctx.workspaceDir, "recordings");
+  } else {
+    exitError(
+      "STORAGE_UNAVAILABLE",
+      "\u65E0\u6CD5\u786E\u5B9A\u5F55\u97F3\u5B58\u50A8\u76EE\u5F55\uFF1AstateDir \u548C workspaceDir \u5747\u672A\u8BBE\u7F6E"
+    );
   }
-  dir;
-  idIndexDir;
-  contentKeyIndexDir;
-  idCache = /* @__PURE__ */ new Map();
-  contentKeyCache = /* @__PURE__ */ new Map();
-  dateWriteChains = /* @__PURE__ */ new Map();
-  resolveDisplayName;
-  async init() {
-    (0, import_node_fs3.mkdirSync)(this.dir, { recursive: true });
-    (0, import_node_fs3.mkdirSync)(this.idIndexDir, { recursive: true });
-    (0, import_node_fs3.rmSync)(this.contentKeyIndexDir, { recursive: true, force: true });
-    (0, import_node_fs3.mkdirSync)(this.contentKeyIndexDir, { recursive: true });
+  (0, import_node_fs3.mkdirSync)(base, { recursive: true });
+  return (0, import_node_path2.join)(base, "asr-config.json");
+}
+function readRecordingIndex(dir) {
+  const indexPath = (0, import_node_path2.join)(dir, "index.json");
+  if (!(0, import_node_fs3.existsSync)(indexPath)) return [];
+  try {
+    const raw = JSON.parse((0, import_node_fs3.readFileSync)(indexPath, "utf-8"));
+    return Array.isArray(raw?.recordings) ? raw.recordings : [];
+  } catch {
+    return [];
   }
-  async ingest(items) {
-    const result = {
-      received: items.length,
-      ingested: 0,
-      dedupedById: 0,
-      dedupedByContent: 0,
-      invalid: 0,
-      inserted: []
+}
+
+// src/light/validators.ts
+var VALID_MODES = [
+  "wave",
+  "breath",
+  "strobe",
+  "steady",
+  "wave_rainbow",
+  "pixel_frame"
+];
+var MAX_SEGMENTS = 12;
+function validateSegments(segments) {
+  if (!Array.isArray(segments)) {
+    return { valid: false, errors: [{ field: "segments", message: "\u5FC5\u987B\u662F\u6570\u7EC4" }] };
+  }
+  if (segments.length === 0) {
+    return { valid: false, errors: [{ field: "segments", message: "\u4E0D\u80FD\u4E3A\u7A7A" }] };
+  }
+  if (segments.length > MAX_SEGMENTS) {
+    return {
+      valid: false,
+      errors: [{ field: "segments", message: `\u6700\u591A ${MAX_SEGMENTS} \u6BB5` }]
     };
-    for (const n of items) {
-      const outcome = await this.writeNotification(n);
-      switch (outcome.kind) {
-        case "ingested":
-          result.ingested += 1;
-          result.inserted.push(outcome.entry);
-          break;
-        case "dedupedById":
-          result.dedupedById += 1;
-          break;
-        case "dedupedByContent":
-          result.dedupedByContent += 1;
-          break;
-        case "invalid":
-          result.invalid += 1;
-          break;
-      }
-    }
-    this.prune();
-    return result;
   }
-  async writeNotification(n) {
-    const ts = new Date(n.timestamp);
-    if (Number.isNaN(ts.getTime())) {
-      this.logger.warn(`\u5FFD\u7565\u975E\u6CD5 timestamp \u7684\u901A\u77E5: ${n.id}`);
-      return { kind: "invalid" };
-    }
-    const dateKey = this.formatDate(ts);
-    const filePath = (0, import_node_path2.join)(this.dir, `${dateKey}.json`);
-    const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
-    const entry = this.buildStoredNotification(n);
-    return this.withDateWriteLock(dateKey, async () => {
-      if (normalizedId && this.hasNotificationId(dateKey, normalizedId)) {
-        return { kind: "dedupedById" };
-      }
-      if (this.hasNotificationContentKey(dateKey, filePath, entry)) {
-        return { kind: "dedupedByContent" };
-      }
-      const appDisplayName = this.resolveDisplayName ? await this.resolveDisplayName(entry.appName) : entry.appName;
-      const storedEntry = {
-        ...entry,
-        appDisplayName
-      };
-      const arr = this.readStoredNotifications(filePath);
-      arr.push(storedEntry);
-      (0, import_node_fs3.writeFileSync)(filePath, JSON.stringify(arr, null, 2), "utf-8");
-      if (normalizedId) {
-        this.recordNotificationId(dateKey, normalizedId);
-      }
-      this.recordNotificationContentKey(dateKey, filePath, storedEntry);
-      return { kind: "ingested", entry: storedEntry };
-    });
+  const errors = [];
+  for (let i = 0; i < segments.length; i++) {
+    validateSegment(segments[i], `segments[${i}]`, errors);
   }
-  buildStoredNotification(n) {
-    return {
-      appName: typeof n.app === "string" && n.app ? n.app : "Unknown",
-      title: typeof n.title === "string" ? n.title : "",
-      content: this.buildContent(n),
-      timestamp: n.timestamp
-    };
+  if (errors.length > 0) return { valid: false, errors };
+  return { valid: true, segments };
+}
+function parseAndValidateSegments(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    exitError("VALIDATION_FAILED", "segments \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON");
   }
-  buildContent(n) {
-    const body = n.body?.trim();
-    if (body) {
-      return body;
-    }
-    const fallback = [];
-    if (n.category) {
-      fallback.push(`category:${n.category}`);
-    }
-    if (n.metadata && Object.keys(n.metadata).length > 0) {
-      fallback.push(`metadata:${JSON.stringify(n.metadata)}`);
-    }
-    return fallback.join(" ; ") || "-";
+  const result = validateSegments(parsed);
+  if (!result.valid) {
+    output({ ok: false, error: { code: "VALIDATION_FAILED", details: result.errors } });
+    process.exit(1);
   }
-  formatDate(d) {
-    const year = d.getFullYear();
-    const month = String(d.getMonth() + 1).padStart(2, "0");
-    const day = String(d.getDate()).padStart(2, "0");
-    return `${year}-${month}-${day}`;
+  return result.segments;
+}
+function validateSegment(seg, prefix, errors) {
+  if (!isRecord(seg)) {
+    errors.push({ field: prefix, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+    return;
   }
-  getIdIndexPath(dateKey) {
-    return (0, import_node_path2.join)(this.idIndexDir, `${dateKey}.ids`);
+  const mode = seg.mode;
+  if (!VALID_MODES.includes(mode)) {
+    errors.push({
+      field: `${prefix}.mode`,
+      message: `\u4E0D\u652F\u6301\u7684\u6A21\u5F0F '${String(mode)}'\uFF0C\u53EF\u9009\uFF1A${VALID_MODES.join("/")}`
+    });
   }
-  getIdSet(dateKey) {
-    const cached = this.idCache.get(dateKey);
-    if (cached) {
-      return cached;
-    }
-    const idPath = this.getIdIndexPath(dateKey);
-    const ids = /* @__PURE__ */ new Set();
-    if ((0, import_node_fs3.existsSync)(idPath)) {
-      const lines = (0, import_node_fs3.readFileSync)(idPath, "utf-8").split(/\r?\n/);
-      for (const line of lines) {
-        const id = line.trim();
-        if (id) {
-          ids.add(id);
-        }
+  validateNonNegativeNumber(seg.duration_s, `${prefix}.duration_s`, errors, "\u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57\uFF080 \u8868\u793A\u65E0\u9650\u65F6\u957F\uFF09");
+  switch (mode) {
+    case "wave":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
+      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
+      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
+      break;
+    case "wave_rainbow":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
+      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
+      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
+      if (!hasNonZeroRgb(seg.color) && !hasNonZeroRgb(seg.background)) {
+        errors.push({
+          field: prefix,
+          message: "wave_rainbow \u81F3\u5C11\u9700\u8981\u4E00\u7EC4\u975E\u96F6\u989C\u8272\u951A\u70B9\uFF08color \u6216 background\uFF09"
+        });
       }
-    }
-    this.idCache.set(dateKey, ids);
-    return ids;
+      break;
+    case "breath":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalBreathTiming(seg.breath_timing, `${prefix}.breath_timing`, errors);
+      break;
+    case "strobe":
+      validateForegroundSegment(seg, prefix, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      break;
+    case "steady":
+      validateForegroundSegment(seg, prefix, errors);
+      break;
+    case "pixel_frame":
+      validatePixelFrame(seg.pixels, `${prefix}.pixels`, errors);
+      break;
+    default:
+      validateOptionalNonNegativeNumber(seg.brightness, `${prefix}.brightness`, errors);
+      validateOptionalColor(seg.color, `${prefix}.color`, errors);
+      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
+      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
+      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
+      validateOptionalBreathTiming(seg.breath_timing, `${prefix}.breath_timing`, errors);
+      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
   }
-  hasNotificationId(dateKey, id) {
-    return this.getIdSet(dateKey).has(id);
+}
+function validateForegroundSegment(seg, prefix, errors) {
+  validateNumberInRange(
+    seg.brightness,
+    `${prefix}.brightness`,
+    errors,
+    0,
+    255,
+    "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
+  );
+  validateColor(seg.color, `${prefix}.color`, errors);
+  if (seg.mode !== "steady" && seg.brightness === 0) {
+    errors.push({
+      field: `${prefix}.brightness`,
+      message: "brightness=0 \u4EC5 steady \u6A21\u5F0F\u5141\u8BB8\uFF1B\u5176\u5B83\u6A21\u5F0F\u4F1A\u5728\u56FA\u4EF6\u4FA7\u88AB\u8FC7\u6EE4"
+    });
   }
-  getContentKeyIndexPath(dateKey) {
-    return (0, import_node_path2.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
+}
+function validatePixelFrame(value, field, errors) {
+  if (!Array.isArray(value)) {
+    errors.push({ field, message: "pixel_frame \u5FC5\u987B\u63D0\u4F9B pixels \u6570\u7EC4\uFF081\u20137 \u9879\uFF09" });
+    return;
   }
-  getContentKeySet(dateKey, filePath) {
-    const cached = this.contentKeyCache.get(dateKey);
-    if (cached) {
-      return cached;
-    }
-    const keyPath = this.getContentKeyIndexPath(dateKey);
-    const keys = /* @__PURE__ */ new Set();
-    if ((0, import_node_fs3.existsSync)(filePath)) {
-      for (const item of this.readStoredNotifications(filePath)) {
-        keys.add(this.buildNotificationContentKey(item));
-      }
+  if (value.length < 1 || value.length > 7) {
+    errors.push({ field, message: "pixels \u5FC5\u987B\u4E3A 1\u20137 \u9879" });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < value.length; i++) {
+    const pixel = value[i];
+    const prefix = `${field}[${i}]`;
+    if (!isRecord(pixel)) {
+      errors.push({ field: prefix, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+      continue;
     }
-    if (keys.size > 0) {
-      (0, import_node_fs3.writeFileSync)(keyPath, `${Array.from(keys).join("\n")}
-`, "utf-8");
-    } else if ((0, import_node_fs3.existsSync)(keyPath)) {
-      (0, import_node_fs3.rmSync)(keyPath, { force: true });
+    const idx = pixel.index;
+    if (!Number.isInteger(idx) || idx < 0 || idx > 6) {
+      errors.push({ field: `${prefix}.index`, message: "index \u5FC5\u987B\u662F 0\u20136 \u7684\u6574\u6570" });
+    } else if (seen.has(idx)) {
+      errors.push({ field: `${prefix}.index`, message: `index=${idx} \u91CD\u590D` });
+    } else {
+      seen.add(idx);
     }
-    this.contentKeyCache.set(dateKey, keys);
-    return keys;
-  }
-  hasNotificationContentKey(dateKey, filePath, entry) {
-    return this.getContentKeySet(dateKey, filePath).has(
-      this.buildNotificationContentKey(entry)
+    validateNumberInRange(
+      pixel.brightness,
+      `${prefix}.brightness`,
+      errors,
+      0,
+      255,
+      "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
     );
+    validateColor(pixel.color, `${prefix}.color`, errors);
   }
-  recordNotificationId(dateKey, id) {
-    const ids = this.getIdSet(dateKey);
-    if (ids.has(id)) {
-      return;
-    }
-    (0, import_node_fs3.appendFileSync)(this.getIdIndexPath(dateKey), `${id}
-`, "utf-8");
-    ids.add(id);
+}
+function validateOptionalBreathTiming(value, field, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push({ field, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+    return;
   }
-  recordNotificationContentKey(dateKey, filePath, entry) {
-    const keys = this.getContentKeySet(dateKey, filePath);
-    const key = this.buildNotificationContentKey(entry);
-    if (keys.has(key)) {
-      return;
-    }
-    (0, import_node_fs3.appendFileSync)(this.getContentKeyIndexPath(dateKey), `${key}
-`, "utf-8");
-    keys.add(key);
-  }
-  buildNotificationContentKey(entry) {
-    return (0, import_node_crypto.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_fs3.existsSync)(filePath)) {
-      return [];
-    }
-    try {
-      const parsed = JSON.parse((0, import_node_fs3.readFileSync)(filePath, "utf-8"));
-      return Array.isArray(parsed) ? parsed : [];
-    } catch {
-      return [];
-    }
-  }
-  async withDateWriteLock(dateKey, task) {
-    const previous = this.dateWriteChains.get(dateKey) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => {
-      release = resolve;
-    });
-    const chain = previous.then(() => current);
-    this.dateWriteChains.set(dateKey, chain);
-    await previous;
-    try {
-      return await task();
-    } finally {
-      release();
-      if (this.dateWriteChains.get(dateKey) === chain) {
-        this.dateWriteChains.delete(dateKey);
-      }
-    }
-  }
-  prune() {
-    const retentionDays = this.config.retentionDays;
-    if (retentionDays === void 0) {
-      return;
-    }
-    const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
-    const cutoffDate = this.formatDate(new Date(cutoffMs));
-    this.pruneDataFiles(cutoffDate);
-    this.pruneIdIndex(cutoffDate);
-    this.pruneContentKeyIndex(cutoffDate);
-  }
-  /** Remove expired .json, legacy .md files, and legacy date directories */
-  pruneDataFiles(cutoffDate) {
-    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_fs3.readdirSync)(this.dir, { withFileTypes: true })) {
-        if (entry.isFile()) {
-          const match = dateFilePattern.exec(entry.name);
-          if (match && match[1] < cutoffDate) {
-            (0, import_node_fs3.rmSync)((0, import_node_path2.join)(this.dir, entry.name), { force: true });
-          }
-        } else if (entry.isDirectory() && dateDirPattern.test(entry.name) && entry.name < cutoffDate) {
-          (0, import_node_fs3.rmSync)((0, import_node_path2.join)(this.dir, entry.name), { recursive: true, force: true });
-        }
-      }
-    } catch {
-    }
-  }
-  /** Remove expired .ids index files */
-  pruneIdIndex(cutoffDate) {
-    try {
-      for (const entry of (0, import_node_fs3.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_fs3.rmSync)((0, import_node_path2.join)(this.idIndexDir, entry.name), { force: true });
-          this.idCache.delete(match[1]);
-        }
-      }
-    } catch {
-    }
-  }
-  pruneContentKeyIndex(cutoffDate) {
-    try {
-      for (const entry of (0, import_node_fs3.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_fs3.rmSync)((0, import_node_path2.join)(this.contentKeyIndexDir, entry.name), { force: true });
-          this.contentKeyCache.delete(match[1]);
-        }
-      }
-    } catch {
-    }
-  }
-  async close() {
-    this.idCache.clear();
-    this.contentKeyCache.clear();
-    this.dateWriteChains.clear();
-  }
-};
-
-// src/light/repeat.ts
-function normalizeRepeatTimes(input) {
-  if (typeof input === "boolean") {
-    return input ? 0 : 1;
-  }
-  if (typeof input === "number") {
-    return validateRepeatTimes(input);
-  }
-  if (!input) {
-    return 1;
-  }
-  if (input.repeat_times !== void 0) {
-    return validateRepeatTimes(input.repeat_times);
-  }
-  if (input.repeat !== void 0) {
-    return input.repeat ? 0 : 1;
-  }
-  return 1;
-}
-function assertAncsRepeatTimes(repeatTimes) {
-  if (repeatTimes !== 0 && repeatTimes !== 1) {
-    throw new Error(
-      "\u5F53\u524D ANCS \u8DEF\u5F84\u4EC5\u652F\u6301 repeat_times=0\uFF08\u65E0\u9650\u5FAA\u73AF\uFF09\u6216 1\uFF08\u64AD\u653E\u4E00\u8F6E\uFF09\uFF1BN>=2 \u9700\u975E ANCS \u8DEF\u5F84"
-    );
+  validatePositiveNumber(
+    value.rise_ms,
+    `${field}.rise_ms`,
+    errors,
+    "rise_ms \u5FC5\u987B\u662F >0 \u7684\u6570\u5B57\uFF08\u4E0D\u652F\u6301 0ms\uFF09"
+  );
+  validateNonNegativeNumber(
+    value.hold_ms,
+    `${field}.hold_ms`,
+    errors,
+    "hold_ms \u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57"
+  );
+  validatePositiveNumber(
+    value.fall_ms,
+    `${field}.fall_ms`,
+    errors,
+    "fall_ms \u5FC5\u987B\u662F >0 \u7684\u6570\u5B57\uFF08\u4E0D\u652F\u6301 0ms\uFF09"
+  );
+  validateNonNegativeNumber(
+    value.off_ms,
+    `${field}.off_ms`,
+    errors,
+    "off_ms \u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57"
+  );
+}
+function validateOptionalBackground(value, field, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push({ field, message: "\u5FC5\u987B\u5305\u542B r/g/b/brightness \u6570\u503C" });
+    return;
   }
+  validateColor(value, field, errors);
+  validateNumberInRange(
+    value.brightness,
+    `${field}.brightness`,
+    errors,
+    0,
+    255,
+    "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
+  );
 }
-function validateRepeatTimes(value) {
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error("repeat_times \u5FC5\u987B\u662F >=0 \u7684\u6574\u6570");
-  }
-  return value;
+function validateOptionalColor(value, field, errors) {
+  if (value === void 0) return;
+  validateColor(value, field, errors);
 }
-
-// src/cli/helpers.ts
-var import_node_fs4 = require("fs");
-var import_promises = require("fs/promises");
-var import_node_path3 = require("path");
-function resolveNotificationsDir(ctx) {
-  if (ctx.stateDir) {
-    const dir = (0, import_node_path3.join)(
-      ctx.stateDir,
-      "plugins",
-      "phone-notifications",
-      "notifications"
-    );
-    if ((0, import_node_fs4.existsSync)(dir)) return dir;
-  }
-  if (ctx.workspaceDir) {
-    const dir = (0, import_node_path3.join)(ctx.workspaceDir, "notifications");
-    if ((0, import_node_fs4.existsSync)(dir)) return dir;
+function validateColor(value, field, errors) {
+  if (!isRecord(value)) {
+    errors.push({ field, message: "\u5FC5\u987B\u5305\u542B r/g/b \u6570\u503C" });
+    return;
   }
-  return null;
+  validateNumberInRange(value.r, `${field}.r`, errors, 0, 255, "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57");
+  validateNumberInRange(value.g, `${field}.g`, errors, 0, 255, "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57");
+  validateNumberInRange(value.b, `${field}.b`, errors, 0, 255, "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57");
 }
-function listDateKeys(dir) {
-  const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
-  const keys = [];
-  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
-    if (!entry.isFile()) continue;
-    const m = pattern.exec(entry.name);
-    if (m) keys.push(m[1]);
+function validateOptionalDirection(value, field, errors) {
+  if (value === void 0) return;
+  if (value !== "ltr" && value !== "rtl") {
+    errors.push({ field, message: "direction \u5FC5\u987B\u662F ltr \u6216 rtl" });
   }
-  return keys.sort().reverse();
 }
-function readDateFile(dir, dateKey) {
-  const filePath = (0, import_node_path3.join)(dir, `${dateKey}.json`);
-  if (!(0, import_node_fs4.existsSync)(filePath)) return [];
-  try {
-    return JSON.parse((0, import_node_fs4.readFileSync)(filePath, "utf-8"));
-  } catch {
-    return [];
+function validateOptionalWindow(value, field, errors) {
+  if (value === void 0) return;
+  if (value !== 1 && value !== 2 && value !== 3) {
+    errors.push({ field, message: "window \u4EC5\u652F\u6301 1/2/3" });
   }
 }
-function today() {
-  return formatDate2(/* @__PURE__ */ new Date());
-}
-function formatDate2(d) {
-  const y = d.getFullYear();
-  const m = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  return `${y}-${m}-${day}`;
-}
-function daysAgo(n) {
-  const d = /* @__PURE__ */ new Date();
-  d.setDate(d.getDate() - n);
-  return formatDate2(d);
-}
-function filterDateRange(keys, from, to) {
-  return keys.filter((k) => k >= from && k <= to);
+function validateOptionalNonNegativeNumber(value, field, errors) {
+  if (value === void 0) return;
+  validateNonNegativeNumber(value, field, errors, "\u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57");
 }
-function parseIsoTime(value, optionName) {
-  const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})$/;
-  if (!isoPattern.test(value)) {
-    exitError(
-      "INVALID_TIME",
-      `${optionName} \u5FC5\u987B\u662F ISO 8601 \u65F6\u95F4\uFF0C\u4F8B\u5982 2026-03-01T09:00:00+08:00`
-    );
-  }
-  const ts = Date.parse(value);
-  if (Number.isNaN(ts)) {
-    exitError(
-      "INVALID_TIME",
-      `${optionName} \u4E0D\u662F\u5408\u6CD5\u65F6\u95F4\uFF0C\u4F8B\u5982 2026-03-01T09:00:00+08:00`
-    );
+function validatePositiveNumber(value, field, errors, message) {
+  if (value === void 0) return;
+  if (!isFiniteNumber(value) || value <= 0) {
+    errors.push({ field, message });
   }
-  return ts;
-}
-function sortNotificationsByTimestampDesc(items) {
-  return items.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
 }
-async function listDateKeysAsync(dir) {
-  const pattern = /^(\d{4}-\d{2}-\d{2})\.json$/;
-  const keys = [];
-  const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const m = pattern.exec(entry.name);
-    if (m) keys.push(m[1]);
+function validateNonNegativeNumber(value, field, errors, message) {
+  if (!isFiniteNumber(value) || value < 0) {
+    errors.push({ field, message });
   }
-  return keys.sort().reverse();
 }
-async function readDateFileAsync(dir, dateKey) {
-  const filePath = (0, import_node_path3.join)(dir, `${dateKey}.json`);
-  if (!(0, import_node_fs4.existsSync)(filePath)) return [];
-  try {
-    const content = await (0, import_promises.readFile)(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return [];
+function validateNumberInRange(value, field, errors, min, max, message) {
+  if (!isFiniteNumber(value) || value < min || value > max) {
+    errors.push({ field, message });
   }
 }
-function progress(message) {
-  process.stderr.write(message + "\n");
-}
-function output(data) {
-  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+function hasNonZeroRgb(value) {
+  if (!value) return false;
+  return [value.r, value.g, value.b].some((channel) => isFiniteNumber(channel) && channel > 0);
 }
-function exitError(code, message) {
-  output({ ok: false, error: { code, message } });
-  process.exit(1);
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
 }
-function resolveRecordingsDir(ctx) {
-  if (ctx.stateDir) {
-    const dir = (0, import_node_path3.join)(
-      ctx.stateDir,
-      "plugins",
-      "phone-notifications",
-      "recordings"
-    );
-    if ((0, import_node_fs4.existsSync)(dir)) return dir;
-  }
-  if (ctx.workspaceDir) {
-    const dir = (0, import_node_path3.join)(ctx.workspaceDir, "recordings");
-    if ((0, import_node_fs4.existsSync)(dir)) return dir;
-  }
-  return null;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function resolveAsrConfigPath(ctx) {
-  let base;
-  if (ctx.stateDir) {
-    base = (0, import_node_path3.join)(ctx.stateDir, "plugins", "phone-notifications", "recordings");
-  } else if (ctx.workspaceDir) {
-    base = (0, import_node_path3.join)(ctx.workspaceDir, "recordings");
-  } else {
-    exitError(
-      "STORAGE_UNAVAILABLE",
-      "\u65E0\u6CD5\u786E\u5B9A\u5F55\u97F3\u5B58\u50A8\u76EE\u5F55\uFF1AstateDir \u548C workspaceDir \u5747\u672A\u8BBE\u7F6E"
-    );
-  }
-  (0, import_node_fs4.mkdirSync)(base, { recursive: true });
-  return (0, import_node_path3.join)(base, "asr-config.json");
+
+// src/light-rules/storage.ts
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
+
+// src/monitor/fetch-gen.ts
+function generateFetchPy(name, matchRules) {
+  const appName = typeof matchRules.appName === "string" ? matchRules.appName : "";
+  const senderKeywords = stringArray(matchRules.senderKeywords);
+  const contentKeywords = stringArray(matchRules.contentKeywords);
+  return `#!/usr/bin/env python3
+"""Auto-generated fetch script for monitor task: ${name}"""
+import json, sys, os
+from pathlib import Path
+
+def matches(notification: dict) -> bool:
+    app = str(notification.get("appName", "") or "")
+    title = str(notification.get("title", "") or "")
+    content = str(notification.get("content", "") or "")
+    body = str(notification.get("body", "") or "")
+
+    app_name = ${pyLiteral(appName)}
+    if app_name and app != app_name:
+        return False
+
+    sender_keywords = ${pyLiteral(senderKeywords)}
+    sender_haystack = f"{title}\\n{content}\\n{body}"
+    if sender_keywords and not any(keyword in sender_haystack for keyword in sender_keywords):
+        return False
+
+    content_keywords = ${pyLiteral(contentKeywords)}
+    content_haystack = f"{content}\\n{body}"
+    if content_keywords and not any(keyword in content_haystack for keyword in content_keywords):
+        return False
+
+    return True
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--notifications-dir", required=True)
+    args = parser.parse_args()
+
+    checkpoint_path = Path(__file__).parent / "checkpoint.json"
+    checkpoint = {}
+    if checkpoint_path.exists():
+        checkpoint = json.loads(checkpoint_path.read_text())
+
+    ntf_dir = Path(args.notifications_dir)
+    matched = []
+    new_checkpoint = dict(checkpoint)
+
+    for f in sorted(ntf_dir.glob("*.json")):
+        date_key = f.stem
+        items = json.loads(f.read_text())
+        last_idx = checkpoint.get(date_key, {}).get("lastIndex", -1)
+        for i, item in enumerate(items):
+            if i <= last_idx:
+                continue
+            if matches(item):
+                matched.append(item)
+        new_checkpoint[date_key] = {"lastIndex": len(items) - 1}
+
+    checkpoint_path.write_text(json.dumps(new_checkpoint, indent=2))
+
+    if not matched:
+        print("NO_MATCH")
+        return
+
+    for m in matched:
+        print(json.dumps(m, ensure_ascii=False))
+
+if __name__ == "__main__":
+    main()
+`;
 }
-function readRecordingIndex(dir) {
-  const indexPath = (0, import_node_path3.join)(dir, "index.json");
-  if (!(0, import_node_fs4.existsSync)(indexPath)) return [];
-  try {
-    const raw = JSON.parse((0, import_node_fs4.readFileSync)(indexPath, "utf-8"));
-    return Array.isArray(raw?.recordings) ? raw.recordings : [];
-  } catch {
-    return [];
-  }
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+function pyLiteral(value) {
+  return JSON.stringify(value);
 }
 
-// src/light/validators.ts
-var VALID_MODES = [
-  "wave",
-  "breath",
-  "strobe",
-  "steady",
-  "wave_rainbow",
-  "pixel_frame"
-];
-var MAX_SEGMENTS = 12;
-function validateSegments(segments) {
-  if (!Array.isArray(segments)) {
-    return { valid: false, errors: [{ field: "segments", message: "\u5FC5\u987B\u662F\u6570\u7EC4" }] };
-  }
-  if (segments.length === 0) {
-    return { valid: false, errors: [{ field: "segments", message: "\u4E0D\u80FD\u4E3A\u7A7A" }] };
+// src/light-rules/storage.ts
+var LEGACY_DEFAULT_CRON_SCHEDULE = "*/5 * * * *";
+function legacyReadMatchRules(input) {
+  return input.matchRules ?? {};
+}
+function legacyReadCronSchedule(input) {
+  return input.cronSchedule ?? LEGACY_DEFAULT_CRON_SCHEDULE;
+}
+function legacyHasMatchRules(input) {
+  return input.matchRules !== void 0;
+}
+function legacyHasCronSchedule(input) {
+  return input.cronSchedule !== void 0;
+}
+function legacyAssignMatchRules(meta, matchRules) {
+  meta.matchRules = matchRules;
+}
+function legacyAssignCronSchedule(meta, cronSchedule) {
+  meta.cronSchedule = cronSchedule;
+}
+function legacyReadMetaMatchRules(meta) {
+  return meta.matchRules ?? {};
+}
+function legacyReadMetaCronSchedule(meta) {
+  return meta.cronSchedule;
+}
+function resolveBaseDir(ctx) {
+  if (ctx.workspaceDir) return ctx.workspaceDir;
+  if (ctx.stateDir) {
+    const inferredWorkspaceDir = (0, import_node_path3.join)(ctx.stateDir, "workspace");
+    if ((0, import_node_fs4.existsSync)(inferredWorkspaceDir)) return inferredWorkspaceDir;
+    return ctx.stateDir;
   }
-  if (segments.length > MAX_SEGMENTS) {
+  throw new Error("workspaceDir and stateDir both unavailable");
+}
+function tasksDir(ctx) {
+  return (0, import_node_path3.join)(resolveBaseDir(ctx), "tasks");
+}
+function normalizeLightRuleLookupName(name) {
+  return name.trim().replace(/\.json$/i, "");
+}
+function resolveLightRuleTask(ctx, name) {
+  const dir = tasksDir(ctx);
+  const normalizedName = normalizeLightRuleLookupName(name);
+  if (!normalizedName) return null;
+  const directTaskDir = (0, import_node_path3.join)(dir, normalizedName);
+  const directMeta = readMeta(directTaskDir);
+  if (directMeta) {
     return {
-      valid: false,
-      errors: [{ field: "segments", message: `\u6700\u591A ${MAX_SEGMENTS} \u6BB5` }]
+      taskDir: directTaskDir,
+      meta: directMeta
     };
   }
-  const errors = [];
-  for (let i = 0; i < segments.length; i++) {
-    validateSegment(segments[i], `segments[${i}]`, errors);
+  if (!(0, import_node_fs4.existsSync)(dir)) return null;
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const taskDir = (0, import_node_path3.join)(dir, entry.name);
+    const meta = readMeta(taskDir);
+    if (meta?.name === normalizedName) {
+      return {
+        taskDir,
+        meta
+      };
+    }
   }
-  if (errors.length > 0) return { valid: false, errors };
-  return { valid: true, segments };
+  return null;
 }
-function parseAndValidateSegments(json) {
-  let parsed;
+function readOptionalString(value) {
+  if (typeof value !== "string") return void 0;
+  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 {
-    parsed = JSON.parse(json);
+    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 (!Array.isArray(raw.segments)) return null;
+    const name = readOptionalString(raw.name) ?? (0, import_node_path3.basename)(taskDir);
+    const description = readOptionalString(raw.description) ?? readOptionalString(raw.reason) ?? 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({
+      repeat: raw.repeat,
+      repeat_times: raw.repeat_times
+    });
+    assertAncsRepeatTimes(repeatTimes);
+    return {
+      ...raw,
+      name,
+      type: "light-rule",
+      description,
+      segments: raw.segments,
+      repeat_times: repeatTimes,
+      enabled,
+      createdAt
+    };
   } catch {
-    exitError("VALIDATION_FAILED", "segments \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON");
-  }
-  const result = validateSegments(parsed);
-  if (!result.valid) {
-    output({ ok: false, error: { code: "VALIDATION_FAILED", details: result.errors } });
-    process.exit(1);
+    return null;
   }
-  return result.segments;
 }
-function validateSegment(seg, prefix, errors) {
-  if (!isRecord(seg)) {
-    errors.push({ field: prefix, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
-    return;
+function writeMeta(taskDir, meta) {
+  (0, import_node_fs4.writeFileSync)((0, import_node_path3.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+}
+function generateLightRuleReadme(name, description, segments, repeatTimes) {
+  const segmentsJson = JSON.stringify(segments, null, 2);
+  return `# ${name}
+
+## \u76D1\u63A7\u76EE\u6807
+
+${description}
+
+## \u89E6\u53D1\u540E\u5982\u4F55\u5904\u7406
+
+\u5F53\u4EFB\u52A1\u811A\u672C\u8F93\u51FA\u5339\u914D\u7ED3\u679C\u65F6\uFF1A
+
+1. \u5C06\u8F93\u51FA\u6309"\u6BCF\u884C\u4E00\u4E2A JSON \u5BF9\u8C61"\u89E3\u6790
+2. \u8FD9\u4E9B\u662F\u5019\u9009\u901A\u77E5\uFF0C\u4E0D\u4EE3\u8868\u5DF2\u7ECF\u547D\u4E2D
+3. \u6839\u636E\u76D1\u63A7\u76EE\u6807\u5224\u65AD\u662F\u5426\u771F\u6B63\u547D\u4E2D
+
+**\u547D\u4E2D\u540E\u6267\u884C\u706F\u6548**\uFF1A\u8C03\u7528 light_control \u5DE5\u5177\uFF0C\u4F20\u5165\u4EE5\u4E0B\u706F\u6548\u53C2\u6570\uFF1A
+
+\`\`\`json
+${segmentsJson}
+\`\`\`
+
+repeat_times: ${repeatTimes}
+reason: "${description}"
+
+\u53EA\u6267\u884C\u706F\u6548\uFF0C\u4E0D\u4E3B\u52A8\u53D1\u9001\u901A\u77E5\u6458\u8981\u6216\u56DE\u590D\u7528\u6237\u3002
+`;
+}
+function listLightRules(ctx) {
+  const dir = tasksDir(ctx);
+  if (!(0, import_node_fs4.existsSync)(dir)) return [];
+  const rules = [];
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const meta = readMeta((0, import_node_path3.join)(dir, entry.name));
+    if (meta) rules.push(meta);
   }
-  const mode = seg.mode;
-  if (!VALID_MODES.includes(mode)) {
-    errors.push({
-      field: `${prefix}.mode`,
-      message: `\u4E0D\u652F\u6301\u7684\u6A21\u5F0F '${String(mode)}'\uFF0C\u53EF\u9009\uFF1A${VALID_MODES.join("/")}`
-    });
+  return rules;
+}
+function createLightRule(ctx, params) {
+  const dir = tasksDir(ctx);
+  const taskDir = (0, import_node_path3.join)(dir, params.name);
+  if ((0, import_node_fs4.existsSync)(taskDir)) {
+    throw new LightRuleError("ALREADY_EXISTS", `\u706F\u6548\u89C4\u5219 '${params.name}' \u5DF2\u5B58\u5728`);
   }
-  validateNonNegativeNumber(seg.duration_s, `${prefix}.duration_s`, errors, "\u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57\uFF080 \u8868\u793A\u65E0\u9650\u65F6\u957F\uFF09");
-  switch (mode) {
-    case "wave":
-      validateForegroundSegment(seg, prefix, errors);
-      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
-      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
-      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
-      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
-      break;
-    case "wave_rainbow":
-      validateForegroundSegment(seg, prefix, errors);
-      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
-      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
-      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
-      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
-      if (!hasNonZeroRgb(seg.color) && !hasNonZeroRgb(seg.background)) {
-        errors.push({
-          field: prefix,
-          message: "wave_rainbow \u81F3\u5C11\u9700\u8981\u4E00\u7EC4\u975E\u96F6\u989C\u8272\u951A\u70B9\uFF08color \u6216 background\uFF09"
-        });
+  (0, import_node_fs4.mkdirSync)(taskDir, { recursive: true });
+  const repeatTimes = normalizeRepeatTimes({
+    repeat: params.repeat,
+    repeat_times: params.repeat_times
+  });
+  assertAncsRepeatTimes(repeatTimes);
+  const effectiveMatchRules = legacyReadMatchRules(params);
+  const effectiveCronSchedule = legacyReadCronSchedule(params);
+  const meta = {
+    name: params.name,
+    type: "light-rule",
+    description: params.description,
+    segments: params.segments,
+    repeat_times: repeatTimes,
+    enabled: true,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  legacyAssignMatchRules(meta, effectiveMatchRules);
+  legacyAssignCronSchedule(meta, effectiveCronSchedule);
+  writeMeta(taskDir, meta);
+  (0, import_node_fs4.writeFileSync)(
+    (0, import_node_path3.join)(taskDir, "fetch.py"),
+    generateFetchPy(params.name, effectiveMatchRules),
+    "utf-8"
+  );
+  (0, import_node_fs4.writeFileSync)(
+    (0, import_node_path3.join)(taskDir, "README.md"),
+    generateLightRuleReadme(params.name, params.description, params.segments, repeatTimes),
+    "utf-8"
+  );
+  return {
+    meta,
+    cronHint: {
+      action: "add",
+      job: {
+        name: `notif-${params.name}`,
+        schedule: effectiveCronSchedule,
+        sessionTarget: "isolated",
+        message: `\u624B\u673A\u901A\u77E5\u5DF2\u7531\u72EC\u7ACB\u670D\u52A1\u5B9E\u65F6\u6355\u83B7\u5230 notifications/ \u76EE\u5F55\u7684 JSON \u6587\u4EF6\u4E2D\u3002
+\u6267\u884C\uFF1Apython3 tasks/${params.name}/fetch.py --notifications-dir notifications
+- NO_CHANGE \u6216 NO_MATCH \u2192 \u4E0D\u56DE\u590D\uFF0C\u76F4\u63A5\u7ED3\u675F\u3002
+- \u6709\u8F93\u51FA \u2192 \u8BFB tasks/${params.name}/README.md \u4E86\u89E3\u5982\u4F55\u5904\u7406\u6570\u636E\u5E76\u901A\u77E5\u7528\u6237\u3002`
       }
-      break;
-    case "breath":
-      validateForegroundSegment(seg, prefix, errors);
-      validateOptionalBreathTiming(seg.breath_timing, `${prefix}.breath_timing`, errors);
-      break;
-    case "strobe":
-      validateForegroundSegment(seg, prefix, errors);
-      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
-      break;
-    case "steady":
-      validateForegroundSegment(seg, prefix, errors);
-      break;
-    case "pixel_frame":
-      validatePixelFrame(seg.pixels, `${prefix}.pixels`, errors);
-      break;
-    default:
-      validateOptionalNonNegativeNumber(seg.brightness, `${prefix}.brightness`, errors);
-      validateOptionalColor(seg.color, `${prefix}.color`, errors);
-      validateOptionalNonNegativeNumber(seg.interval_ms, `${prefix}.interval_ms`, errors);
-      validateOptionalDirection(seg.direction, `${prefix}.direction`, errors);
-      validateOptionalWindow(seg.window, `${prefix}.window`, errors);
-      validateOptionalBreathTiming(seg.breath_timing, `${prefix}.breath_timing`, errors);
-      validateOptionalBackground(seg.background, `${prefix}.background`, errors);
-  }
+    }
+  };
 }
-function validateForegroundSegment(seg, prefix, errors) {
-  validateNumberInRange(
-    seg.brightness,
-    `${prefix}.brightness`,
-    errors,
-    0,
-    255,
-    "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
-  );
-  validateColor(seg.color, `${prefix}.color`, errors);
-  if (seg.mode !== "steady" && seg.brightness === 0) {
-    errors.push({
-      field: `${prefix}.brightness`,
-      message: "brightness=0 \u4EC5 steady \u6A21\u5F0F\u5141\u8BB8\uFF1B\u5176\u5B83\u6A21\u5F0F\u4F1A\u5728\u56FA\u4EF6\u4FA7\u88AB\u8FC7\u6EE4"
-    });
+function updateLightRule(ctx, params) {
+  const resolved = resolveLightRuleTask(ctx, params.name);
+  const taskDir = resolved?.taskDir;
+  const meta = resolved?.meta;
+  if (!taskDir || !meta) {
+    throw new LightRuleError("NOT_FOUND", `\u706F\u6548\u89C4\u5219 '${params.name}' \u4E0D\u5B58\u5728`);
   }
-}
-function validatePixelFrame(value, field, errors) {
-  if (!Array.isArray(value)) {
-    errors.push({ field, message: "pixel_frame \u5FC5\u987B\u63D0\u4F9B pixels \u6570\u7EC4\uFF081\u20137 \u9879\uFF09" });
-    return;
+  let regenerateFetch = false;
+  let regenerateReadme = false;
+  if (params.description !== void 0) {
+    meta.description = params.description;
+    regenerateReadme = true;
   }
-  if (value.length < 1 || value.length > 7) {
-    errors.push({ field, message: "pixels \u5FC5\u987B\u4E3A 1\u20137 \u9879" });
+  if (legacyHasMatchRules(params)) {
+    legacyAssignMatchRules(meta, legacyReadMatchRules(params));
+    regenerateFetch = true;
   }
-  const seen = /* @__PURE__ */ new Set();
-  for (let i = 0; i < value.length; i++) {
-    const pixel = value[i];
-    const prefix = `${field}[${i}]`;
-    if (!isRecord(pixel)) {
-      errors.push({ field: prefix, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
-      continue;
-    }
-    const idx = pixel.index;
-    if (!Number.isInteger(idx) || idx < 0 || idx > 6) {
-      errors.push({ field: `${prefix}.index`, message: "index \u5FC5\u987B\u662F 0\u20136 \u7684\u6574\u6570" });
-    } else if (seen.has(idx)) {
-      errors.push({ field: `${prefix}.index`, message: `index=${idx} \u91CD\u590D` });
-    } else {
-      seen.add(idx);
-    }
-    validateNumberInRange(
-      pixel.brightness,
-      `${prefix}.brightness`,
-      errors,
-      0,
-      255,
-      "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
-    );
-    validateColor(pixel.color, `${prefix}.color`, errors);
+  if (params.segments !== void 0) {
+    meta.segments = params.segments;
+    regenerateReadme = true;
   }
-}
-function validateOptionalBreathTiming(value, field, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push({ field, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
-    return;
+  if (params.repeat !== void 0 || params.repeat_times !== void 0) {
+    meta.repeat_times = normalizeRepeatTimes({
+      repeat: params.repeat,
+      repeat_times: params.repeat_times
+    });
+    assertAncsRepeatTimes(meta.repeat_times);
+    regenerateReadme = true;
   }
-  validatePositiveNumber(
-    value.rise_ms,
-    `${field}.rise_ms`,
-    errors,
-    "rise_ms \u5FC5\u987B\u662F >0 \u7684\u6570\u5B57\uFF08\u4E0D\u652F\u6301 0ms\uFF09"
-  );
-  validateNonNegativeNumber(
-    value.hold_ms,
-    `${field}.hold_ms`,
-    errors,
-    "hold_ms \u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57"
-  );
-  validatePositiveNumber(
-    value.fall_ms,
-    `${field}.fall_ms`,
-    errors,
-    "fall_ms \u5FC5\u987B\u662F >0 \u7684\u6570\u5B57\uFF08\u4E0D\u652F\u6301 0ms\uFF09"
-  );
-  validateNonNegativeNumber(
-    value.off_ms,
-    `${field}.off_ms`,
-    errors,
-    "off_ms \u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57"
-  );
-}
-function validateOptionalBackground(value, field, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push({ field, message: "\u5FC5\u987B\u5305\u542B r/g/b/brightness \u6570\u503C" });
-    return;
+  if (legacyHasCronSchedule(params)) {
+    legacyAssignCronSchedule(meta, legacyReadCronSchedule(params));
   }
-  validateColor(value, field, errors);
-  validateNumberInRange(
-    value.brightness,
-    `${field}.brightness`,
-    errors,
-    0,
-    255,
-    "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
-  );
-}
-function validateOptionalColor(value, field, errors) {
-  if (value === void 0) return;
-  validateColor(value, field, errors);
-}
-function validateColor(value, field, errors) {
-  if (!isRecord(value)) {
-    errors.push({ field, message: "\u5FC5\u987B\u5305\u542B r/g/b \u6570\u503C" });
-    return;
+  if (params.enabled !== void 0) {
+    meta.enabled = params.enabled;
   }
-  validateNumberInRange(value.r, `${field}.r`, errors, 0, 255, "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57");
-  validateNumberInRange(value.g, `${field}.g`, errors, 0, 255, "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57");
-  validateNumberInRange(value.b, `${field}.b`, errors, 0, 255, "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57");
-}
-function validateOptionalDirection(value, field, errors) {
-  if (value === void 0) return;
-  if (value !== "ltr" && value !== "rtl") {
-    errors.push({ field, message: "direction \u5FC5\u987B\u662F ltr \u6216 rtl" });
+  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeMeta(taskDir, meta);
+  if (regenerateFetch) {
+    (0, import_node_fs4.writeFileSync)(
+      (0, import_node_path3.join)(taskDir, "fetch.py"),
+      generateFetchPy(meta.name, legacyReadMetaMatchRules(meta)),
+      "utf-8"
+    );
   }
-}
-function validateOptionalWindow(value, field, errors) {
-  if (value === void 0) return;
-  if (value !== 1 && value !== 2 && value !== 3) {
-    errors.push({ field, message: "window \u4EC5\u652F\u6301 1/2/3" });
+  if (regenerateReadme) {
+    (0, import_node_fs4.writeFileSync)(
+      (0, import_node_path3.join)(taskDir, "README.md"),
+      generateLightRuleReadme(meta.name, meta.description, meta.segments, meta.repeat_times),
+      "utf-8"
+    );
   }
-}
-function validateOptionalNonNegativeNumber(value, field, errors) {
-  if (value === void 0) return;
-  validateNonNegativeNumber(value, field, errors, "\u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57");
-}
-function validatePositiveNumber(value, field, errors, message) {
-  if (value === void 0) return;
-  if (!isFiniteNumber(value) || value <= 0) {
-    errors.push({ field, message });
-  }
-}
-function validateNonNegativeNumber(value, field, errors, message) {
-  if (!isFiniteNumber(value) || value < 0) {
-    errors.push({ field, message });
-  }
-}
-function validateNumberInRange(value, field, errors, min, max, message) {
-  if (!isFiniteNumber(value) || value < min || value > max) {
-    errors.push({ field, message });
-  }
-}
-function hasNonZeroRgb(value) {
-  if (!value) return false;
-  return [value.r, value.g, value.b].some((channel) => isFiniteNumber(channel) && channel > 0);
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-// src/light-rules/storage.ts
-var import_node_fs5 = require("fs");
-var import_node_path4 = require("path");
-
-// src/monitor/fetch-gen.ts
-function generateFetchPy(name, matchRules) {
-  const appName = typeof matchRules.appName === "string" ? matchRules.appName : "";
-  const senderKeywords = stringArray(matchRules.senderKeywords);
-  const contentKeywords = stringArray(matchRules.contentKeywords);
-  return `#!/usr/bin/env python3
-"""Auto-generated fetch script for monitor task: ${name}"""
-import json, sys, os
-from pathlib import Path
-
-def matches(notification: dict) -> bool:
-    app = str(notification.get("appName", "") or "")
-    title = str(notification.get("title", "") or "")
-    content = str(notification.get("content", "") or "")
-    body = str(notification.get("body", "") or "")
-
-    app_name = ${pyLiteral(appName)}
-    if app_name and app != app_name:
-        return False
-
-    sender_keywords = ${pyLiteral(senderKeywords)}
-    sender_haystack = f"{title}\\n{content}\\n{body}"
-    if sender_keywords and not any(keyword in sender_haystack for keyword in sender_keywords):
-        return False
-
-    content_keywords = ${pyLiteral(contentKeywords)}
-    content_haystack = f"{content}\\n{body}"
-    if content_keywords and not any(keyword in content_haystack for keyword in content_keywords):
-        return False
-
-    return True
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--notifications-dir", required=True)
-    args = parser.parse_args()
-
-    checkpoint_path = Path(__file__).parent / "checkpoint.json"
-    checkpoint = {}
-    if checkpoint_path.exists():
-        checkpoint = json.loads(checkpoint_path.read_text())
-
-    ntf_dir = Path(args.notifications_dir)
-    matched = []
-    new_checkpoint = dict(checkpoint)
-
-    for f in sorted(ntf_dir.glob("*.json")):
-        date_key = f.stem
-        items = json.loads(f.read_text())
-        last_idx = checkpoint.get(date_key, {}).get("lastIndex", -1)
-        for i, item in enumerate(items):
-            if i <= last_idx:
-                continue
-            if matches(item):
-                matched.append(item)
-        new_checkpoint[date_key] = {"lastIndex": len(items) - 1}
-
-    checkpoint_path.write_text(json.dumps(new_checkpoint, indent=2))
-
-    if not matched:
-        print("NO_MATCH")
-        return
-
-    for m in matched:
-        print(json.dumps(m, ensure_ascii=False))
-
-if __name__ == "__main__":
-    main()
-`;
-}
-function stringArray(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((item) => typeof item === "string" && item.length > 0);
-}
-function pyLiteral(value) {
-  return JSON.stringify(value);
-}
-
-// src/light-rules/storage.ts
-var LEGACY_DEFAULT_CRON_SCHEDULE = "*/5 * * * *";
-function legacyReadMatchRules(input) {
-  return input.matchRules ?? {};
-}
-function legacyReadCronSchedule(input) {
-  return input.cronSchedule ?? LEGACY_DEFAULT_CRON_SCHEDULE;
-}
-function legacyHasMatchRules(input) {
-  return input.matchRules !== void 0;
-}
-function legacyHasCronSchedule(input) {
-  return input.cronSchedule !== void 0;
-}
-function legacyAssignMatchRules(meta, matchRules) {
-  meta.matchRules = matchRules;
-}
-function legacyAssignCronSchedule(meta, cronSchedule) {
-  meta.cronSchedule = cronSchedule;
-}
-function legacyReadMetaMatchRules(meta) {
-  return meta.matchRules ?? {};
-}
-function legacyReadMetaCronSchedule(meta) {
-  return meta.cronSchedule;
-}
-function resolveBaseDir(ctx) {
-  if (ctx.workspaceDir) return ctx.workspaceDir;
-  if (ctx.stateDir) {
-    const inferredWorkspaceDir = (0, import_node_path4.join)(ctx.stateDir, "workspace");
-    if ((0, import_node_fs5.existsSync)(inferredWorkspaceDir)) return inferredWorkspaceDir;
-    return ctx.stateDir;
-  }
-  throw new Error("workspaceDir and stateDir both unavailable");
-}
-function tasksDir(ctx) {
-  return (0, import_node_path4.join)(resolveBaseDir(ctx), "tasks");
-}
-function normalizeLightRuleLookupName(name) {
-  return name.trim().replace(/\.json$/i, "");
-}
-function resolveLightRuleTask(ctx, name) {
-  const dir = tasksDir(ctx);
-  const normalizedName = normalizeLightRuleLookupName(name);
-  if (!normalizedName) return null;
-  const directTaskDir = (0, import_node_path4.join)(dir, normalizedName);
-  const directMeta = readMeta(directTaskDir);
-  if (directMeta) {
-    return {
-      taskDir: directTaskDir,
-      meta: directMeta
-    };
-  }
-  if (!(0, import_node_fs5.existsSync)(dir)) return null;
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const taskDir = (0, import_node_path4.join)(dir, entry.name);
-    const meta = readMeta(taskDir);
-    if (meta?.name === normalizedName) {
-      return {
-        taskDir,
-        meta
-      };
-    }
-  }
-  return null;
-}
-function readOptionalString(value) {
-  if (typeof value !== "string") return void 0;
-  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_path4.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs5.existsSync)(metaPath)) return null;
-  try {
-    const raw = JSON.parse((0, import_node_fs5.readFileSync)(metaPath, "utf-8"));
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-    if (raw.type !== "light-rule" && !isLegacyLightRuleWithoutType(raw)) return null;
-    if (!Array.isArray(raw.segments)) return null;
-    const name = readOptionalString(raw.name) ?? (0, import_node_path4.basename)(taskDir);
-    const description = readOptionalString(raw.description) ?? readOptionalString(raw.reason) ?? name;
-    const createdAt = readOptionalString(raw.createdAt) ?? (0, import_node_fs5.statSync)(metaPath).birthtime.toISOString();
-    const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
-    const repeatTimes = normalizeRepeatTimes({
-      repeat: raw.repeat,
-      repeat_times: raw.repeat_times
-    });
-    assertAncsRepeatTimes(repeatTimes);
-    return {
-      ...raw,
-      name,
-      type: "light-rule",
-      description,
-      segments: raw.segments,
-      repeat_times: repeatTimes,
-      enabled,
-      createdAt
-    };
-  } catch {
-    return null;
-  }
-}
-function writeMeta(taskDir, meta) {
-  (0, import_node_fs5.writeFileSync)((0, import_node_path4.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
-}
-function generateLightRuleReadme(name, description, segments, repeatTimes) {
-  const segmentsJson = JSON.stringify(segments, null, 2);
-  return `# ${name}
-
-## \u76D1\u63A7\u76EE\u6807
-
-${description}
-
-## \u89E6\u53D1\u540E\u5982\u4F55\u5904\u7406
-
-\u5F53\u4EFB\u52A1\u811A\u672C\u8F93\u51FA\u5339\u914D\u7ED3\u679C\u65F6\uFF1A
-
-1. \u5C06\u8F93\u51FA\u6309"\u6BCF\u884C\u4E00\u4E2A JSON \u5BF9\u8C61"\u89E3\u6790
-2. \u8FD9\u4E9B\u662F\u5019\u9009\u901A\u77E5\uFF0C\u4E0D\u4EE3\u8868\u5DF2\u7ECF\u547D\u4E2D
-3. \u6839\u636E\u76D1\u63A7\u76EE\u6807\u5224\u65AD\u662F\u5426\u771F\u6B63\u547D\u4E2D
-
-**\u547D\u4E2D\u540E\u6267\u884C\u706F\u6548**\uFF1A\u8C03\u7528 light_control \u5DE5\u5177\uFF0C\u4F20\u5165\u4EE5\u4E0B\u706F\u6548\u53C2\u6570\uFF1A
-
-\`\`\`json
-${segmentsJson}
-\`\`\`
-
-repeat_times: ${repeatTimes}
-reason: "${description}"
-
-\u53EA\u6267\u884C\u706F\u6548\uFF0C\u4E0D\u4E3B\u52A8\u53D1\u9001\u901A\u77E5\u6458\u8981\u6216\u56DE\u590D\u7528\u6237\u3002
-`;
-}
-function listLightRules(ctx) {
-  const dir = tasksDir(ctx);
-  if (!(0, import_node_fs5.existsSync)(dir)) return [];
-  const rules = [];
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const meta = readMeta((0, import_node_path4.join)(dir, entry.name));
-    if (meta) rules.push(meta);
-  }
-  return rules;
-}
-function createLightRule(ctx, params) {
-  const dir = tasksDir(ctx);
-  const taskDir = (0, import_node_path4.join)(dir, params.name);
-  if ((0, import_node_fs5.existsSync)(taskDir)) {
-    throw new LightRuleError("ALREADY_EXISTS", `\u706F\u6548\u89C4\u5219 '${params.name}' \u5DF2\u5B58\u5728`);
-  }
-  (0, import_node_fs5.mkdirSync)(taskDir, { recursive: true });
-  const repeatTimes = normalizeRepeatTimes({
-    repeat: params.repeat,
-    repeat_times: params.repeat_times
-  });
-  assertAncsRepeatTimes(repeatTimes);
-  const effectiveMatchRules = legacyReadMatchRules(params);
-  const effectiveCronSchedule = legacyReadCronSchedule(params);
-  const meta = {
-    name: params.name,
-    type: "light-rule",
-    description: params.description,
-    segments: params.segments,
-    repeat_times: repeatTimes,
-    enabled: true,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  legacyAssignMatchRules(meta, effectiveMatchRules);
-  legacyAssignCronSchedule(meta, effectiveCronSchedule);
-  writeMeta(taskDir, meta);
-  (0, import_node_fs5.writeFileSync)(
-    (0, import_node_path4.join)(taskDir, "fetch.py"),
-    generateFetchPy(params.name, effectiveMatchRules),
-    "utf-8"
-  );
-  (0, import_node_fs5.writeFileSync)(
-    (0, import_node_path4.join)(taskDir, "README.md"),
-    generateLightRuleReadme(params.name, params.description, params.segments, repeatTimes),
-    "utf-8"
-  );
-  return {
-    meta,
-    cronHint: {
-      action: "add",
-      job: {
-        name: `notif-${params.name}`,
-        schedule: effectiveCronSchedule,
-        sessionTarget: "isolated",
-        message: `\u624B\u673A\u901A\u77E5\u5DF2\u7531\u72EC\u7ACB\u670D\u52A1\u5B9E\u65F6\u6355\u83B7\u5230 notifications/ \u76EE\u5F55\u7684 JSON \u6587\u4EF6\u4E2D\u3002
-\u6267\u884C\uFF1Apython3 tasks/${params.name}/fetch.py --notifications-dir notifications
-- NO_CHANGE \u6216 NO_MATCH \u2192 \u4E0D\u56DE\u590D\uFF0C\u76F4\u63A5\u7ED3\u675F\u3002
-- \u6709\u8F93\u51FA \u2192 \u8BFB tasks/${params.name}/README.md \u4E86\u89E3\u5982\u4F55\u5904\u7406\u6570\u636E\u5E76\u901A\u77E5\u7528\u6237\u3002`
-      }
-    }
-  };
-}
-function updateLightRule(ctx, params) {
-  const resolved = resolveLightRuleTask(ctx, params.name);
-  const taskDir = resolved?.taskDir;
-  const meta = resolved?.meta;
-  if (!taskDir || !meta) {
-    throw new LightRuleError("NOT_FOUND", `\u706F\u6548\u89C4\u5219 '${params.name}' \u4E0D\u5B58\u5728`);
-  }
-  let regenerateFetch = false;
-  let regenerateReadme = false;
-  if (params.description !== void 0) {
-    meta.description = params.description;
-    regenerateReadme = true;
-  }
-  if (legacyHasMatchRules(params)) {
-    legacyAssignMatchRules(meta, legacyReadMatchRules(params));
-    regenerateFetch = true;
-  }
-  if (params.segments !== void 0) {
-    meta.segments = params.segments;
-    regenerateReadme = true;
-  }
-  if (params.repeat !== void 0 || params.repeat_times !== void 0) {
-    meta.repeat_times = normalizeRepeatTimes({
-      repeat: params.repeat,
-      repeat_times: params.repeat_times
-    });
-    assertAncsRepeatTimes(meta.repeat_times);
-    regenerateReadme = true;
-  }
-  if (legacyHasCronSchedule(params)) {
-    legacyAssignCronSchedule(meta, legacyReadCronSchedule(params));
-  }
-  if (params.enabled !== void 0) {
-    meta.enabled = params.enabled;
-  }
-  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeMeta(taskDir, meta);
-  if (regenerateFetch) {
-    (0, import_node_fs5.writeFileSync)(
-      (0, import_node_path4.join)(taskDir, "fetch.py"),
-      generateFetchPy(meta.name, legacyReadMetaMatchRules(meta)),
-      "utf-8"
-    );
-  }
-  if (regenerateReadme) {
-    (0, import_node_fs5.writeFileSync)(
-      (0, import_node_path4.join)(taskDir, "README.md"),
-      generateLightRuleReadme(meta.name, meta.description, meta.segments, meta.repeat_times),
-      "utf-8"
-    );
-  }
-  const cronHint = legacyHasCronSchedule(params) ? {
-    action: "update",
-    job: {
-      name: `notif-${meta.name}`,
-      schedule: legacyReadMetaCronSchedule(meta)
-    }
-  } : void 0;
-  return { meta, cronHint };
+  const cronHint = legacyHasCronSchedule(params) ? {
+    action: "update",
+    job: {
+      name: `notif-${meta.name}`,
+      schedule: legacyReadMetaCronSchedule(meta)
+    }
+  } : void 0;
+  return { meta, cronHint };
 }
 function deleteLightRule(ctx, name) {
   const resolved = resolveLightRuleTask(ctx, name);
@@ -6654,7 +6336,7 @@ function deleteLightRule(ctx, name) {
   if (!taskDir || !meta) {
     throw new LightRuleError("NOT_FOUND", `\u706F\u6548\u89C4\u5219 '${name}' \u4E0D\u5B58\u5728`);
   }
-  (0, import_node_fs5.rmSync)(taskDir, { recursive: true, force: true });
+  (0, import_node_fs4.rmSync)(taskDir, { recursive: true, force: true });
   return {
     name: meta.name,
     cronHint: {
@@ -7009,16 +6691,21 @@ var MODE_TO_INDEX = {
   wave_rainbow: 4,
   pixel_frame: 5
 };
-function buildLightEffectApnsBody(segments, repeatInput) {
+function buildLightEffectApnsBody(segments, repeatInput, visibleTextOverride) {
   assertSegmentCount(segments);
   assertSegmentsValid(segments);
   const repeatTimes = normalizeRepeatTimes(repeatInput);
   assertAncsRepeatTimes(repeatTimes);
-  const visibleText = summarizeSegments(segments);
+  const visibleText = resolveVisibleText(visibleTextOverride, segments);
   const separator = repeatTimes === 0 ? LED_SEPARATOR_LOOP : LED_SEPARATOR_ONCE;
   const payload = segments.map((segment) => encodeSegment(segment)).join("");
   return `${visibleText}${separator}${payload}`;
 }
+function resolveVisibleText(override, segments) {
+  const trimmed = override?.trim();
+  if (trimmed) return trimmed;
+  return summarizeSegments(segments);
+}
 function assertSegmentCount(segments) {
   if (segments.length < 1 || segments.length > MAX_LIGHT_SEGMENTS) {
     throw new Error(`light_control supports 1-${MAX_LIGHT_SEGMENTS} segments`);
@@ -7374,231 +7061,48 @@ function registerLightRulesTools(api, registry, logger) {
           updated: true,
           rule: result.meta,
           cronHint: result.cronHint
-        });
-      } catch (e) {
-        if (e instanceof LightRuleError) return err(e.code, e.message);
-        logger.warn(`lightrules.update tool failed: ${e?.message}`);
-        return err("INTERNAL_ERROR", e?.message ?? "Unknown error");
-      }
-    }
-  }, ["lightrules_update"]);
-  registerToolWithAliases(api, {
-    name: "lightrules.delete",
-    label: "Delete Light Rule",
-    description: '\u5220\u9664\u4E00\u6761\u706F\u6548\u89C4\u5219\uFF08\u4E0D\u53EF\u6062\u590D\uFF09\u3002\u5F53\u7528\u6237\u8BF4"\u5220\u9664\u706F\u6548\u89C4\u5219"\u3001"\u79FB\u9664\u89C4\u5219"\u7B49\u65F6\u8C03\u7528\u3002',
-    parameters: {
-      type: "object",
-      required: ["name"],
-      additionalProperties: false,
-      properties: {
-        name: { type: "string", description: "\u8981\u5220\u9664\u7684\u89C4\u5219\u540D\u79F0" }
-      }
-    },
-    async execute(_toolCallId, params) {
-      const { name } = params;
-      if (!name || typeof name !== "string")
-        return err("INVALID_PARAMS", "name is required");
-      try {
-        const result = await registry.delete(name);
-        logger.info(`lightrules.delete tool: deleted ${name}`);
-        return ok({ ok: true, name: result.name, deleted: true, cronHint: result.cronHint });
-      } catch (e) {
-        if (e instanceof LightRuleError) return err(e.code, e.message);
-        logger.warn(`lightrules.delete tool failed: ${e?.message}`);
-        return err("INTERNAL_ERROR", e?.message ?? "Unknown error");
-      }
-    }
-  }, ["lightrules_delete"]);
-}
-
-// src/light-rules/evaluator-job.ts
-var EVALUATOR_JOB_ID = "light-rules-evaluator";
-var EVALUATOR_SUBAGENT_SESSION_KEY = EVALUATOR_JOB_ID;
-var FALLBACK_CRON_EXPR = "0 0 1 1 *";
-function buildEvaluatorJobMessage(notificationsDir) {
-  return `\u706F\u6548\u89C4\u5219\u8BC4\u4F30\u4EFB\u52A1\u3002
-
-\u6267\u884C\u6B65\u9AA4\uFF1A
-1. \u8BFB\u53D6 tasks/light-rules-evaluator/checkpoint.json\uFF08\u8BB0\u5F55\u4E0A\u6B21\u5904\u7406\u8FDB\u5EA6\uFF09
-2. \u626B\u63CF ${notificationsDir} \u76EE\u5F55\uFF0C\u83B7\u53D6 checkpoint \u4E4B\u540E\u7684\u65B0\u901A\u77E5
-3. \u626B\u63CF tasks/ \u76EE\u5F55\uFF0C\u8BFB\u53D6\u6240\u6709 type=light-rule \u4E14 enabled=true \u7684 meta.json
-4. \u5BF9\u6BCF\u6761\u65B0\u901A\u77E5\uFF0C\u9010\u4E00\u5224\u65AD\u662F\u5426\u547D\u4E2D\u6BCF\u6761\u89C4\u5219\u7684 description\uFF08\u8BED\u4E49\u5339\u914D\uFF09
-5. \u547D\u4E2D\u65F6\uFF1A\u4EE5\u8BE5\u89C4\u5219\u7684 segments \u548C repeat_times \u8C03\u7528 light_control \u5DE5\u5177
-6. \u66F4\u65B0 checkpoint.json\uFF0C\u8BB0\u5F55\u5DF2\u5904\u7406\u5230\u7684\u6700\u65B0\u901A\u77E5\u4F4D\u7F6E
-7. \u82E5\u65E0\u65B0\u901A\u77E5\u6216\u65E0 enabled \u89C4\u5219\uFF1A\u8F93\u51FA NO_CHANGE\uFF0C\u76F4\u63A5\u7ED3\u675F`;
-}
-var LightRulesEvaluatorJob = class {
-  logger;
-  registry;
-  subagentRunner;
-  getNotificationsDir;
-  /**
-   * 轻量进程内评估器（事件驱动方案的正式路径）。
-   * 配置后：每批通知走一次 pi-ai `complete()`，不再启动 agent session。
-   * 未配置（或调用失败）时：回退 cron / subagent 老路径。
-   */
-  inlineEvaluator;
-  /**
-   * 记录本进程生命周期内 job 是否已确认存在。
-   * 仅在 `ensureJobExists` 成功后置 true，避免每次 push 都做检查。
-   */
-  jobEnsured = false;
-  /**
-   * 首次创建 job 时的并发保护。
-   * 避免冷启动瞬间多条通知并发到达时重复调用 `cron.add`。
-   */
-  ensureJobPromise = null;
-  /**
-   * subagent fallback 路径的并发保护。
-   * 若评估 session 已在运行中，跳过本次触发（checkpoint 保证下次补处理）。
-   */
-  subagentInFlight = false;
-  constructor(deps) {
-    this.logger = deps.logger;
-    this.registry = deps.registry;
-    this.inlineEvaluator = deps.inlineEvaluator;
-    this.subagentRunner = deps.subagentRunner;
-    this.getNotificationsDir = deps.getNotificationsDir ?? (() => void 0);
-  }
-  /**
-   * 通知落盘后调用。若有新增通知且存在 enabled 规则，则触发评估。
-   *
-   * 路径优先级：
-   *  1. inlineEvaluator（配置后的主路径）：进程内一次 LLM 调用直接匹配 + 触发灯效
-   *  2. cron.enqueueRun("force")：legacy，gateway context 路径
-   *  3. subagentRunner.run：legacy，HTTP Relay 路径（cron 不可用时）
-   *
-   * inline 成功（包括 0 命中）立刻返回，不会再走 legacy 路径。
-   * inline 失败（LLM 错误 / 未配置 provider）才回退 legacy。
-   *
-   * @param cron     来自 gateway context 的 CronService；HTTP 路径下为 null
-   * @param inserted 本次 ingest 实际新落盘的通知（StoredNotification 去重后）
-   */
-  async triggerIfNeeded(cron, inserted) {
-    if (inserted.length === 0) return;
-    if (this.registry.getEnabled().length === 0) return;
-    if (this.inlineEvaluator) {
-      try {
-        const ok2 = await this.inlineEvaluator.evaluate(inserted);
-        if (ok2) return;
-        this.logger.warn(
-          "light-rules-evaluator: inline evaluator failed; falling back to legacy agent session path"
-        );
-      } catch (err2) {
-        this.logger.warn(
-          `light-rules-evaluator: inline evaluator threw: ${err2?.message ?? err2}; falling back`
-        );
-      }
-    }
-    if (!cron) {
-      await this.triggerViaSubagent();
-      return;
-    }
-    try {
-      await this.ensureJobExists(cron);
-    } catch (err2) {
-      this.logger.warn(`light-rules-evaluator: job ensure failed: ${err2?.message ?? err2}`);
-      return;
-    }
-    try {
-      const result = await cron.enqueueRun(EVALUATOR_JOB_ID, "force");
-      if (!result.ok) {
-        this.logger.warn("light-rules-evaluator: enqueueRun returned ok=false");
-        return;
-      }
-      if ("enqueued" in result && result.enqueued) {
-        this.logger.info(`light-rules-evaluator: enqueued runId=${result.runId}`);
-      } else if ("reason" in result) {
-        this.logger.info(`light-rules-evaluator: enqueueRun skipped (${result.reason})`);
+        });
+      } catch (e) {
+        if (e instanceof LightRuleError) return err(e.code, e.message);
+        logger.warn(`lightrules.update tool failed: ${e?.message}`);
+        return err("INTERNAL_ERROR", e?.message ?? "Unknown error");
       }
-    } catch (err2) {
-      this.logger.warn(`light-rules-evaluator: enqueueRun failed: ${err2?.message ?? err2}`);
-    }
-  }
-  /**
-   * cron service 不可用时的 fallback：直接通过 subagentRunner 运行评估 session。
-   *
-   * 并发保护：若上一次 subagent 运行尚未完成，本次跳过。
-   * checkpoint 保证即使本次跳过，下次触发时会处理所有积压通知。
-   */
-  async triggerViaSubagent() {
-    if (!this.subagentRunner) {
-      this.logger.warn(
-        "light-rules-evaluator: cron service unavailable and no subagent fallback configured; notifications ingested via HTTP will not trigger light rules until an agent session is active"
-      );
-      return;
-    }
-    if (this.subagentInFlight) {
-      this.logger.info("light-rules-evaluator: subagent run in-flight, skipping this trigger");
-      return;
     }
-    const notificationsDir = this.getNotificationsDir();
-    if (!notificationsDir) {
-      this.logger.warn("light-rules-evaluator: notifications dir not ready, skipping subagent trigger");
-      return;
-    }
-    this.subagentInFlight = true;
-    try {
-      const result = await this.subagentRunner.run({
-        sessionKey: EVALUATOR_SUBAGENT_SESSION_KEY,
-        message: buildEvaluatorJobMessage(notificationsDir),
-        deliver: false,
-        idempotencyKey: `${EVALUATOR_SUBAGENT_SESSION_KEY}-${Date.now()}`
-      });
-      this.logger.info(`light-rules-evaluator: subagent triggered runId=${result.runId}`);
-    } catch (err2) {
-      this.logger.warn(`light-rules-evaluator: subagent trigger failed: ${err2?.message ?? err2}`);
-    } finally {
-      this.subagentInFlight = false;
-    }
-  }
-  /**
-   * 按需创建 `light-rules-evaluator` job。
-   * 若 job 已存在（内存缓存或 cron store），直接返回；否则调用 `cron.add`。
-   */
-  async ensureJobExists(cron) {
-    if (this.jobEnsured) return;
-    if (!this.ensureJobPromise) {
-      this.ensureJobPromise = this.createJobIfNeeded(cron).finally(() => {
-        this.ensureJobPromise = null;
-      });
-    }
-    await this.ensureJobPromise;
-  }
-  async createJobIfNeeded(cron) {
-    if (cron.getJob(EVALUATOR_JOB_ID)) {
-      this.jobEnsured = true;
-      return;
-    }
-    try {
-      await cron.add({
-        id: EVALUATOR_JOB_ID,
-        name: "\u706F\u6548\u89C4\u5219\u8BC4\u4F30",
-        description: "\u4E8B\u4EF6\u9A71\u52A8\uFF1A\u901A\u77E5\u5230\u8FBE\u65F6\u8BC4\u4F30\u6240\u6709 enabled \u706F\u6548\u89C4\u5219\uFF0C\u547D\u4E2D\u5219\u8C03\u7528 light_control \u89E6\u53D1\u706F\u6548",
-        enabled: true,
-        schedule: { kind: "cron", expr: FALLBACK_CRON_EXPR },
-        sessionTarget: "isolated",
-        wakeMode: "now",
-        payload: {
-          kind: "agentTurn",
-          message: buildEvaluatorJobMessage(this.getNotificationsDir() ?? "notifications")
-        }
-      });
-      this.logger.info("light-rules-evaluator: job created");
-    } catch (err2) {
-      if (!cron.getJob(EVALUATOR_JOB_ID)) {
-        throw err2;
+  }, ["lightrules_update"]);
+  registerToolWithAliases(api, {
+    name: "lightrules.delete",
+    label: "Delete Light Rule",
+    description: '\u5220\u9664\u4E00\u6761\u706F\u6548\u89C4\u5219\uFF08\u4E0D\u53EF\u6062\u590D\uFF09\u3002\u5F53\u7528\u6237\u8BF4"\u5220\u9664\u706F\u6548\u89C4\u5219"\u3001"\u79FB\u9664\u89C4\u5219"\u7B49\u65F6\u8C03\u7528\u3002',
+    parameters: {
+      type: "object",
+      required: ["name"],
+      additionalProperties: false,
+      properties: {
+        name: { type: "string", description: "\u8981\u5220\u9664\u7684\u89C4\u5219\u540D\u79F0" }
+      }
+    },
+    async execute(_toolCallId, params) {
+      const { name } = params;
+      if (!name || typeof name !== "string")
+        return err("INVALID_PARAMS", "name is required");
+      try {
+        const result = await registry.delete(name);
+        logger.info(`lightrules.delete tool: deleted ${name}`);
+        return ok({ ok: true, name: result.name, deleted: true, cronHint: result.cronHint });
+      } catch (e) {
+        if (e instanceof LightRuleError) return err(e.code, e.message);
+        logger.warn(`lightrules.delete tool failed: ${e?.message}`);
+        return err("INTERNAL_ERROR", e?.message ?? "Unknown error");
       }
     }
-    this.jobEnsured = true;
-  }
-};
+  }, ["lightrules_delete"]);
+}
 
 // src/light-rules/inline-evaluator.ts
 init_credentials();
 
 // src/light/sender.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto = require("crypto");
 init_env();
 async function sendLightEffect(apiKey, segments, logger, repeatInput, reason) {
   const apiUrl = getEnvUrls().lightApiUrl;
@@ -7615,11 +7119,11 @@ async function sendLightEffect(apiKey, segments, logger, repeatInput, reason) {
   }
   let bizContent;
   try {
-    bizContent = buildLightEffectApnsBody(segments, repeatInput);
+    bizContent = buildLightEffectApnsBody(segments, repeatInput, reason);
   } catch (error) {
     return { ok: false, error: error?.message ?? String(error) };
   }
-  const bizUniqueId = (0, import_node_crypto2.randomUUID)();
+  const bizUniqueId = (0, import_node_crypto.randomUUID)();
   const requestBody = {
     appKey,
     bizMap: { noticeType: "APP_NOTIFICATION_IMPORTANT", reason },
@@ -7727,8 +7231,8 @@ var InlineLightRuleEvaluator = class {
 };
 
 // src/light-rules/migration.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 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
@@ -7738,32 +7242,32 @@ function normalizeScriptText(text) {
   return text.replace(/\r\n/g, "\n").trim();
 }
 function resolveTasksDir(ctx) {
-  if (ctx.workspaceDir) return (0, import_node_path8.join)(ctx.workspaceDir, "tasks");
+  if (ctx.workspaceDir) return (0, import_node_path7.join)(ctx.workspaceDir, "tasks");
   if (ctx.stateDir) {
-    const inferredWorkspaceDir = (0, import_node_path8.join)(ctx.stateDir, "workspace");
-    if ((0, import_node_fs9.existsSync)(inferredWorkspaceDir)) return (0, import_node_path8.join)(inferredWorkspaceDir, "tasks");
-    return (0, import_node_path8.join)(ctx.stateDir, "tasks");
+    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_fs9.existsSync)(tasksDir3)) return;
+  if (!tasksDir3 || !(0, import_node_fs8.existsSync)(tasksDir3)) return;
   try {
-    for (const entry of (0, import_node_fs9.readdirSync)(tasksDir3, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs8.readdirSync)(tasksDir3, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      migrateTaskDir((0, import_node_path8.join)(tasksDir3, String(entry.name)), logger);
+      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_path8.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs9.existsSync)(metaPath)) return;
+  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_fs9.readFileSync)(metaPath, "utf-8"));
+    meta = JSON.parse((0, import_node_fs8.readFileSync)(metaPath, "utf-8"));
   } catch {
     return;
   }
@@ -7772,7 +7276,7 @@ function migrateTaskDir(taskDir, logger) {
   mergeMatchRulesIntoDescription(meta, name, metaPath, logger);
   replaceFetchPy(taskDir, name, logger);
   for (const filename of ["README.md", "checkpoint.json"]) {
-    removeFile((0, import_node_path8.join)(taskDir, filename), name, filename, logger);
+    removeFile((0, import_node_path7.join)(taskDir, filename), name, filename, logger);
   }
 }
 function mergeMatchRulesIntoDescription(meta, name, metaPath, logger) {
@@ -7793,30 +7297,30 @@ function mergeMatchRulesIntoDescription(meta, name, metaPath, logger) {
   }
   delete meta.matchRules;
   try {
-    (0, import_node_fs9.writeFileSync)(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+    (0, import_node_fs8.writeFileSync)(metaPath, JSON.stringify(meta, null, 2), "utf-8");
     logger.info(`migration: merged matchRules into description for light rule: ${name}`);
   } catch (err2) {
     logger.warn(`migration: failed to update meta.json for ${name}: ${err2?.message}`);
   }
 }
 function replaceFetchPy(taskDir, name, logger) {
-  const fetchPyPath = (0, import_node_path8.join)(taskDir, "fetch.py");
-  if (!(0, import_node_fs9.existsSync)(fetchPyPath)) return;
+  const fetchPyPath = (0, import_node_path7.join)(taskDir, "fetch.py");
+  if (!(0, import_node_fs8.existsSync)(fetchPyPath)) return;
   try {
-    const existing = (0, import_node_fs9.readFileSync)(fetchPyPath, "utf-8");
+    const existing = (0, import_node_fs8.readFileSync)(fetchPyPath, "utf-8");
     if (normalizeScriptText(existing) === normalizeScriptText(NO_MATCH_FETCH_PY)) {
       return;
     }
-    (0, import_node_fs9.writeFileSync)(fetchPyPath, NO_MATCH_FETCH_PY, "utf-8");
+    (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_fs9.existsSync)(filePath)) return;
+  if (!(0, import_node_fs8.existsSync)(filePath)) return;
   try {
-    (0, import_node_fs9.rmSync)(filePath);
+    (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}`);
@@ -7987,7 +7491,7 @@ function resolveUpdateChannel(params) {
 }
 
 // src/update/index.ts
-var import_node_path10 = require("path");
+var import_node_path9 = require("path");
 
 // src/update/checker.ts
 function parseSemver(v) {
@@ -8089,8 +7593,8 @@ var UpdateChecker = class {
 };
 
 // src/update/executor.ts
-var import_node_fs10 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path8 = require("path");
 var import_node_os = require("os");
 var VERSION_PATTERN = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 var BASE_URL = "https://artifact.yoooclaw.com/plugin";
@@ -8100,9 +7604,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_fs10.mkdtempSync)((0, import_node_path9.join)((0, import_node_os.tmpdir)(), ".openclaw-plugin-update-"));
-  const tgzPath = (0, import_node_path9.join)(workDir, "plugin.tgz");
-  const stagingDir = (0, import_node_path9.join)(workDir, "staged");
+  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");
   let backupDir = null;
   try {
     logger.info("\u4E0B\u8F7D\u63D2\u4EF6\u5305...");
@@ -8111,9 +7615,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_fs10.writeFileSync)(tgzPath, buffer);
+    (0, import_node_fs9.writeFileSync)(tgzPath, buffer);
     logger.info(`\u4E0B\u8F7D\u5B8C\u6210 (${buffer.length} bytes)`);
-    (0, import_node_fs10.mkdirSync)(stagingDir, { recursive: true });
+    (0, import_node_fs9.mkdirSync)(stagingDir, { recursive: true });
     const tarResult = await runCommand(
       ["tar", "-xzf", tgzPath, "-C", stagingDir, "--strip-components=1"],
       { timeoutMs: 3e4 }
@@ -8122,14 +7626,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_fs10.mkdirSync)((0, import_node_path9.dirname)(targetDir), { recursive: true });
+    (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(targetDir), { recursive: true });
     try {
       backupDir = `${targetDir}.bak.${Date.now()}`;
-      (0, import_node_fs10.renameSync)(targetDir, backupDir);
+      (0, import_node_fs9.renameSync)(targetDir, backupDir);
     } catch {
       backupDir = null;
     }
-    (0, import_node_fs10.renameSync)(stagingDir, targetDir);
+    (0, import_node_fs9.renameSync)(stagingDir, targetDir);
     try {
       await updateConfigRecord2(version, tgzUrl);
     } catch (err2) {
@@ -8137,7 +7641,7 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
     }
     if (backupDir) {
       try {
-        (0, import_node_fs10.rmSync)(backupDir, { force: true, recursive: true });
+        (0, import_node_fs9.rmSync)(backupDir, { force: true, recursive: true });
       } catch {
       }
     }
@@ -8147,8 +7651,8 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
   } catch (err2) {
     if (backupDir) {
       try {
-        (0, import_node_fs10.rmSync)(targetDir, { force: true, recursive: true });
-        (0, import_node_fs10.renameSync)(backupDir, targetDir);
+        (0, import_node_fs9.rmSync)(targetDir, { force: true, recursive: true });
+        (0, import_node_fs9.renameSync)(backupDir, targetDir);
         logger.info("\u5DF2\u56DE\u6EDA\u5230\u4E4B\u524D\u7248\u672C");
       } catch (rollbackErr) {
         logger.error(`\u56DE\u6EDA\u5931\u8D25: ${String(rollbackErr)}`);
@@ -8159,7 +7663,7 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
     return { success: false, message: errMsg };
   } finally {
     try {
-      (0, import_node_fs10.rmSync)(workDir, { force: true, recursive: true });
+      (0, import_node_fs9.rmSync)(workDir, { force: true, recursive: true });
     } catch {
     }
   }
@@ -8174,7 +7678,7 @@ function resolveTargetDir(api) {
     if (installPath) return installPath;
   } catch {
   }
-  return (0, import_node_path10.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
+  return (0, import_node_path9.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
 }
 async function updateConfigRecord(api, version, targetDir, tgzUrl) {
   const configApi = api.runtime.config;
@@ -8362,10 +7866,10 @@ function registerAutoUpdateLifecycle(deps) {
 }
 
 // src/plugin/cli.ts
-var import_node_path18 = require("path");
+var import_node_path17 = require("path");
 
 // src/cli/auth.ts
-var import_node_fs11 = require("fs");
+var import_node_fs10 = require("fs");
 init_credentials();
 function registerAuthCli(program) {
   const auth = program.command("auth").description("\u7528\u6237\u8BA4\u8BC1\u7BA1\u7406");
@@ -8401,12 +7905,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_fs11.existsSync)(path2)) {
+    if ((0, import_node_fs10.existsSync)(path2)) {
       const creds = readCredentials();
       delete creds.apiKey;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
-        (0, import_node_fs11.rmSync)(path2, { force: true });
+        (0, import_node_fs10.rmSync)(path2, { force: true });
       } else {
         writeCredentials(creds);
       }
@@ -8538,23 +8042,23 @@ function registerNtfStats(ntf, ctx) {
 }
 
 // src/cli/ntf-sync.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");
 var SYNC_FETCH_LIMIT = 300;
 function checkpointPath(dir) {
-  return (0, import_node_path11.join)(dir, ".checkpoint.json");
+  return (0, import_node_path10.join)(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!(0, import_node_fs12.existsSync)(p)) return {};
+  if (!(0, import_node_fs11.existsSync)(p)) return {};
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_node_fs11.readFileSync)(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCheckpoint(dir, data) {
-  (0, import_node_fs12.writeFileSync)(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
+  (0, import_node_fs11.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");
@@ -8647,24 +8151,24 @@ function registerNtfSync(ntf, ctx) {
 }
 
 // src/cli/ntf-monitor.ts
-var import_node_fs13 = require("fs");
-var import_node_path12 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path11 = require("path");
 function tasksDir2(ctx) {
   const base = ctx.workspaceDir || ctx.stateDir;
   if (!base) throw new Error("workspaceDir and stateDir both unavailable");
-  return (0, import_node_path12.join)(base, "tasks");
+  return (0, import_node_path11.join)(base, "tasks");
 }
 function readMeta2(taskDir) {
-  const metaPath = (0, import_node_path12.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs13.existsSync)(metaPath)) return null;
+  const metaPath = (0, import_node_path11.join)(taskDir, "meta.json");
+  if (!(0, import_node_fs12.existsSync)(metaPath)) return null;
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)(metaPath, "utf-8"));
+    return JSON.parse((0, import_node_fs12.readFileSync)(metaPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeMeta2(taskDir, meta) {
-  (0, import_node_fs13.writeFileSync)((0, import_node_path12.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  (0, import_node_fs12.writeFileSync)((0, import_node_path11.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function generateReadme(name, description) {
   return `# Monitor Task: ${name}
@@ -8683,27 +8187,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_fs13.existsSync)(dir)) {
+    if (!(0, import_node_fs12.existsSync)(dir)) {
       output({ ok: true, tasks: [] });
       return;
     }
     const tasks = [];
-    for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const meta = readMeta2((0, import_node_path12.join)(dir, entry.name));
+      const meta = readMeta2((0, import_node_path11.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_path12.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path11.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_path12.join)(taskDir, "checkpoint.json");
+    const checkpointPath2 = (0, import_node_path11.join)(taskDir, "checkpoint.json");
     let checkpoint = {};
-    if ((0, import_node_fs13.existsSync)(checkpointPath2)) {
+    if ((0, import_node_fs12.existsSync)(checkpointPath2)) {
       try {
-        checkpoint = JSON.parse((0, import_node_fs13.readFileSync)(checkpointPath2, "utf-8"));
+        checkpoint = JSON.parse((0, import_node_fs12.readFileSync)(checkpointPath2, "utf-8"));
       } catch {
       }
     }
@@ -8718,8 +8222,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_path12.join)(dir, name);
-      if ((0, import_node_fs13.existsSync)(taskDir)) {
+      const taskDir = (0, import_node_path11.join)(dir, name);
+      if ((0, import_node_fs12.existsSync)(taskDir)) {
         exitError("ALREADY_EXISTS", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u5DF2\u5B58\u5728`);
       }
       let matchRules;
@@ -8731,7 +8235,7 @@ function registerNtfMonitor(ntf, ctx) {
           "match-rules \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON"
         );
       }
-      (0, import_node_fs13.mkdirSync)(taskDir, { recursive: true });
+      (0, import_node_fs12.mkdirSync)(taskDir, { recursive: true });
       const meta = {
         name,
         description: opts.description,
@@ -8741,13 +8245,13 @@ function registerNtfMonitor(ntf, ctx) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeMeta2(taskDir, meta);
-      (0, import_node_fs13.writeFileSync)(
-        (0, import_node_path12.join)(taskDir, "fetch.py"),
+      (0, import_node_fs12.writeFileSync)(
+        (0, import_node_path11.join)(taskDir, "fetch.py"),
         generateFetchPy(name, matchRules),
         "utf-8"
       );
-      (0, import_node_fs13.writeFileSync)(
-        (0, import_node_path12.join)(taskDir, "README.md"),
+      (0, import_node_fs12.writeFileSync)(
+        (0, import_node_path11.join)(taskDir, "README.md"),
         generateReadme(name, opts.description),
         "utf-8"
       );
@@ -8775,8 +8279,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_path12.join)(tasksDir2(ctx), name);
-    if (!(0, import_node_fs13.existsSync)(taskDir)) {
+    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    if (!(0, import_node_fs12.existsSync)(taskDir)) {
       exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     }
     if (!opts.yes) {
@@ -8789,7 +8293,7 @@ function registerNtfMonitor(ntf, ctx) {
       });
       process.exit(1);
     }
-    (0, import_node_fs13.rmSync)(taskDir, { recursive: true, force: true });
+    (0, import_node_fs12.rmSync)(taskDir, { recursive: true, force: true });
     output({
       ok: true,
       name,
@@ -8801,7 +8305,7 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("enable <name>").description("\u542F\u7528\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = (0, import_node_path12.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = true;
@@ -8809,7 +8313,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_path12.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = false;
@@ -8853,9 +8357,9 @@ function registerLightSend(light) {
 }
 
 // src/cli/light-setup-tools.ts
-var import_node_fs14 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path13 = require("path");
+var import_node_path12 = require("path");
 function isObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -8869,7 +8373,7 @@ function ensureArray(obj, key) {
 function resolveConfigPath2() {
   const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
   if (fromEnv) return fromEnv;
-  return (0, import_node_path13.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
+  return (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
 }
 var LIGHT_TOOLS = [
   "light_control",
@@ -8916,12 +8420,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_fs14.existsSync)(configPath)) {
+    if (!(0, import_node_fs13.existsSync)(configPath)) {
       exitError("CONFIG_NOT_FOUND", `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
     }
     let cfg = {};
     try {
-      const raw = (0, import_node_fs14.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs13.readFileSync)(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (isObject(parsed)) cfg = parsed;
     } catch (err2) {
@@ -8929,8 +8433,8 @@ function registerLightSetupTools(light) {
     }
     const result = upsertLightControlAlsoAllow(cfg);
     try {
-      (0, import_node_fs14.mkdirSync)((0, import_node_path13.dirname)(configPath), { recursive: true });
-      (0, import_node_fs14.writeFileSync)(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+      (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");
     } catch (err2) {
       exitError("WRITE_FAILED", `\u5199\u5165\u914D\u7F6E\u5931\u8D25: ${err2?.message ?? String(err2)}`);
     }
@@ -8948,17 +8452,17 @@ function registerLightSetupTools(light) {
 }
 
 // src/cli/tunnel-status.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");
 init_credentials();
 init_env();
-var STATUS_REL_PATH = (0, import_node_path14.join)("plugins", "phone-notifications", "tunnel-status.json");
+var STATUS_REL_PATH = (0, import_node_path13.join)("plugins", "phone-notifications", "tunnel-status.json");
 function readTunnelStatus(ctx) {
   if (!ctx.stateDir) return null;
-  const filePath = (0, import_node_path14.join)(ctx.stateDir, STATUS_REL_PATH);
-  if (!(0, import_node_fs15.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path13.join)(ctx.stateDir, STATUS_REL_PATH);
+  if (!(0, import_node_fs14.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs15.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs14.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -9026,24 +8530,24 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-var import_node_fs16 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path14 = require("path");
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = (0, import_node_path15.join)(
+    const dir = (0, import_node_path14.join)(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "logs"
     );
-    if ((0, import_node_fs16.existsSync)(dir)) return dir;
+    if ((0, import_node_fs15.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_fs16.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
     if (!entry.isFile()) continue;
     const m = pattern.exec(entry.name);
     if (m) keys.push(m[1]);
@@ -9051,9 +8555,9 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = (0, import_node_path15.join)(dir, `${dateKey}.log`);
-  if (!(0, import_node_fs16.existsSync)(filePath)) return;
-  const content = (0, import_node_fs16.readFileSync)(filePath, "utf-8");
+  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 lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split("\n")) {
     if (collected.length >= limit) return;
@@ -9120,12 +8624,12 @@ function registerEnvCli(ntf) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs20 = require("fs");
+var import_node_fs19 = require("fs");
 var import_node_readline = require("readline");
 init_host();
 
 // src/cli/doctor/check-dangerous-flags.ts
-var import_node_fs17 = require("fs");
+var import_node_fs16 = require("fs");
 function isObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
@@ -9142,13 +8646,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_fs17.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs16.readFileSync)(configPath, "utf-8");
       const config = JSON.parse(raw);
       const gw = config.gateway;
       const cui = gw.controlUi;
       cui.dangerouslyDisableDeviceAuth = false;
-      (0, import_node_fs17.copyFileSync)(configPath, configPath + ".bak");
-      (0, import_node_fs17.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      (0, import_node_fs16.copyFileSync)(configPath, configPath + ".bak");
+      (0, import_node_fs16.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     }
   };
 };
@@ -9196,11 +8700,11 @@ function warnEmpty() {
 }
 
 // src/cli/doctor/check-state-dir-perms.ts
-var import_node_fs18 = require("fs");
+var import_node_fs17 = require("fs");
 var checkStateDirPerms = ({ stateDir }) => {
   let mode;
   try {
-    mode = (0, import_node_fs18.statSync)(stateDir).mode;
+    mode = (0, import_node_fs17.statSync)(stateDir).mode;
   } catch {
     return null;
   }
@@ -9214,7 +8718,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_fs18.chmodSync)(stateDir, 448);
+      (0, import_node_fs17.chmodSync)(stateDir, 448);
     }
   };
 };
@@ -9269,16 +8773,16 @@ var checkCredentials = () => {
 };
 
 // src/cli/doctor/check-tunnel.ts
-var import_node_fs19 = require("fs");
-var import_node_path16 = require("path");
-var STATUS_REL_PATH2 = (0, import_node_path16.join)(
+var import_node_fs18 = require("fs");
+var import_node_path15 = require("path");
+var STATUS_REL_PATH2 = (0, import_node_path15.join)(
   "plugins",
   "phone-notifications",
   "tunnel-status.json"
 );
 var checkTunnel = ({ stateDir }) => {
-  const filePath = (0, import_node_path16.join)(stateDir, STATUS_REL_PATH2);
-  if (!(0, import_node_fs19.existsSync)(filePath)) {
+  const filePath = (0, import_node_path15.join)(stateDir, STATUS_REL_PATH2);
+  if (!(0, import_node_fs18.existsSync)(filePath)) {
     return {
       id: "tunnel",
       severity: "warn",
@@ -9290,7 +8794,7 @@ var checkTunnel = ({ stateDir }) => {
   }
   let status;
   try {
-    status = JSON.parse((0, import_node_fs19.readFileSync)(filePath, "utf-8"));
+    status = JSON.parse((0, import_node_fs18.readFileSync)(filePath, "utf-8"));
   } catch {
     return {
       id: "tunnel",
@@ -9383,9 +8887,9 @@ function isObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function readConfig(configPath) {
-  if (!(0, import_node_fs20.existsSync)(configPath)) return {};
+  if (!(0, import_node_fs19.existsSync)(configPath)) return {};
   try {
-    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(configPath, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs19.readFileSync)(configPath, "utf-8"));
     return isObject5(parsed) ? parsed : {};
   } catch {
     return {};
@@ -9586,7 +9090,7 @@ function registerRecStoragePath(rec, ctx) {
 
 // src/cli/rec-setup.ts
 var import_node_readline2 = require("readline");
-var import_node_fs21 = require("fs");
+var import_node_fs20 = require("fs");
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
@@ -9672,9 +9176,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_fs21.existsSync)(configPath)) {
+    if ((0, import_node_fs20.existsSync)(configPath)) {
       try {
-        const existing = JSON.parse((0, import_node_fs21.readFileSync)(configPath, "utf-8"));
+        const existing = JSON.parse((0, import_node_fs20.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");
@@ -9687,7 +9191,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_fs21.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
+      (0, import_node_fs20.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
       process.stderr.write(`
 \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${configPath}
 
@@ -9701,8 +9205,8 @@ function registerRecSetup(rec, ctx) {
 
 // src/cli/update.ts
 var import_node_child_process = require("child_process");
-var import_node_fs22 = require("fs");
-var import_node_path17 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path16 = require("path");
 var import_node_os3 = __toESM(require("os"), 1);
 init_host();
 var BASE_URL2 = "https://artifact.yoooclaw.com/plugin";
@@ -9761,9 +9265,9 @@ async function runUpdate(ctx, opts) {
 `);
     process.exit(1);
   }
-  const tmpScript = (0, import_node_path17.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
+  const tmpScript = (0, import_node_path16.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
   try {
-    (0, import_node_fs22.writeFileSync)(tmpScript, installScript, "utf-8");
+    (0, import_node_fs21.writeFileSync)(tmpScript, installScript, "utf-8");
   } catch (err2) {
     const msg = `\u5199\u5165\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${err2?.message ?? String(err2)}`;
     if (json) {
@@ -9781,7 +9285,7 @@ async function runUpdate(ctx, opts) {
     { stdio: "inherit" }
   );
   try {
-    (0, import_node_fs22.unlinkSync)(tmpScript);
+    (0, import_node_fs21.unlinkSync)(tmpScript);
   } catch {
   }
   if (result.error) {
@@ -9845,10 +9349,10 @@ function inferOpenClawRootDir(workspaceDir) {
   if (!workspaceDir) {
     return void 0;
   }
-  if ((0, import_node_path18.basename)(workspaceDir) !== "workspace") {
+  if ((0, import_node_path17.basename)(workspaceDir) !== "workspace") {
     return void 0;
   }
-  return (0, import_node_path18.dirname)(workspaceDir);
+  return (0, import_node_path17.dirname)(workspaceDir);
 }
 function registerPluginCli(api, params) {
   const { logger, openclawDir } = params;
@@ -10015,214 +9519,530 @@ var lightControlParameters = {
         }
       }
     },
-    reason: {
-      type: "string",
-      description: "\u7ED3\u5408\u5BF9\u8BDD\u4E0A\u4E0B\u6587\uFF0C\u7B80\u8981\u8BF4\u660E\u4E3A\u4EC0\u4E48\u8981\u4EAE\u706F\uFF08\u4F8B\u5982\uFF1A\u7528\u6237\u5FC3\u60C5\u4F4E\u843D\u60F3\u8981\u6E29\u6696\u6C1B\u56F4\u3001\u5E86\u795D\u751F\u65E5\u3001\u63D0\u9192\u559D\u6C34\u7B49\uFF09\u3002\u8FD9\u4E2A\u5B57\u6BB5\u5E2E\u52A9\u8BB0\u5F55\u6BCF\u6B21\u4EAE\u706F\u7684\u610F\u56FE\u548C\u52A8\u673A\u3002"
-    },
-    repeat: {
-      type: "boolean",
-      description: "\u517C\u5BB9\u65E7\u53C2\u6570\u3002true = \u65E0\u9650\u5FAA\u73AF\uFF0Cfalse/\u4E0D\u586B = \u4E00\u8F6E\uFF1B\u82E5\u540C\u65F6\u63D0\u4F9B repeat_times\uFF0C\u5219\u4EE5\u540E\u8005\u4E3A\u51C6"
+    reason: {
+      type: "string",
+      description: "\u7ED3\u5408\u5BF9\u8BDD\u4E0A\u4E0B\u6587\uFF0C\u7B80\u8981\u8BF4\u660E\u4E3A\u4EC0\u4E48\u8981\u4EAE\u706F\uFF08\u4F8B\u5982\uFF1A\u7528\u6237\u5FC3\u60C5\u4F4E\u843D\u60F3\u8981\u6E29\u6696\u6C1B\u56F4\u3001\u5E86\u795D\u751F\u65E5\u3001\u63D0\u9192\u559D\u6C34\u7B49\uFF09\u3002\u8FD9\u4E2A\u5B57\u6BB5\u5E2E\u52A9\u8BB0\u5F55\u6BCF\u6B21\u4EAE\u706F\u7684\u610F\u56FE\u548C\u52A8\u673A\u3002"
+    },
+    repeat: {
+      type: "boolean",
+      description: "\u517C\u5BB9\u65E7\u53C2\u6570\u3002true = \u65E0\u9650\u5FAA\u73AF\uFF0Cfalse/\u4E0D\u586B = \u4E00\u8F6E\uFF1B\u82E5\u540C\u65F6\u63D0\u4F9B repeat_times\uFF0C\u5219\u4EE5\u540E\u8005\u4E3A\u51C6"
+    },
+    repeat_times: {
+      type: "number",
+      minimum: 0,
+      description: "\u6574\u6761\u7EC4\u5408\u91CD\u590D\u6B21\u6570\uFF1A0 = \u65E0\u9650\u5FAA\u73AF\uFF0C1 = \u64AD\u653E\u4E00\u8F6E\u3002\u5F53\u524D ANCS \u8DEF\u5F84\u4E0D\u652F\u6301 N>=2"
+    }
+  }
+};
+function registerLightControlTool(api, logger) {
+  api.registerTool({
+    name: "light_control",
+    label: "Light Control",
+    description: '\u63A7\u5236\u786C\u4EF6\u706F\u6548\uFF0C\u652F\u6301 1\u201312 \u6BB5\u987A\u5E8F\u706F\u6548\uFF0C\u6BCF\u6BB5\u72EC\u7ACB\u53C2\u6570\uFF086 \u79CD\u6A21\u5F0F\uFF1A\u6CE2\u6D6A/\u547C\u5438/\u9891\u95EA/\u5E38\u4EAE/\u6D41\u5149/\u9010\u7EC4\u50CF\u7D20\u5E27\uFF09\u3002Tool \u5185\u90E8\u81EA\u52A8\u91CF\u5316\u4E3A\u5D4C\u5165\u5F0F\u534F\u8BAE\u5B9A\u4E49\u7684\u79BB\u6563\u6863\u4F4D\uFF0C\u5E76\u6309\u6A21\u5F0F\u7CBE\u7B80\u4E3A\u53D8\u957F ANCS \u63A7\u5236\u5E8F\u5217\uFF0C\u901A\u8FC7 HTTP \u63A5\u53E3\u4E0B\u53D1\u706F\u6548\u6307\u4EE4\u3002\u5F53\u7528\u6237\u8BF4"\u5F00\u706F"\u3001"\u6362\u4E2A\u706F\u6548"\u3001"\u628A\u706F\u8C03\u6210\u7EA2\u8272"\u3001"\u8425\u9020\u6C1B\u56F4"\u7B49\u4E0E\u706F\u5149\u63A7\u5236\u76F8\u5173\u7684\u8868\u8FBE\u65F6\u8C03\u7528\u3002',
+    parameters: lightControlParameters,
+    async execute(_toolCallId, params) {
+      let apiKey;
+      try {
+        apiKey = requireApiKey();
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: e.message }],
+          details: { ok: false, error: { code: "AUTH_REQUIRED", message: e.message } }
+        };
+      }
+      const { segments, reason, repeat, repeat_times } = params;
+      const validation = validateSegments(segments);
+      if (!validation.valid) {
+        return {
+          content: [{ type: "text", text: JSON.stringify(validation.errors) }],
+          details: {
+            ok: false,
+            error: { code: "VALIDATION_FAILED", details: validation.errors }
+          }
+        };
+      }
+      let repeatTimes;
+      try {
+        repeatTimes = normalizeRepeatTimes({ repeat, repeat_times });
+        assertAncsRepeatTimes(repeatTimes);
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error?.message ?? String(error) }],
+          details: {
+            ok: false,
+            error: { code: "VALIDATION_FAILED", message: error?.message ?? String(error) }
+          }
+        };
+      }
+      logger.info(`Light control reason: ${reason}`);
+      const result = await sendLightEffect(
+        apiKey,
+        validation.segments,
+        logger,
+        { repeat_times: repeatTimes },
+        reason
+      );
+      if (!result.ok) {
+        logger.warn(
+          `Light control HTTP request failed: ${result.status} ${result.error}`
+        );
+      } else {
+        logger.info(`Light control sent, bizUniqueId=${result.bizUniqueId}`);
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        details: result
+      };
+    }
+  });
+}
+
+// src/plugin/lifecycle.ts
+var import_node_fs31 = require("fs");
+init_host();
+
+// src/notification/app-name-map.ts
+var import_node_fs22 = require("fs");
+var import_node_path18 = require("path");
+init_credentials();
+init_env();
+var PLUGIN_STATE_DIR = "phone-notifications";
+var CACHE_FILE = "app-name-map.json";
+var BUILTIN_APP_NAME_MAP_URL = getEnvUrls().appNameMapUrl;
+var APP_NAME_MAP_URL = ("".trim() ? "".trim() : void 0) ?? BUILTIN_APP_NAME_MAP_URL;
+var APP_NAME_MAP_REFRESH_HOURS = 12;
+function isRecordOfStrings(v) {
+  if (v === null || typeof v !== "object") return false;
+  for (const val of Object.values(v)) if (typeof val !== "string") return false;
+  return true;
+}
+function isAppNameMapApiResponse(v) {
+  if (v === null || typeof v !== "object") return false;
+  const o = v;
+  return Array.isArray(o.data) && o.data.every(
+    (item) => item !== null && typeof item === "object" && typeof item.packageName === "string" && typeof item.appName === "string"
+  );
+}
+function getCachePath(stateDir) {
+  return (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+}
+function createAppNameMapProvider(opts) {
+  const { stateDir, logger } = opts;
+  const url = APP_NAME_MAP_URL;
+  const refreshHours = APP_NAME_MAP_REFRESH_HOURS;
+  const map = /* @__PURE__ */ new Map();
+  let refreshTimer = null;
+  let stopWatching = null;
+  let inFlightFetch = null;
+  function loadFromDisk() {
+    const path2 = getCachePath(stateDir);
+    if (!(0, import_node_fs22.existsSync)(path2)) return;
+    try {
+      const raw = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+      if (!isRecordOfStrings(raw)) return;
+      map.clear();
+      for (const [k, v] of Object.entries(raw)) map.set(k, v);
+      logger.info(`[app-name-map] loaded ${map.size} entries from cache: ${path2}`);
+    } catch {
+    }
+  }
+  async function fetchFromServer() {
+    const apiKey = loadApiKey();
+    if (!url) {
+      logger.warn("[app-name-map] APP_NAME_MAP_URL is empty, skip refresh");
+      return;
+    }
+    if (!apiKey) {
+      logger.info("[app-name-map] api key missing, skip refresh");
+      return;
+    }
+    const rawApiKey = apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Api-Key-Id": rawApiKey },
+        body: JSON.stringify({
+          platform: ""
+        })
+      });
+      if (!res.ok) {
+        logger.warn(`[app-name-map] refresh failed: HTTP ${res.status} ${res.statusText}`);
+        return;
+      }
+      const body = await res.json();
+      if (!isAppNameMapApiResponse(body) || !body.success || !body.data?.length) {
+        logger.warn("[app-name-map] refresh failed: unexpected response shape or empty data");
+        return;
+      }
+      map.clear();
+      for (const item of body.data) {
+        if (item.packageName && item.appName) map.set(item.packageName, item.appName);
+      }
+      if (map.size === 0) {
+        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 cachePath = getCachePath(stateDir);
+      (0, import_node_fs22.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);
+      logger.warn(`[app-name-map] refresh error: ${message}`);
+    }
+  }
+  async function ensureOneFetch() {
+    if (inFlightFetch) return inFlightFetch;
+    inFlightFetch = fetchFromServer().finally(() => {
+      inFlightFetch = null;
+    });
+    return inFlightFetch;
+  }
+  return {
+    async resolveDisplayName(packageName) {
+      if (map.has(packageName)) return map.get(packageName);
+      return packageName;
+    },
+    async start() {
+      loadFromDisk();
+      await fetchFromServer();
+      if (!url) return;
+      if (refreshHours > 0) {
+        const ms = refreshHours * 60 * 60 * 1e3;
+        refreshTimer = setInterval(() => fetchFromServer().catch(() => {
+        }), ms);
+      }
+      stopWatching = watchCredentials(() => fetchFromServer().catch(() => {
+      }));
     },
-    repeat_times: {
-      type: "number",
-      minimum: 0,
-      description: "\u6574\u6761\u7EC4\u5408\u91CD\u590D\u6B21\u6570\uFF1A0 = \u65E0\u9650\u5FAA\u73AF\uFF0C1 = \u64AD\u653E\u4E00\u8F6E\u3002\u5F53\u524D ANCS \u8DEF\u5F84\u4E0D\u652F\u6301 N>=2"
+    stop() {
+      stopWatching?.();
+      stopWatching = null;
+      if (refreshTimer) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+      }
+      map.clear();
     }
+  };
+}
+
+// src/notification/storage.ts
+var import_node_fs23 = require("fs");
+var import_node_crypto2 = require("crypto");
+var import_node_path19 = 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);
+}
+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);
+    return true;
+  } catch {
+    return false;
   }
-};
-function registerLightControlTool(api, logger) {
-  api.registerTool({
-    name: "light_control",
-    label: "Light Control",
-    description: '\u63A7\u5236\u786C\u4EF6\u706F\u6548\uFF0C\u652F\u6301 1\u201312 \u6BB5\u987A\u5E8F\u706F\u6548\uFF0C\u6BCF\u6BB5\u72EC\u7ACB\u53C2\u6570\uFF086 \u79CD\u6A21\u5F0F\uFF1A\u6CE2\u6D6A/\u547C\u5438/\u9891\u95EA/\u5E38\u4EAE/\u6D41\u5149/\u9010\u7EC4\u50CF\u7D20\u5E27\uFF09\u3002Tool \u5185\u90E8\u81EA\u52A8\u91CF\u5316\u4E3A\u5D4C\u5165\u5F0F\u534F\u8BAE\u5B9A\u4E49\u7684\u79BB\u6563\u6863\u4F4D\uFF0C\u5E76\u6309\u6A21\u5F0F\u7CBE\u7B80\u4E3A\u53D8\u957F ANCS \u63A7\u5236\u5E8F\u5217\uFF0C\u901A\u8FC7 HTTP \u63A5\u53E3\u4E0B\u53D1\u706F\u6548\u6307\u4EE4\u3002\u5F53\u7528\u6237\u8BF4"\u5F00\u706F"\u3001"\u6362\u4E2A\u706F\u6548"\u3001"\u628A\u706F\u8C03\u6210\u7EA2\u8272"\u3001"\u8425\u9020\u6C1B\u56F4"\u7B49\u4E0E\u706F\u5149\u63A7\u5236\u76F8\u5173\u7684\u8868\u8FBE\u65F6\u8C03\u7528\u3002',
-    parameters: lightControlParameters,
-    async execute(_toolCallId, params) {
-      let apiKey;
-      try {
-        apiKey = requireApiKey();
-      } catch (e) {
-        return {
-          content: [{ type: "text", text: e.message }],
-          details: { ok: false, error: { code: "AUTH_REQUIRED", message: e.message } }
-        };
+}
+function resolveNotificationStorageDir(ctx, logger) {
+  const stateNotifDir = getStateFallbackNotificationDir(ctx.stateDir);
+  if (ensureWritableDirectory(stateNotifDir)) {
+    logger.info(`\u901A\u77E5\u5C06\u5199\u5165 stateDir \u8DEF\u5F84: ${stateNotifDir}`);
+    return stateNotifDir;
+  }
+  if (ctx.workspaceDir) {
+    const workspaceDir = (0, import_node_path19.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}`
+      );
+      return workspaceDir;
+    }
+  }
+  throw new Error(`\u901A\u77E5\u5B58\u50A8\u76EE\u5F55\u4E0D\u53EF\u7528: ${stateNotifDir}`);
+}
+var NotificationStorage = class {
+  constructor(dir, config, logger, resolveDisplayName) {
+    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.resolveDisplayName = resolveDisplayName;
+  }
+  dir;
+  idIndexDir;
+  contentKeyIndexDir;
+  idCache = /* @__PURE__ */ new Map();
+  contentKeyCache = /* @__PURE__ */ new Map();
+  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 });
+  }
+  async ingest(items) {
+    const result = {
+      received: items.length,
+      ingested: 0,
+      dedupedById: 0,
+      dedupedByContent: 0,
+      invalid: 0,
+      inserted: []
+    };
+    for (const n of items) {
+      const outcome = await this.writeNotification(n);
+      switch (outcome.kind) {
+        case "ingested":
+          result.ingested += 1;
+          result.inserted.push(outcome.entry);
+          break;
+        case "dedupedById":
+          result.dedupedById += 1;
+          break;
+        case "dedupedByContent":
+          result.dedupedByContent += 1;
+          break;
+        case "invalid":
+          result.invalid += 1;
+          break;
       }
-      const { segments, reason, repeat, repeat_times } = params;
-      const validation = validateSegments(segments);
-      if (!validation.valid) {
-        return {
-          content: [{ type: "text", text: JSON.stringify(validation.errors) }],
-          details: {
-            ok: false,
-            error: { code: "VALIDATION_FAILED", details: validation.errors }
-          }
-        };
+    }
+    this.prune();
+    return result;
+  }
+  async writeNotification(n) {
+    const ts = new Date(n.timestamp);
+    if (Number.isNaN(ts.getTime())) {
+      this.logger.warn(`\u5FFD\u7565\u975E\u6CD5 timestamp \u7684\u901A\u77E5: ${n.id}`);
+      return { kind: "invalid" };
+    }
+    const dateKey = this.formatDate(ts);
+    const filePath = (0, import_node_path19.join)(this.dir, `${dateKey}.json`);
+    const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
+    const entry = this.buildStoredNotification(n);
+    return this.withDateWriteLock(dateKey, async () => {
+      if (normalizedId && this.hasNotificationId(dateKey, normalizedId)) {
+        return { kind: "dedupedById" };
       }
-      let repeatTimes;
-      try {
-        repeatTimes = normalizeRepeatTimes({ repeat, repeat_times });
-        assertAncsRepeatTimes(repeatTimes);
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: error?.message ?? String(error) }],
-          details: {
-            ok: false,
-            error: { code: "VALIDATION_FAILED", message: error?.message ?? String(error) }
-          }
-        };
+      if (this.hasNotificationContentKey(dateKey, filePath, entry)) {
+        return { kind: "dedupedByContent" };
+      }
+      const appDisplayName = this.resolveDisplayName ? await this.resolveDisplayName(entry.appName) : entry.appName;
+      const storedEntry = {
+        ...entry,
+        appDisplayName
+      };
+      const arr = this.readStoredNotifications(filePath);
+      arr.push(storedEntry);
+      (0, import_node_fs23.writeFileSync)(filePath, JSON.stringify(arr, null, 2), "utf-8");
+      if (normalizedId) {
+        this.recordNotificationId(dateKey, normalizedId);
+      }
+      this.recordNotificationContentKey(dateKey, filePath, storedEntry);
+      return { kind: "ingested", entry: storedEntry };
+    });
+  }
+  buildStoredNotification(n) {
+    return {
+      appName: typeof n.app === "string" && n.app ? n.app : "Unknown",
+      title: typeof n.title === "string" ? n.title : "",
+      content: this.buildContent(n),
+      timestamp: n.timestamp
+    };
+  }
+  buildContent(n) {
+    const body = n.body?.trim();
+    if (body) {
+      return body;
+    }
+    const fallback = [];
+    if (n.category) {
+      fallback.push(`category:${n.category}`);
+    }
+    if (n.metadata && Object.keys(n.metadata).length > 0) {
+      fallback.push(`metadata:${JSON.stringify(n.metadata)}`);
+    }
+    return fallback.join(" ; ") || "-";
+  }
+  formatDate(d) {
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+  }
+  getIdIndexPath(dateKey) {
+    return (0, import_node_path19.join)(this.idIndexDir, `${dateKey}.ids`);
+  }
+  getIdSet(dateKey) {
+    const cached = this.idCache.get(dateKey);
+    if (cached) {
+      return cached;
+    }
+    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/);
+      for (const line of lines) {
+        const id = line.trim();
+        if (id) {
+          ids.add(id);
+        }
       }
-      logger.info(`Light control reason: ${reason}`);
-      const result = await sendLightEffect(
-        apiKey,
-        validation.segments,
-        logger,
-        { repeat_times: repeatTimes },
-        reason
-      );
-      if (!result.ok) {
-        logger.warn(
-          `Light control HTTP request failed: ${result.status} ${result.error}`
-        );
-      } else {
-        logger.info(`Light control sent, bizUniqueId=${result.bizUniqueId}`);
+    }
+    this.idCache.set(dateKey, ids);
+    return ids;
+  }
+  hasNotificationId(dateKey, id) {
+    return this.getIdSet(dateKey).has(id);
+  }
+  getContentKeyIndexPath(dateKey) {
+    return (0, import_node_path19.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
+  }
+  getContentKeySet(dateKey, filePath) {
+    const cached = this.contentKeyCache.get(dateKey);
+    if (cached) {
+      return cached;
+    }
+    const keyPath = this.getContentKeyIndexPath(dateKey);
+    const keys = /* @__PURE__ */ new Set();
+    if ((0, import_node_fs23.existsSync)(filePath)) {
+      for (const item of this.readStoredNotifications(filePath)) {
+        keys.add(this.buildNotificationContentKey(item));
       }
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        details: result
-      };
     }
-  });
-}
-
-// src/plugin/lifecycle.ts
-var import_node_fs31 = require("fs");
-init_host();
-
-// src/notification/app-name-map.ts
-var import_node_fs23 = require("fs");
-var import_node_path19 = require("path");
-init_credentials();
-init_env();
-var PLUGIN_STATE_DIR = "phone-notifications";
-var CACHE_FILE = "app-name-map.json";
-var BUILTIN_APP_NAME_MAP_URL = getEnvUrls().appNameMapUrl;
-var APP_NAME_MAP_URL = ("".trim() ? "".trim() : void 0) ?? BUILTIN_APP_NAME_MAP_URL;
-var APP_NAME_MAP_REFRESH_HOURS = 12;
-function isRecordOfStrings(v) {
-  if (v === null || typeof v !== "object") return false;
-  for (const val of Object.values(v)) if (typeof val !== "string") return false;
-  return true;
-}
-function isAppNameMapApiResponse(v) {
-  if (v === null || typeof v !== "object") return false;
-  const o = v;
-  return Array.isArray(o.data) && o.data.every(
-    (item) => item !== null && typeof item === "object" && typeof item.packageName === "string" && typeof item.appName === "string"
-  );
-}
-function getCachePath(stateDir) {
-  return (0, import_node_path19.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
-}
-function createAppNameMapProvider(opts) {
-  const { stateDir, logger } = opts;
-  const url = APP_NAME_MAP_URL;
-  const refreshHours = APP_NAME_MAP_REFRESH_HOURS;
-  const map = /* @__PURE__ */ new Map();
-  let refreshTimer = null;
-  let stopWatching = null;
-  let inFlightFetch = null;
-  function loadFromDisk() {
-    const path2 = getCachePath(stateDir);
-    if (!(0, import_node_fs23.existsSync)(path2)) return;
-    try {
-      const raw = JSON.parse((0, import_node_fs23.readFileSync)(path2, "utf-8"));
-      if (!isRecordOfStrings(raw)) return;
-      map.clear();
-      for (const [k, v] of Object.entries(raw)) map.set(k, v);
-      logger.info(`[app-name-map] loaded ${map.size} entries from cache: ${path2}`);
-    } catch {
+    if (keys.size > 0) {
+      (0, import_node_fs23.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 });
     }
+    this.contentKeyCache.set(dateKey, keys);
+    return keys;
   }
-  async function fetchFromServer() {
-    const apiKey = loadApiKey();
-    if (!url) {
-      logger.warn("[app-name-map] APP_NAME_MAP_URL is empty, skip refresh");
+  hasNotificationContentKey(dateKey, filePath, entry) {
+    return this.getContentKeySet(dateKey, filePath).has(
+      this.buildNotificationContentKey(entry)
+    );
+  }
+  recordNotificationId(dateKey, id) {
+    const ids = this.getIdSet(dateKey);
+    if (ids.has(id)) {
       return;
     }
-    if (!apiKey) {
-      logger.info("[app-name-map] api key missing, skip refresh");
+    (0, import_node_fs23.appendFileSync)(this.getIdIndexPath(dateKey), `${id}
+`, "utf-8");
+    ids.add(id);
+  }
+  recordNotificationContentKey(dateKey, filePath, entry) {
+    const keys = this.getContentKeySet(dateKey, filePath);
+    const key = this.buildNotificationContentKey(entry);
+    if (keys.has(key)) {
       return;
     }
-    const rawApiKey = apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
+    (0, import_node_fs23.appendFileSync)(this.getContentKeyIndexPath(dateKey), `${key}
+`, "utf-8");
+    keys.add(key);
+  }
+  buildNotificationContentKey(entry) {
+    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)) {
+      return [];
+    }
     try {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", "X-Api-Key-Id": rawApiKey },
-        body: JSON.stringify({
-          platform: ""
-        })
-      });
-      if (!res.ok) {
-        logger.warn(`[app-name-map] refresh failed: HTTP ${res.status} ${res.statusText}`);
-        return;
-      }
-      const body = await res.json();
-      if (!isAppNameMapApiResponse(body) || !body.success || !body.data?.length) {
-        logger.warn("[app-name-map] refresh failed: unexpected response shape or empty data");
-        return;
-      }
-      map.clear();
-      for (const item of body.data) {
-        if (item.packageName && item.appName) map.set(item.packageName, item.appName);
-      }
-      if (map.size === 0) {
-        logger.warn("[app-name-map] refresh succeeded but got 0 entries");
-        return;
-      }
-      const dir = (0, import_node_path19.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
-      (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
-      const cachePath = getCachePath(stateDir);
-      (0, import_node_fs23.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);
-      logger.warn(`[app-name-map] refresh error: ${message}`);
+      const parsed = JSON.parse((0, import_node_fs23.readFileSync)(filePath, "utf-8"));
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
     }
   }
-  async function ensureOneFetch() {
-    if (inFlightFetch) return inFlightFetch;
-    inFlightFetch = fetchFromServer().finally(() => {
-      inFlightFetch = null;
+  async withDateWriteLock(dateKey, task) {
+    const previous = this.dateWriteChains.get(dateKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
     });
-    return inFlightFetch;
+    const chain = previous.then(() => current);
+    this.dateWriteChains.set(dateKey, chain);
+    await previous;
+    try {
+      return await task();
+    } finally {
+      release();
+      if (this.dateWriteChains.get(dateKey) === chain) {
+        this.dateWriteChains.delete(dateKey);
+      }
+    }
   }
-  return {
-    async resolveDisplayName(packageName) {
-      if (map.has(packageName)) return map.get(packageName);
-      return packageName;
-    },
-    async start() {
-      loadFromDisk();
-      await fetchFromServer();
-      if (!url) return;
-      if (refreshHours > 0) {
-        const ms = refreshHours * 60 * 60 * 1e3;
-        refreshTimer = setInterval(() => fetchFromServer().catch(() => {
-        }), ms);
+  prune() {
+    const retentionDays = this.config.retentionDays;
+    if (retentionDays === void 0) {
+      return;
+    }
+    const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+    const cutoffDate = this.formatDate(new Date(cutoffMs));
+    this.pruneDataFiles(cutoffDate);
+    this.pruneIdIndex(cutoffDate);
+    this.pruneContentKeyIndex(cutoffDate);
+  }
+  /** Remove expired .json, legacy .md files, and legacy date directories */
+  pruneDataFiles(cutoffDate) {
+    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 })) {
+        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 });
+          }
+        } 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 });
+        }
       }
-      stopWatching = watchCredentials(() => fetchFromServer().catch(() => {
-      }));
-    },
-    stop() {
-      stopWatching?.();
-      stopWatching = null;
-      if (refreshTimer) {
-        clearInterval(refreshTimer);
-        refreshTimer = null;
+    } catch {
+    }
+  }
+  /** Remove expired .ids index files */
+  pruneIdIndex(cutoffDate) {
+    try {
+      for (const entry of (0, import_node_fs23.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 });
+          this.idCache.delete(match[1]);
+        }
       }
-      map.clear();
+    } catch {
     }
-  };
-}
+  }
+  pruneContentKeyIndex(cutoffDate) {
+    try {
+      for (const entry of (0, import_node_fs23.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 });
+          this.contentKeyCache.delete(match[1]);
+        }
+      }
+    } catch {
+    }
+  }
+  async close() {
+    this.idCache.clear();
+    this.contentKeyCache.clear();
+    this.dateWriteChains.clear();
+  }
+};
 
 // src/recording/storage.ts
 var import_node_fs24 = require("fs");
@@ -10546,7 +10366,7 @@ var RecordingStorage = class {
     if (entry.transcriptDataFile) {
       const transcriptDoc = this.readRelativeTranscriptDocument(entry.transcriptDataFile);
       const transcriptFromJson = extractTranscriptTextFromDocument(transcriptDoc);
-      if (transcriptFromJson) {
+      if (transcriptFromJson !== void 0) {
         return transcriptFromJson;
       }
     }
@@ -12851,16 +12671,15 @@ function registerNotificationInterfaces(deps) {
     filterNotifications,
     registerGatewayMethod,
     tunnelService,
-    onAfterIngest,
-    getCronForHttpIngest
+    onAfterIngest
   } = deps;
-  function triggerAfterIngest(inserted, cron) {
+  function triggerAfterIngest(inserted) {
     if (inserted.length === 0 || !onAfterIngest) return;
-    void Promise.resolve().then(() => onAfterIngest(inserted, cron)).catch((err2) => logger.warn(`onAfterIngest failed: ${err2?.message ?? err2}`));
+    void Promise.resolve().then(() => onAfterIngest(inserted)).catch((err2) => logger.warn(`onAfterIngest failed: ${err2?.message ?? err2}`));
   }
   registerGatewayMethod(
     "notifications.push",
-    async ({ params, respond, context }) => {
+    async ({ params, respond }) => {
       const storage = getStorage();
       if (!storage) {
         respond(false, null, {
@@ -12880,7 +12699,7 @@ function registerNotificationInterfaces(deps) {
       const filtered = filterNotifications(items);
       const result = filtered.length ? await storage.ingest(filtered) : createEmptyIngestResult();
       respond(true, toIngestResponse(result));
-      triggerAfterIngest(result.inserted, context?.cron);
+      triggerAfterIngest(result.inserted);
     }
   );
   api.registerHttpRoute({
@@ -12924,7 +12743,7 @@ function registerNotificationInterfaces(deps) {
       const result = filtered.length ? await storage.ingest(filtered) : createEmptyIngestResult();
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ ok: true, ...toIngestResponse(result) }));
-      triggerAfterIngest(result.inserted, getCronForHttpIngest?.());
+      triggerAfterIngest(result.inserted);
     }
   });
   logger.info("Gateway \u901A\u77E5\u65B9\u6CD5\u5DF2\u6CE8\u518C: notifications.push");
@@ -13395,7 +13214,6 @@ var index_default = {
     let storage = null;
     let recordingStorage = null;
     let broadcastFn = null;
-    let cronService = null;
     let autoUpdateLifecycle = null;
     let tunnelService = null;
     const openclawDir = api.runtime.state.resolveStateDir();
@@ -13448,9 +13266,6 @@ var index_default = {
     function registerGatewayMethodWithBroadcastCapture(method, handler) {
       api.registerGatewayMethod(method, async (opts) => {
         cacheBroadcast(opts.context?.broadcast);
-        if (opts.context?.cron) {
-          cronService = opts.context.cron;
-        }
         await deactivateRelayForDirectGatewayRequest(method, opts);
         return handler(opts);
       });
@@ -13474,13 +13289,6 @@ var index_default = {
       registry: lightRuleRegistry,
       invoker: lightRuleInvoker
     });
-    const lightRulesEvaluatorJob = new LightRulesEvaluatorJob({
-      logger,
-      registry: lightRuleRegistry,
-      inlineEvaluator: inlineLightRuleEvaluator,
-      subagentRunner: api.runtime.subagent,
-      getNotificationsDir: () => openclawDir ? getStateFallbackNotificationDir(openclawDir) : void 0
-    });
     registerStorageLifecycle({
       api,
       config,
@@ -13510,10 +13318,9 @@ var index_default = {
       filterNotifications,
       registerGatewayMethod: registerGatewayMethodWithBroadcastCapture,
       tunnelService,
-      onAfterIngest: (inserted, cron) => {
-        void lightRulesEvaluatorJob.triggerIfNeeded(cron, inserted);
-      },
-      getCronForHttpIngest: () => cronService
+      onAfterIngest: (inserted) => {
+        void inlineLightRuleEvaluator.evaluate(inserted);
+      }
     });
     registerLightControlTool(api, logger);
     registerRecordingInterfaces({