@yoooclaw/phone-notifications 1.10.7 → 1.11.0-beta.1

package/dist/index.cjs

@@ -52,24 +52,24 @@ function expandUserPath(value) {
     return homeDir();
   }
   if (value.startsWith("~/")) {
-    return (0, import_node_path6.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_path6.join)(home, ".qclaw", "qclaw.json"),
-    (0, import_node_path6.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_fs7.existsSync)(metaPath)) {
+    if (!(0, import_node_fs5.existsSync)(metaPath)) {
       continue;
     }
     try {
-      const parsed = JSON.parse((0, import_node_fs7.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_path6.join)(homeDir(), ".openclaw");
+  const baseDir = (0, import_node_path4.join)(homeDir(), ".openclaw");
   return [
-    (0, import_node_path6.join)(baseDir, "openclaw.json"),
-    (0, import_node_path6.join)(baseDir, "credentials.json"),
-    (0, import_node_path6.join)(baseDir, "extensions")
-  ].some((candidate) => (0, import_node_fs7.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_path6.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_path6.dirname)(meta.configPath);
+    return (0, import_node_path4.dirname)(meta.configPath);
   }
-  return (0, import_node_path6.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_path6.join)(stateDir, "openclaw.json");
+  return (0, import_node_path4.join)(stateDir, "openclaw.json");
 }
 function resolveStateFile(filename) {
-  return (0, import_node_path6.join)(resolveStateDir(), filename);
+  return (0, import_node_path4.join)(resolveStateDir(), filename);
 }
-var import_node_fs7, import_node_path6;
+var import_node_fs5, import_node_path4;
 var init_host = __esm({
   "src/host.ts"() {
     "use strict";
-    import_node_fs7 = require("fs");
-    import_node_path6 = 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_fs8.existsSync)(path2)) return {};
+  if (!(0, import_node_fs6.existsSync)(path2)) return {};
   try {
-    return JSON.parse((0, import_node_fs8.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_fs8.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true, mode: 448 });
-  (0, import_node_fs8.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_path7.dirname)(path2);
-  const filename = (0, import_node_path7.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_fs8.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_fs8, import_node_path7;
+var import_node_fs6, import_node_path5;
 var init_credentials = __esm({
   "src/auth/credentials.ts"() {
     "use strict";
-    import_node_fs8 = require("fs");
-    import_node_path7 = 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_fs9.mkdirSync)((0, import_node_path8.dirname)(path2), { recursive: true });
-  const existing = (0, import_node_fs9.existsSync)(path2) ? (0, import_node_fs9.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_fs9.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_fs9.existsSync)(path2)) return {};
+  if (!(0, import_node_fs7.existsSync)(path2)) return {};
   return Object.fromEntries(
-    (0, import_node_fs9.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_fs9, import_node_path8, 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_fs9 = require("fs");
-    import_node_path8 = 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 = normalizePossiblyEmptyText(params.text) ?? joinSegmentsText(segments) ?? "";
+  const text = normalizeOptionalText(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: normalizePossiblyEmptyText(params.summary),
+      summary: normalizeOptionalText(params.summary),
       text,
       segments
     },
@@ -335,11 +335,11 @@ function parseTranscriptDocument(value) {
 }
 function extractTranscriptTextFromDocument(doc) {
   if (!doc) return void 0;
-  return normalizePossiblyEmptyText(doc.normalized.text) ?? joinSegmentsText(doc.normalized.segments);
+  return normalizeOptionalText(doc.normalized.text) ?? joinSegmentsText(doc.normalized.segments);
 }
 function extractTranscriptSummaryFromDocument(doc) {
   if (!doc) return void 0;
-  return normalizePossiblyEmptyText(doc.normalized.summary);
+  return normalizeOptionalText(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 = normalizePossiblyEmptyText(normalized.text) ?? joinSegmentsText(segments);
-  if (text === void 0) {
+  const text = normalizeOptionalText(normalized.text) ?? joinSegmentsText(segments);
+  if (!text) {
     return void 0;
   }
   return {
     title: normalizeOptionalText(normalized.title),
     category: normalizeOptionalText(normalized.category),
-    summary: normalizePossiblyEmptyText(normalized.summary),
+    summary: normalizeOptionalText(normalized.summary),
     text,
     segments
   };
@@ -465,9 +465,6 @@ 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;
 }
@@ -1345,7 +1342,7 @@ async function runTranscriptionWorkflow(params) {
     return { ok: false, error: result.error };
   }
   const title = normalizeOptionalText2(result.summary) ? normalizeOptionalText2(result.summary) : extractSummary(result.text ?? "");
-  const summary = result.summaryText ?? "";
+  const summary = normalizeOptionalText2(result.summaryText);
   result.summary = title;
   const transcriptData = buildTranscriptDocument({
     recordingId,
@@ -1606,11 +1603,16 @@ 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;
-  const status = normalizeLongRecordingStatus(data?.status) ?? "SUCCEEDED";
+  if (!text) {
+    return {
+      ok: false,
+      error: "Model Proxy ASR \u4EFB\u52A1\u5DF2\u5B8C\u6210\uFF0C\u4F46\u672A\u8FD4\u56DE sourceTextList\u3001sourceText \u6216 summaryResult"
+    };
+  }
   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}`
@@ -1630,7 +1632,7 @@ function buildLongRecordingSuccessResult(taskId, requestId, data, logger) {
       provider: "model-proxy",
       taskId,
       requestId,
-      status
+      status: "SUCCEEDED"
     },
     rawResponse: data
   };
@@ -5422,7 +5424,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.10.7".trim();
+  const version = "1.11.0-beta.1".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -5547,764 +5549,448 @@ 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`
+    );
   }
-  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 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`
+    );
   }
-  throw new Error(`\u901A\u77E5\u5B58\u50A8\u76EE\u5F55\u4E0D\u53EF\u7528: ${stateNotifDir}`);
+  return ts;
 }
-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 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]);
   }
-  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 });
+  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 [];
   }
-  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;
-      }
-    }
-    this.prune();
-    return result;
+}
+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;
   }
-  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 };
-    });
+  if (ctx.workspaceDir) {
+    const dir = (0, import_node_path2.join)(ctx.workspaceDir, "recordings");
+    if ((0, import_node_fs3.existsSync)(dir)) return dir;
   }
-  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
-    };
+  return null;
+}
+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"
+    );
   }
-  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(" ; ") || "-";
+  (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 [];
   }
-  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}`;
+}
+
+// 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" }] };
   }
-  getIdIndexPath(dateKey) {
-    return (0, import_node_path2.join)(this.idIndexDir, `${dateKey}.ids`);
+  if (segments.length === 0) {
+    return { valid: false, errors: [{ field: "segments", message: "\u4E0D\u80FD\u4E3A\u7A7A" }] };
   }
-  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);
-        }
-      }
-    }
-    this.idCache.set(dateKey, ids);
-    return ids;
+  if (segments.length > MAX_SEGMENTS) {
+    return {
+      valid: false,
+      errors: [{ field: "segments", message: `\u6700\u591A ${MAX_SEGMENTS} \u6BB5` }]
+    };
   }
-  hasNotificationId(dateKey, id) {
-    return this.getIdSet(dateKey).has(id);
+  const errors = [];
+  for (let i = 0; i < segments.length; i++) {
+    validateSegment(segments[i], `segments[${i}]`, errors);
   }
-  getContentKeyIndexPath(dateKey) {
-    return (0, import_node_path2.join)(this.contentKeyIndexDir, `${dateKey}.keys`);
+  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");
   }
-  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 (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 });
-    }
-    this.contentKeyCache.set(dateKey, keys);
-    return keys;
+  const result = validateSegments(parsed);
+  if (!result.valid) {
+    output({ ok: false, error: { code: "VALIDATION_FAILED", details: result.errors } });
+    process.exit(1);
   }
-  hasNotificationContentKey(dateKey, filePath, entry) {
-    return this.getContentKeySet(dateKey, filePath).has(
-      this.buildNotificationContentKey(entry)
-    );
+  return result.segments;
+}
+function validateSegment(seg, prefix, errors) {
+  if (!isRecord(seg)) {
+    errors.push({ field: prefix, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+    return;
   }
-  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);
+  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("/")}`
+    });
   }
-  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);
+  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"
+        });
+      }
+      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);
   }
-  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");
+}
+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"
+    });
   }
-  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 [];
-    }
+}
+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;
   }
-  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);
-      }
-    }
+  if (value.length < 1 || value.length > 7) {
+    errors.push({ field, message: "pixels \u5FC5\u987B\u4E3A 1\u20137 \u9879" });
   }
-  prune() {
-    const retentionDays = this.config.retentionDays;
-    if (retentionDays === void 0) {
-      return;
+  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 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 {
+    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);
     }
-  }
-  /** 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"
+    validateNumberInRange(
+      pixel.brightness,
+      `${prefix}.brightness`,
+      errors,
+      0,
+      255,
+      "\u5FC5\u987B\u662F 0\u2013255 \u7684\u6570\u5B57"
     );
+    validateColor(pixel.color, `${prefix}.color`, errors);
   }
 }
-function validateRepeatTimes(value) {
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error("repeat_times \u5FC5\u987B\u662F >=0 \u7684\u6574\u6570");
+function validateOptionalBreathTiming(value, field, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push({ field, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+    return;
   }
-  return value;
+  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"
+  );
 }
-
-// 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 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;
   }
-  return null;
+  validateColor(value, field, errors);
+  validateNumberInRange(
+    value.brightness,
+    `${field}.brightness`,
+    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]);
-  }
-  return keys.sort().reverse();
+function validateOptionalColor(value, field, errors) {
+  if (value === void 0) return;
+  validateColor(value, field, errors);
 }
-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 validateColor(value, field, errors) {
+  if (!isRecord(value)) {
+    errors.push({ field, message: "\u5FC5\u987B\u5305\u542B r/g/b \u6570\u503C" });
+    return;
   }
+  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 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`
-    );
+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" });
   }
-  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 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" });
   }
-  return ts;
 }
-function sortNotificationsByTimestampDesc(items) {
-  return items.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+function validateOptionalNonNegativeNumber(value, field, errors) {
+  if (value === void 0) return;
+  validateNonNegativeNumber(value, field, errors, "\u5FC5\u987B\u662F \u22650 \u7684\u6570\u5B57");
 }
-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 validatePositiveNumber(value, field, errors, message) {
+  if (value === void 0) return;
+  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 validateNonNegativeNumber(value, field, errors, message) {
+  if (!isFiniteNumber(value) || value < 0) {
+    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 exitError(code, message) {
-  output({ ok: false, error: { code, message } });
-  process.exit(1);
-}
-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;
+function validateNumberInRange(value, field, errors, min, max, message) {
+  if (!isFiniteNumber(value) || value < min || value > max) {
+    errors.push({ field, message });
   }
-  return null;
 }
-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");
+function hasNonZeroRgb(value) {
+  if (!value) return false;
+  return [value.r, value.g, value.b].some((channel) => isFiniteNumber(channel) && channel > 0);
 }
-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 [];
-  }
-}
-
-// 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` }]
-    };
-  }
-  const errors = [];
-  for (let i = 0; i < segments.length; i++) {
-    validateSegment(segments[i], `segments[${i}]`, errors);
-  }
-  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");
-  }
-  const result = validateSegments(parsed);
-  if (!result.valid) {
-    output({ ok: false, error: { code: "VALIDATION_FAILED", details: result.errors } });
-    process.exit(1);
-  }
-  return result.segments;
-}
-function validateSegment(seg, prefix, errors) {
-  if (!isRecord(seg)) {
-    errors.push({ field: prefix, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
-    return;
-  }
-  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("/")}`
-    });
-  }
-  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"
-        });
-      }
-      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 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;
-  }
-  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;
-    }
-    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);
-  }
-}
-function validateOptionalBreathTiming(value, field, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push({ field, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
-    return;
-  }
-  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 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;
-  }
-  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" });
-  }
-}
-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 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 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");
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
 
 // src/monitor/fetch-gen.ts
 function generateFetchPy(name, matchRules) {
@@ -6414,14 +6100,14 @@ function legacyReadMetaCronSchedule(meta) {
 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;
+    const inferredWorkspaceDir = (0, import_node_path3.join)(ctx.stateDir, "workspace");
+    if ((0, import_node_fs4.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");
+  return (0, import_node_path3.join)(resolveBaseDir(ctx), "tasks");
 }
 function normalizeLightRuleLookupName(name) {
   return name.trim().replace(/\.json$/i, "");
@@ -6430,7 +6116,7 @@ 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 directTaskDir = (0, import_node_path3.join)(dir, normalizedName);
   const directMeta = readMeta(directTaskDir);
   if (directMeta) {
     return {
@@ -6438,10 +6124,10 @@ function resolveLightRuleTask(ctx, name) {
       meta: directMeta
     };
   }
-  if (!(0, import_node_fs5.existsSync)(dir)) return null;
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
+  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_path4.join)(dir, entry.name);
+    const taskDir = (0, import_node_path3.join)(dir, entry.name);
     const meta = readMeta(taskDir);
     if (meta?.name === normalizedName) {
       return {
@@ -6461,16 +6147,16 @@ 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;
+  const metaPath = (0, import_node_path3.join)(taskDir, "meta.json");
+  if (!(0, import_node_fs4.existsSync)(metaPath)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs5.readFileSync)(metaPath, "utf-8"));
+    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_path4.basename)(taskDir);
+    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_fs5.statSync)(metaPath).birthtime.toISOString();
+    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,
@@ -6492,7 +6178,7 @@ function readMeta(taskDir) {
   }
 }
 function writeMeta(taskDir, meta) {
-  (0, import_node_fs5.writeFileSync)((0, import_node_path4.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  (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);
@@ -6524,22 +6210,22 @@ reason: "${description}"
 }
 function listLightRules(ctx) {
   const dir = tasksDir(ctx);
-  if (!(0, import_node_fs5.existsSync)(dir)) return [];
+  if (!(0, import_node_fs4.existsSync)(dir)) return [];
   const rules = [];
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const meta = readMeta((0, import_node_path4.join)(dir, entry.name));
+    const meta = readMeta((0, import_node_path3.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)) {
+  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`);
   }
-  (0, import_node_fs5.mkdirSync)(taskDir, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(taskDir, { recursive: true });
   const repeatTimes = normalizeRepeatTimes({
     repeat: params.repeat,
     repeat_times: params.repeat_times
@@ -6559,13 +6245,13 @@ function createLightRule(ctx, params) {
   legacyAssignMatchRules(meta, effectiveMatchRules);
   legacyAssignCronSchedule(meta, effectiveCronSchedule);
   writeMeta(taskDir, meta);
-  (0, import_node_fs5.writeFileSync)(
-    (0, import_node_path4.join)(taskDir, "fetch.py"),
+  (0, import_node_fs4.writeFileSync)(
+    (0, import_node_path3.join)(taskDir, "fetch.py"),
     generateFetchPy(params.name, effectiveMatchRules),
     "utf-8"
   );
-  (0, import_node_fs5.writeFileSync)(
-    (0, import_node_path4.join)(taskDir, "README.md"),
+  (0, import_node_fs4.writeFileSync)(
+    (0, import_node_path3.join)(taskDir, "README.md"),
     generateLightRuleReadme(params.name, params.description, params.segments, repeatTimes),
     "utf-8"
   );
@@ -6623,15 +6309,15 @@ function updateLightRule(ctx, params) {
   meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   writeMeta(taskDir, meta);
   if (regenerateFetch) {
-    (0, import_node_fs5.writeFileSync)(
-      (0, import_node_path4.join)(taskDir, "fetch.py"),
+    (0, import_node_fs4.writeFileSync)(
+      (0, import_node_path3.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"),
+    (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"
     );
@@ -6652,7 +6338,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: {
@@ -7409,168 +7095,141 @@ function registerLightRulesTools(api, registry, logger) {
   }, ["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
+// src/light-rules/inline-evaluator.ts
+init_credentials();
 
-\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`;
+// src/light/sender.ts
+var import_node_crypto = require("crypto");
+init_env();
+async function sendLightEffect(apiKey, segments, logger, repeatInput, reason) {
+  const apiUrl = getEnvUrls().lightApiUrl;
+  const appKey = "7Q617S1G5WD274JI";
+  const templateId = "1990771146010017788";
+  logger?.info(
+    `Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "\u2026" : "UNSET"}, templateId=${templateId ?? "UNSET"}, apiKey=${apiKey ? apiKey.substring(0, 20) + "\u2026" : "EMPTY"}, segments=${JSON.stringify(segments)}`
+  );
+  if (!apiUrl || !appKey || !templateId) {
+    return {
+      ok: false,
+      error: "\u706F\u6548 API \u672A\u914D\u7F6E\uFF0C\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF LIGHT_API_URL / LIGHT_APP_KEY / LIGHT_TEMPLATE_ID"
+    };
+  }
+  let bizContent;
+  try {
+    bizContent = buildLightEffectApnsBody(segments, repeatInput);
+  } catch (error) {
+    return { ok: false, error: error?.message ?? String(error) };
+  }
+  const bizUniqueId = (0, import_node_crypto.randomUUID)();
+  const requestBody = {
+    appKey,
+    bizMap: { noticeType: "APP_NOTIFICATION_IMPORTANT", reason },
+    bizUniqueId,
+    paramsMap: { bizContent },
+    pushType: "SPECIFY_PUSH",
+    templateId
+  };
+  logger?.info(
+    `Light sender: POST ${apiUrl}, bizUniqueId=${bizUniqueId}, body=${JSON.stringify(requestBody).substring(0, 500)}`
+  );
+  const res = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Api-Key-Id": apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const resBody = await res.text();
+  if (!res.ok) {
+    logger?.warn(
+      `Light sender: FAILED ${res.status}, url=${apiUrl}, resBody=${resBody.substring(0, 500)}`
+    );
+    return { ok: false, status: res.status, error: resBody };
+  }
+  logger?.info(`Light sender: OK bizUniqueId=${bizUniqueId}, resBody=${resBody.substring(0, 200)}`);
+  return { ok: true, bizUniqueId, response: JSON.parse(resBody) };
 }
-var LightRulesEvaluatorJob = class {
+
+// src/light-rules/inline-evaluator.ts
+var InlineLightRuleEvaluator = class {
   logger;
   registry;
-  subagentRunner;
-  getNotificationsDir;
-  /**
-   * 记录本进程生命周期内 job 是否已确认存在。
-   * 仅在 `ensureJobExists` 成功后置 true，避免每次 push 都做检查。
-   */
-  jobEnsured = false;
-  /**
-   * 首次创建 job 时的并发保护。
-   * 避免冷启动瞬间多条通知并发到达时重复调用 `cron.add`。
-   */
-  ensureJobPromise = null;
-  /**
-   * subagent fallback 路径的并发保护。
-   * 若评估 session 已在运行中，跳过本次触发（checkpoint 保证下次补处理）。
-   */
-  subagentInFlight = false;
+  invoker;
   constructor(deps) {
     this.logger = deps.logger;
     this.registry = deps.registry;
-    this.subagentRunner = deps.subagentRunner;
-    this.getNotificationsDir = deps.getNotificationsDir ?? (() => void 0);
+    this.invoker = deps.invoker;
   }
   /**
-   * 通知落盘后调用。若有新增通知且存在 enabled 规则，则触发评估。
-   *
-   * 两条路径：
-   *  - cron 不为 null：enqueueRun("force") 入队（gateway context 路径，正常路径）
-   *  - cron 为 null：通过 subagentRunner 直接运行（HTTP Relay 路径，fallback）
+   * 评估一批新通知。
    *
-   * @param cron          来自 gateway context 的 CronService；HTTP 路径下为 null
-   * @param insertedCount 本次 ingest 新落盘的通知条数（StoredNotification 去重后）
+   * @returns true 表示评估流程正常结束；false 表示 invoker 失败，调用方可选择回退。
    */
-  async triggerIfNeeded(cron, insertedCount) {
-    if (insertedCount === 0) return;
-    if (this.registry.getEnabled().length === 0) return;
-    if (!cron) {
-      await this.triggerViaSubagent();
-      return;
+  async evaluate(notifications) {
+    if (notifications.length === 0) return true;
+    const rules = this.registry.getEnabled();
+    if (rules.length === 0) return true;
+    const matches = await this.invoker.matchNotifications(notifications, rules);
+    if (matches === null) return false;
+    if (matches.length === 0) {
+      this.logger.info(
+        `lightrules: 0 matches (notifications=${notifications.length}, rules=${rules.length})`
+      );
+      return true;
+    }
+    const firedRules = /* @__PURE__ */ new Set();
+    for (const match of matches) {
+      if (firedRules.has(match.ruleName)) continue;
+      const rule = this.registry.get(match.ruleName);
+      if (!rule) {
+        this.logger.warn(
+          `lightrules: matched rule '${match.ruleName}' not found in registry`
+        );
+        continue;
+      }
+      firedRules.add(match.ruleName);
+      await this.triggerLight(rule);
     }
+    this.logger.info(
+      `lightrules: fired ${firedRules.size} rule(s): ${[...firedRules].join(", ")} (from ${matches.length} match(es) across ${notifications.length} notification(s))`
+    );
+    return true;
+  }
+  async triggerLight(rule) {
+    let apiKey;
     try {
-      await this.ensureJobExists(cron);
+      apiKey = requireApiKey();
     } catch (err2) {
-      this.logger.warn(`light-rules-evaluator: job ensure failed: ${err2?.message ?? err2}`);
+      this.logger.warn(
+        `lightrules: trigger '${rule.name}' skipped - no API key: ${err2?.message ?? err2}`
+      );
       return;
     }
     try {
-      const result = await cron.enqueueRun(EVALUATOR_JOB_ID, "force");
+      const result = await sendLightEffect(
+        apiKey,
+        rule.segments,
+        this.logger,
+        { repeat_times: rule.repeat_times },
+        rule.description
+      );
       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})`);
+        this.logger.warn(
+          `lightrules: trigger '${rule.name}' http-failed (${result.status ?? "?"}): ${result.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"
+        `lightrules: trigger '${rule.name}' exception: ${err2?.message ?? err2}`
       );
-      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;
-      }
-    }
-    this.jobEnsured = true;
-  }
 };
 
 // src/light-rules/migration.ts
-var import_node_fs6 = require("fs");
-var import_node_path5 = 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
@@ -7580,32 +7239,32 @@ function normalizeScriptText(text) {
   return text.replace(/\r\n/g, "\n").trim();
 }
 function resolveTasksDir(ctx) {
-  if (ctx.workspaceDir) return (0, import_node_path5.join)(ctx.workspaceDir, "tasks");
+  if (ctx.workspaceDir) return (0, import_node_path7.join)(ctx.workspaceDir, "tasks");
   if (ctx.stateDir) {
-    const inferredWorkspaceDir = (0, import_node_path5.join)(ctx.stateDir, "workspace");
-    if ((0, import_node_fs6.existsSync)(inferredWorkspaceDir)) return (0, import_node_path5.join)(inferredWorkspaceDir, "tasks");
-    return (0, import_node_path5.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_fs6.existsSync)(tasksDir3)) return;
+  if (!tasksDir3 || !(0, import_node_fs8.existsSync)(tasksDir3)) return;
   try {
-    for (const entry of (0, import_node_fs6.readdirSync)(tasksDir3, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs8.readdirSync)(tasksDir3, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      migrateTaskDir((0, import_node_path5.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_path5.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs6.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_fs6.readFileSync)(metaPath, "utf-8"));
+    meta = JSON.parse((0, import_node_fs8.readFileSync)(metaPath, "utf-8"));
   } catch {
     return;
   }
@@ -7614,7 +7273,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_path5.join)(taskDir, filename), name, filename, logger);
+    removeFile((0, import_node_path7.join)(taskDir, filename), name, filename, logger);
   }
 }
 function mergeMatchRulesIntoDescription(meta, name, metaPath, logger) {
@@ -7635,36 +7294,185 @@ function mergeMatchRulesIntoDescription(meta, name, metaPath, logger) {
   }
   delete meta.matchRules;
   try {
-    (0, import_node_fs6.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_path5.join)(taskDir, "fetch.py");
-  if (!(0, import_node_fs6.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_fs6.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_fs6.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_fs6.existsSync)(filePath)) return;
+  if (!(0, import_node_fs8.existsSync)(filePath)) return;
   try {
-    (0, import_node_fs6.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}`);
   }
 }
 
+// src/light-rules/pi-invoker.ts
+var import_agent_runtime = require("openclaw/plugin-sdk/agent-runtime");
+var DEFAULT_PROVIDER = "anthropic";
+var DEFAULT_MODEL_ID = "claude-haiku-4-5-20251001";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_OUTPUT_TOKENS = 512;
+var PiAiInvoker = class {
+  constructor(api, logger, options = {}) {
+    this.api = api;
+    this.logger = logger;
+    this.options = options;
+  }
+  /**
+   * 对一批通知和当前启用的规则做一次 LLM 匹配。
+   *
+   * 返回：
+   *  - `LlmMatchResult[]`：匹配成功（可能为空数组，即 0 命中）
+   *  - `null`：调用失败（模型准备失败 / 网络 / 解析）。调用方据此决定是否回退。
+   */
+  async matchNotifications(notifications, rules) {
+    if (notifications.length === 0 || rules.length === 0) return [];
+    const provider = this.options.provider ?? DEFAULT_PROVIDER;
+    const modelId = this.options.modelId ?? DEFAULT_MODEL_ID;
+    const prepared = await (0, import_agent_runtime.prepareSimpleCompletionModel)({
+      cfg: this.api.config,
+      provider,
+      modelId
+    });
+    if ("error" in prepared) {
+      this.logger.warn(
+        `PiAiInvoker: prepare ${provider}/${modelId} failed: ${prepared.error}`
+      );
+      return null;
+    }
+    const systemPrompt = buildSystemPrompt(rules);
+    const userMessage = buildUserMessage(notifications);
+    try {
+      const resp = await (0, import_agent_runtime.completeWithPreparedSimpleCompletionModel)({
+        model: prepared.model,
+        auth: prepared.auth,
+        context: {
+          systemPrompt,
+          messages: [
+            { role: "user", content: userMessage, timestamp: Date.now() }
+          ]
+        },
+        options: {
+          temperature: 0,
+          maxTokens: MAX_OUTPUT_TOKENS,
+          signal: AbortSignal.timeout(this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+          cacheRetention: "short"
+        }
+      });
+      if (resp.stopReason === "error" || resp.stopReason === "aborted") {
+        this.logger.warn(
+          `PiAiInvoker: complete stopped with ${resp.stopReason}: ${resp.errorMessage ?? "n/a"}`
+        );
+        return null;
+      }
+      const text = extractText(resp.content);
+      return parseMatchResult(text, notifications.length, rules);
+    } catch (err2) {
+      this.logger.warn(`PiAiInvoker: complete failed: ${err2?.message ?? err2}`);
+      return null;
+    }
+  }
+};
+function extractText(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const c of content) {
+    if (c && typeof c === "object" && c.type === "text") {
+      const t = c.text;
+      if (typeof t === "string") parts.push(t);
+    }
+  }
+  return parts.join("");
+}
+function buildSystemPrompt(rules) {
+  const lines = [
+    '\u4F60\u662F"\u624B\u673A\u901A\u77E5 \u2192 \u706F\u6548\u89C4\u5219"\u547D\u4E2D\u5339\u914D\u52A9\u624B\u3002',
+    "",
+    "\u5F53\u524D\u542F\u7528\u7684\u706F\u6548\u89C4\u5219\uFF08\u6309\u521B\u5EFA\u65F6\u95F4\u5012\u5E8F\uFF09\uFF1A",
+    ""
+  ];
+  const sorted = [...rules].sort(
+    (a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? "")
+  );
+  sorted.forEach((rule, idx) => {
+    lines.push(`[${idx + 1}] name: ${rule.name}`);
+    lines.push(`    description: ${rule.description}`);
+    lines.push("");
+  });
+  lines.push(
+    "\u4EFB\u52A1\uFF1A\u5BF9\u7528\u6237\u63A5\u4E0B\u6765\u53D1\u6765\u7684\u6BCF\u6761\u901A\u77E5\uFF0C\u5224\u65AD\u5B83\u547D\u4E2D\u4E86\u54EA\u4E9B\u89C4\u5219\u3002",
+    "",
+    "\u8F93\u51FA\u5FC5\u987B\u662F\u7EAF JSON\uFF08\u4E0D\u8981 Markdown \u4EE3\u7801\u5757\u3001\u4E0D\u8981\u4EFB\u4F55\u89E3\u91CA\u6587\u5B57\uFF09\uFF1A",
+    '{"matches":[{"i":<\u901A\u77E5\u4E0B\u6807>,"rule":"<\u89C4\u5219name>"}]}',
+    "",
+    '- \u547D\u4E2D 0 \u6761 \u2192 \u8F93\u51FA {"matches":[]}',
+    "- \u4E00\u6761\u901A\u77E5\u53EF\u80FD\u547D\u4E2D\u591A\u6761\u89C4\u5219 \u2192 \u6BCF\u4E2A\u7EC4\u5408\u4E00\u4E2A\u6761\u76EE",
+    '- \u4E25\u683C\u6309\u89C4\u5219 description \u5224\u65AD\uFF0C\u62FF\u4E0D\u51C6\u65F6\u503E\u5411\u4E8E"\u4E0D\u89E6\u53D1"',
+    "- rule \u5FC5\u987B\u7CBE\u786E\u7B49\u4E8E\u4E0A\u9762\u5217\u51FA\u7684 name \u5B57\u7B26\u4E32"
+  );
+  return lines.join("\n");
+}
+function buildUserMessage(notifications) {
+  const lines = [
+    `\u4EE5\u4E0B ${notifications.length} \u6761\u65B0\u624B\u673A\u901A\u77E5\uFF0C\u6309\u987A\u5E8F\u7F16\u53F7\uFF1A`,
+    ""
+  ];
+  notifications.forEach((n, i) => {
+    const app = n.appDisplayName ?? n.appName;
+    lines.push(
+      `[${i}] app=${app} time=${n.timestamp}`,
+      `    title: ${n.title}`,
+      `    content: ${n.content}`,
+      ""
+    );
+  });
+  lines.push("\u8BF7\u5224\u65AD\u6BCF\u6761\u901A\u77E5\u547D\u4E2D\u4E86\u54EA\u4E9B\u89C4\u5219\uFF0C\u6309\u7EA6\u5B9A\u683C\u5F0F\u8F93\u51FA JSON\u3002");
+  return lines.join("\n");
+}
+function parseMatchResult(rawText, notificationCount, rules) {
+  if (!rawText) return [];
+  const text = rawText.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object") return [];
+  const raw = parsed.matches;
+  if (!Array.isArray(raw)) return [];
+  const validRuleNames = new Set(rules.map((r) => r.name));
+  const results = [];
+  for (const m of raw) {
+    if (!m || typeof m !== "object") continue;
+    const entry = m;
+    const i = typeof entry.i === "number" ? entry.i : typeof entry.index === "number" ? entry.index : -1;
+    const ruleName = typeof entry.rule === "string" ? entry.rule : null;
+    if (!Number.isInteger(i) || i < 0 || i >= notificationCount) continue;
+    if (!ruleName || !validRuleNames.has(ruleName)) continue;
+    results.push({ notificationIndex: i, ruleName });
+  }
+  return results;
+}
+
 // src/plugin/auto-update.ts
 init_env();
 
@@ -7680,7 +7488,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) {
@@ -7782,8 +7590,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";
@@ -7793,9 +7601,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...");
@@ -7804,9 +7612,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 }
@@ -7815,14 +7623,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) {
@@ -7830,7 +7638,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 {
       }
     }
@@ -7840,8 +7648,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)}`);
@@ -7852,7 +7660,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 {
     }
   }
@@ -7867,7 +7675,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;
@@ -8055,10 +7863,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");
@@ -8094,12 +7902,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);
       }
@@ -8231,23 +8039,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");
@@ -8340,24 +8148,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}
@@ -8376,27 +8184,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 {
       }
     }
@@ -8411,8 +8219,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;
@@ -8424,7 +8232,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,
@@ -8434,13 +8242,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"
       );
@@ -8468,8 +8276,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) {
@@ -8482,7 +8290,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,
@@ -8494,7 +8302,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;
@@ -8502,7 +8310,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;
@@ -8513,61 +8321,6 @@ function registerNtfMonitor(ntf, ctx) {
 
 // src/cli/light-send.ts
 init_credentials();
-
-// src/light/sender.ts
-var import_node_crypto2 = require("crypto");
-init_env();
-async function sendLightEffect(apiKey, segments, logger, repeatInput, reason) {
-  const apiUrl = getEnvUrls().lightApiUrl;
-  const appKey = "7Q617S1G5WD274JI";
-  const templateId = "1990771146010017788";
-  logger?.info(
-    `Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "\u2026" : "UNSET"}, templateId=${templateId ?? "UNSET"}, apiKey=${apiKey ? apiKey.substring(0, 20) + "\u2026" : "EMPTY"}, segments=${JSON.stringify(segments)}`
-  );
-  if (!apiUrl || !appKey || !templateId) {
-    return {
-      ok: false,
-      error: "\u706F\u6548 API \u672A\u914D\u7F6E\uFF0C\u8BF7\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF LIGHT_API_URL / LIGHT_APP_KEY / LIGHT_TEMPLATE_ID"
-    };
-  }
-  let bizContent;
-  try {
-    bizContent = buildLightEffectApnsBody(segments, repeatInput);
-  } catch (error) {
-    return { ok: false, error: error?.message ?? String(error) };
-  }
-  const bizUniqueId = (0, import_node_crypto2.randomUUID)();
-  const requestBody = {
-    appKey,
-    bizMap: { noticeType: "APP_NOTIFICATION_IMPORTANT", reason },
-    bizUniqueId,
-    paramsMap: { bizContent },
-    pushType: "SPECIFY_PUSH",
-    templateId
-  };
-  logger?.info(
-    `Light sender: POST ${apiUrl}, bizUniqueId=${bizUniqueId}, body=${JSON.stringify(requestBody).substring(0, 500)}`
-  );
-  const res = await fetch(apiUrl, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Api-Key-Id": apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey
-    },
-    body: JSON.stringify(requestBody)
-  });
-  const resBody = await res.text();
-  if (!res.ok) {
-    logger?.warn(
-      `Light sender: FAILED ${res.status}, url=${apiUrl}, resBody=${resBody.substring(0, 500)}`
-    );
-    return { ok: false, status: res.status, error: resBody };
-  }
-  logger?.info(`Light sender: OK bizUniqueId=${bizUniqueId}, resBody=${resBody.substring(0, 200)}`);
-  return { ok: true, bizUniqueId, response: JSON.parse(resBody) };
-}
-
-// src/cli/light-send.ts
 function registerLightSend(light) {
   light.command("send").description("\u53D1\u9001\u706F\u6548\u6307\u4EE4\u5230\u786C\u4EF6\u8BBE\u5907").requiredOption("--segments <json>", "\u706F\u6548\u53C2\u6570 JSON").option("--repeat", "\u65E0\u9650\u5FAA\u73AF\u64AD\u653E\uFF08\u9ED8\u8BA4\u4EC5\u64AD\u653E\u4E00\u8F6E\uFF09").option("--repeat-times <n>", "\u6574\u6761\u7EC4\u5408\u91CD\u590D\u6B21\u6570\uFF1A0=\u65E0\u9650\uFF0C1=\u4E00\u8F6E\uFF1B\u5F53\u524D ANCS \u8DEF\u5F84\u4E0D\u652F\u6301 >=2").action(async (opts) => {
     let apiKey;
@@ -8601,9 +8354,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);
 }
@@ -8617,7 +8370,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",
@@ -8664,12 +8417,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) {
@@ -8677,8 +8430,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)}`);
     }
@@ -8696,17 +8449,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;
   }
@@ -8774,24 +8527,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]);
@@ -8799,9 +8552,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;
@@ -8868,12 +8621,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);
 }
@@ -8890,13 +8643,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");
     }
   };
 };
@@ -8944,11 +8697,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;
   }
@@ -8962,7 +8715,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);
     }
   };
 };
@@ -9017,16 +8770,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",
@@ -9038,7 +8791,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",
@@ -9131,9 +8884,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 {};
@@ -9334,7 +9087,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));
 }
@@ -9420,9 +9173,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");
@@ -9435,7 +9188,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}
 
@@ -9449,8 +9202,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";
@@ -9509,9 +9262,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) {
@@ -9529,7 +9282,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) {
@@ -9593,10 +9346,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;
@@ -9818,159 +9571,475 @@ function registerLightControlTool(api, logger) {
           }
         };
       }
-      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}`);
+      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(() => {
+      }));
+    },
+    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 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;
+      }
+    }
+    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" };
+      }
+      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);
+        }
+      }
+    }
+    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");
@@ -10294,7 +10363,7 @@ var RecordingStorage = class {
     if (entry.transcriptDataFile) {
       const transcriptDoc = this.readRelativeTranscriptDocument(entry.transcriptDataFile);
       const transcriptFromJson = extractTranscriptTextFromDocument(transcriptDoc);
-      if (transcriptFromJson !== void 0) {
+      if (transcriptFromJson) {
         return transcriptFromJson;
       }
     }
@@ -10588,11 +10657,11 @@ var import_node_fs25 = require("fs");
 var import_node_path21 = require("path");
 var import_promises2 = require("stream/promises");
 var import_node_stream = require("stream");
-var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_BACKOFF_MS = 2e3;
 async function downloadFile(url, destPath, logger, options) {
-  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
   const retryBackoffMs = options?.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
   (0, import_node_fs25.mkdirSync)((0, import_node_path21.dirname)(destPath), { recursive: true });
@@ -10877,7 +10946,7 @@ var import_node_path24 = require("path");
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
 var import_receiver = __toESM(require_receiver(), 1);
-var import_sender3 = __toESM(require_sender(), 1);
+var import_sender4 = __toESM(require_sender(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
@@ -12599,16 +12668,15 @@ function registerNotificationInterfaces(deps) {
     filterNotifications,
     registerGatewayMethod,
     tunnelService,
-    onAfterIngest,
-    getCronForHttpIngest
+    onAfterIngest
   } = deps;
-  function triggerAfterIngest(insertedCount, cron) {
-    if (insertedCount <= 0 || !onAfterIngest) return;
-    void Promise.resolve().then(() => onAfterIngest(insertedCount, cron)).catch((err2) => logger.warn(`onAfterIngest failed: ${err2?.message ?? err2}`));
+  function triggerAfterIngest(inserted) {
+    if (inserted.length === 0 || !onAfterIngest) return;
+    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, {
@@ -12628,7 +12696,7 @@ function registerNotificationInterfaces(deps) {
       const filtered = filterNotifications(items);
       const result = filtered.length ? await storage.ingest(filtered) : createEmptyIngestResult();
       respond(true, toIngestResponse(result));
-      triggerAfterIngest(result.inserted.length, context?.cron);
+      triggerAfterIngest(result.inserted);
     }
   );
   api.registerHttpRoute({
@@ -12672,7 +12740,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.length, getCronForHttpIngest?.());
+      triggerAfterIngest(result.inserted);
     }
   });
   logger.info("Gateway \u901A\u77E5\u65B9\u6CD5\u5DF2\u6CE8\u518C: notifications.push");
@@ -13143,7 +13211,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();
@@ -13196,9 +13263,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);
       });
@@ -13216,11 +13280,11 @@ var index_default = {
       broadcastFn("recording.status", event);
     }
     const lightRuleRegistry = new LightRuleRegistry(lightRuleCtx);
-    const lightRulesEvaluatorJob = new LightRulesEvaluatorJob({
+    const lightRuleInvoker = new PiAiInvoker(api, logger);
+    const inlineLightRuleEvaluator = new InlineLightRuleEvaluator({
       logger,
       registry: lightRuleRegistry,
-      subagentRunner: api.runtime.subagent,
-      getNotificationsDir: () => openclawDir ? getStateFallbackNotificationDir(openclawDir) : void 0
+      invoker: lightRuleInvoker
     });
     registerStorageLifecycle({
       api,
@@ -13251,10 +13315,9 @@ var index_default = {
       filterNotifications,
       registerGatewayMethod: registerGatewayMethodWithBroadcastCapture,
       tunnelService,
-      onAfterIngest: (insertedCount, cron) => {
-        void lightRulesEvaluatorJob.triggerIfNeeded(cron, insertedCount);
-      },
-      getCronForHttpIngest: () => cronService
+      onAfterIngest: (inserted) => {
+        void inlineLightRuleEvaluator.evaluate(inserted);
+      }
     });
     registerLightControlTool(api, logger);
     registerRecordingInterfaces({