修改了通知相关的功能，能够正常通知了。

entry/src/main/ets/common/AppSettings.ets

@@ -14,6 +14,7 @@ export class AppSettings {
   private static readonly KEY_BACKUP_KEY: string = 'sys_backup_cal_key'; // 备份目标 DAV 日历本
   private static readonly KEY_MANUAL_READONLY: string = 'manual_readonly_keys'; // 手动标记只读的 calKey
   private static readonly KEY_MUTED_REMINDER: string = 'muted_reminder_keys';  // 提醒静音的 calKey
+  private static readonly KEY_REMINDER_TICK: string = 'reminder_tick';         // 应用内提醒上次检查时间戳
   private static readonly KEY_FULL_REFETCH: string = 'full_refetch_done'; // 一次性全量重拉已完成
 
   /**
@@ -114,6 +115,29 @@ export class AppSettings {
     }
   }
 
+  /** 应用内提醒模式的上次检查时间戳（毫秒，0 = 未初始化） */
+  static async getReminderTick(context: common.Context): Promise<number> {
+    try {
+      const store: preferences.Preferences =
+        await preferences.getPreferences(context, AppSettings.STORE);
+      return await store.get(AppSettings.KEY_REMINDER_TICK, 0) as number;
+    } catch (err) {
+      return 0;
+    }
+  }
+
+  static async setReminderTick(context: common.Context, tick: number): Promise<void> {
+    try {
+      const store: preferences.Preferences =
+        await preferences.getPreferences(context, AppSettings.STORE);
+      await store.put(AppSettings.KEY_REMINDER_TICK, tick);
+      await store.flush();
+    } catch (err) {
+      const e = err as BusinessError;
+      console.error(`保存提醒检查时间戳失败: ${e.message}`);
+    }
+  }
+
   /** 系统日历模式：display = 仅混合显示；backup = 本地系统日程备份到选定 CalDAV 日历本 */
   static async getSysCalMode(context: common.Context): Promise<string> {
     try {

entry/src/main/ets/common/EventDb.ets

@@ -25,7 +25,8 @@ export class LocalEvent {
   completed: boolean = false; // 待办是否已完成（STATUS:COMPLETED）
   rrule: string = '';       // 原始 RRULE（空 = 非重复）；显示时按规则展开多次发生
   exdate: string = '';      // 原始 EXDATE 排除日期，分号分隔
-  reminder: number = 0;     // 提醒提前分钟数（来自 VALARM，0 = 不提醒）
+  reminder: number = 0;     // 主提醒提前分钟数（第一个提醒，兼容旧字段），0 = 不提醒
+  reminders: number[] = []; // 全部提醒提前分钟数（多选），按添加顺序
 }
 
 /** 远端事件条目（REPORT 解析结果） */
@@ -43,7 +44,8 @@ export class RemoteEvent {
   completed: boolean = false; // VTODO STATUS:COMPLETED
   rrule: string = '';         // 原始 RRULE
   exdate: string = '';        // 原始 EXDATE（分号分隔）
-  reminder: number = 0;       // 提醒提前分钟数（VALARM）
+  reminder: number = 0;       // 主提醒提前分钟数（第一个提醒，兼容旧字段）
+  reminders: number[] = [];   // 全部提醒提前分钟数（多选）
 }
 
 export class EventDb {
@@ -97,10 +99,31 @@ export class EventDb {
     } catch (err) {
       // 列已存在
     }
+    try {
+      await store.executeSql("ALTER TABLE events ADD COLUMN reminders TEXT DEFAULT ''");
+    } catch (err) {
+      // 列已存在
+    }
     EventDb.db = store;
     return store;
   }
 
+  /** 提醒数组规范化：去掉 0/非法值并去重升序 */
+  static normalizeReminders(list: number[]): number[] {
+    const set = new Set<number>();
+    for (const n of list) {
+      if (n > 0) {
+        set.add(n);
+      }
+    }
+    return Array.from(set).sort((a: number, b: number): number => a - b);
+  }
+
+  /** 提醒数组比较键（规范化后逗号连接，用于增量比对） */
+  static remKey(list: number[]): string {
+    return EventDb.normalizeReminders(list).join(',');
+  }
+
   private static fromRow(rs: relationalStore.ResultSet): LocalEvent {
     const e = new LocalEvent();
     e.id = rs.getLong(rs.getColumnIndex('id'));
@@ -124,6 +147,14 @@ export class EventDb {
     e.rrule = rs.getString(rs.getColumnIndex('rrule'));
     e.exdate = rs.getString(rs.getColumnIndex('exdate'));
     e.reminder = rs.getLong(rs.getColumnIndex('reminder'));
+    // 多提醒（逗号分隔分钟数）；旧数据无该列时回退单提醒
+    const remStr: string = rs.getString(rs.getColumnIndex('reminders'));
+    if (remStr !== '') {
+      e.reminders = remStr.split(',').map((s: string): number => Number(s))
+        .filter((n: number): boolean => !Number.isNaN(n) && n > 0);
+    } else if (e.reminder > 0) {
+      e.reminders = [e.reminder];
+    }
     return e;
   }
 
@@ -147,7 +178,8 @@ export class EventDb {
       'completed': e.completed ? 1 : 0,
       'rrule': e.rrule,
       'exdate': e.exdate,
-      'reminder': e.reminder
+      'reminder': e.reminders.length > 0 ? e.reminders[0] : 0,
+      'reminders': e.reminders.map((n: number): string => String(n)).join(',')
     };
     return bucket;
   }
@@ -365,10 +397,12 @@ export class EventDb {
         e.rrule = r.rrule;
         e.exdate = r.exdate;
         e.reminder = r.reminder;
+        e.reminders = r.reminders;
         await store.insert('events', EventDb.toBucket(e));
         added++;
       } else if (found.etag !== r.etag || found.rrule !== r.rrule || found.exdate !== r.exdate
-        || found.reminder !== r.reminder || found.recurring !== r.recurring) {
+        || found.reminder !== r.reminder || found.recurring !== r.recurring
+        || EventDb.remKey(found.reminders) !== EventDb.remKey(r.reminders)) {
         // 更新（rrule/exdate/recurring 变化也更新，兼容老数据回填）
         found.title = r.title;
         found.description = r.description;
@@ -385,6 +419,7 @@ export class EventDb {
         found.rrule = r.rrule;
         found.exdate = r.exdate;
         found.reminder = r.reminder;
+        found.reminders = r.reminders;
         const up = new relationalStore.RdbPredicates('events');
         up.equalTo('id', found.id);
         await store.update(EventDb.toBucket(found), up);

entry/src/main/ets/common/IcsUtil.ets

@@ -16,7 +16,8 @@ class ParsedEvent {
   inAlarm: boolean = false; // 是否处于 VALARM 子组件内（内部属性不参与解析）
   rrule: string = '';       // 原始 RRULE 值
   exdates: string[] = [];   // 原始 EXDATE 值列表
-  reminder: number = 0;     // 提醒提前分钟数（来自 VALARM TRIGGER，0 = 不提醒）
+  reminder: number = 0;     // 主提醒提前分钟数（第一个 VALARM，0 = 不提醒）
+  reminders: number[] = []; // 全部提醒提前分钟数（多 VALARM）
 }
 
 /** iCal 时间解析结果 */
@@ -71,7 +72,13 @@ export class IcsUtil {
           const av: string = line.substring(ac + 1).trim();
           const an: string = ap.split(';')[0].toUpperCase();
           if (an === 'TRIGGER') {
-            current.reminder = IcsUtil.triggerMinutes(av, ap);
+            const m: number = IcsUtil.triggerMinutes(av, ap);
+            if (m > 0) {
+              current.reminders.push(m);
+              if (current.reminder === 0) {
+                current.reminder = m; // 第一个提醒作为主提醒（兼容旧字段）
+              }
+            }
           }
         }
         continue;
@@ -134,6 +141,7 @@ export class IcsUtil {
       r.rrule = p.rrule;
       r.exdate = p.exdates.join(';');
       r.reminder = p.reminder;
+      r.reminders = p.reminders;
       return r;
     });
   }
@@ -244,11 +252,23 @@ export class IcsUtil {
       `SUMMARY:${IcsUtil.escape(e.title)}\r\n` +
       (e.location !== '' ? `LOCATION:${IcsUtil.escape(e.location)}\r\n` : '') +
       (e.description !== '' ? `DESCRIPTION:${IcsUtil.escape(e.description)}\r\n` : '') +
-      (e.reminder > 0 ? IcsUtil.valarm(e.reminder) : '') +
+      IcsUtil.valarms(e.reminders.length > 0 ? e.reminders
+        : (e.reminder > 0 ? [e.reminder] : [])) +
       'END:VEVENT\r\n' +
       'END:VCALENDAR\r\n';
   }
 
+  /** 由提醒分钟数组生成多个 VALARM（已规范化去重） */
+  private static valarms(minutes: number[]): string {
+    let out: string = '';
+    for (const m of minutes) {
+      if (m > 0) {
+        out += IcsUtil.valarm(m);
+      }
+    }
+    return out;
+  }
+
   /** 由提前分钟数生成 VALARM（TRIGGER 负时长 = 提前触发） */
   private static valarm(minutes: number): string {
     let trigger: string;

entry/src/main/ets/common/LogUtil.ets

@@ -1,25 +1,107 @@
 // entry/src/main/ets/common/LogUtil.ets
-// 日志功能已按需求移除：保留空实现以兼容既有调用点（不写文件、不再缓冲）
+// 同步日志：写入应用 filesDir/sync.log（含时间戳），超 512KB 自动截断保留后半。
+// 设置页「同步日志」卡片可查看/复制/清空，方便真机测试时诊断同步与提醒问题。
 import { common } from '@kit.AbilityKit';
+import { fileIo as fs } from '@kit.CoreFileKit';
+import { util } from '@kit.ArkTS';
+import { BusinessError } from '@kit.BasicServicesKit';
 
 export class LogUtil {
-  static logFilePath(): string {
-    return '';
-  }
+  private static path: string = '';
+  private static readonly MAX_BYTES: number = 512 * 1024;
 
-  /** 空实现（日志功能已移除） */
   static init(context: common.Context): void {
+    try {
+      LogUtil.path = `${context.filesDir}/sync.log`;
+    } catch (err) {
+      LogUtil.path = '';
+    }
   }
 
-  /** 仅输出到 console（hilog），不再写文件 */
+  static logFilePath(): string {
+    return LogUtil.path;
+  }
+
+  /** 写一行日志：console + 文件（文件失败静默，不影响业务） */
   static write(msg: string): void {
     console.info(`SyncLog ${msg}`);
+    if (LogUtil.path === '') {
+      return;
+    }
+    try {
+      const d = new Date();
+      const p = (n: number): string => n < 10 ? '0' + n : String(n);
+      const ts: string = `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}` +
+        ` ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+      // 超限截断：保留最后 256KB
+      try {
+        const st: fs.Stat = fs.statSync(LogUtil.path);
+        if (st.size > LogUtil.MAX_BYTES) {
+          LogUtil.truncate();
+        }
+      } catch (err) {
+        // 文件不存在属正常，直接创建写入
+      }
+      const file: fs.File = fs.openSync(LogUtil.path,
+        fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.APPEND);
+      fs.writeSync(file.fd, `[${ts}] ${msg}\n`);
+      fs.closeSync(file.fd);
+    } catch (err) {
+      // 写日志失败不影响业务
+    }
+  }
+
+  /** 截断：只保留文件末尾 256KB */
+  private static truncate(): void {
+    try {
+      const keep: number = 256 * 1024;
+      const st: fs.Stat = fs.statSync(LogUtil.path);
+      const size: number = Math.min(st.size, keep);
+      const file = fs.openSync(LogUtil.path, fs.OpenMode.READ_ONLY);
+      const buf: ArrayBuffer = new ArrayBuffer(size);
+      fs.readSync(file.fd, buf, { offset: st.size - size });
+      fs.closeSync(file.fd);
+      const out = fs.openSync(LogUtil.path,
+        fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC);
+      fs.writeSync(out.fd, `…（日志过长，已截断保留末尾）\n`);
+      fs.writeSync(out.fd, new Uint8Array(buf));
+      fs.closeSync(out.fd);
+    } catch (err) {
+      // 截断失败忽略，下次再试
+    }
   }
 
   static readAll(context: common.Context): string {
-    return '(日志功能已移除)';
+    try {
+      if (LogUtil.path === '') {
+        LogUtil.init(context);
+      }
+      if (LogUtil.path === '') {
+        return '(无法确定日志路径)';
+      }
+      const st: fs.Stat = fs.statSync(LogUtil.path);
+      if (st.size === 0) {
+        return '(日志为空)';
+      }
+      const file = fs.openSync(LogUtil.path, fs.OpenMode.READ_ONLY);
+      const buf: ArrayBuffer = new ArrayBuffer(st.size);
+      fs.readSync(file.fd, buf);
+      fs.closeSync(file.fd);
+      const decoder: util.TextDecoder = util.TextDecoder.create('utf-8');
+      return decoder.decodeToString(new Uint8Array(buf));
+    } catch (err) {
+      return `(读取日志失败: ${(err as BusinessError).message})`;
+    }
   }
 
   static clear(context: common.Context): void {
+    try {
+      if (LogUtil.path === '') {
+        LogUtil.init(context);
+      }
+      fs.unlinkSync(LogUtil.path);
+    } catch (err) {
+      // 文件不存在等，忽略
+    }
   }
 }

entry/src/main/ets/common/ReminderService.ets

@@ -1,27 +1,136 @@
 // entry/src/main/ets/common/ReminderService.ets
-// 日程提醒：基于后台代理提醒（reminderAgentManager），
-// 在日程开始前 N 分钟（来自服务器 VALARM TRIGGER）发系统通知，可右滑删除
+// 日程提醒，双模式：
+// 1) 系统代理提醒（reminderAgentManager）：需要华为审批的"代理提醒使用权限"，
+//    未申请的普通应用配额为 0（发布报 1700002 且池内为 0）
+// 2) 应用内通知（notificationManager）：配额为 0 时的降级方案。
+//    依赖应用进程存活（前台或"后台持续同步"长时任务），由自动同步定时器驱动，
+//    每次检查把"提醒时刻刚好已到"的日程用本地通知发出。
 import { reminderAgentManager } from '@kit.BackgroundTasksKit';
+import { notificationManager } from '@kit.NotificationKit';
 import { common } from '@kit.AbilityKit';
 import { BusinessError } from '@kit.BasicServicesKit';
 import { EventDb, LocalEvent } from './EventDb';
 import { AppSettings } from './AppSettings';
+import { AccountStore } from './AccountStore';
 import { LogUtil } from './LogUtil';
 
 export class ReminderService {
-  private static readonly MAX_REMINDERS: number = 30; // 系统对单应用代理提醒数量有限制
+  // 系统对单应用代理提醒上限 30 条，留 5 个余量给测试提醒等临时请求
+  private static readonly MAX_REMINDERS: number = 25;
   private static readonly WINDOW: number = 7 * 86400000; // 只排未来 7 天
 
-  /** 全量重建提醒：先取消本应用全部代理提醒，再按当前数据重新发布 */
-  static async refreshReminders(context: common.Context): Promise<void> {
+  /** 代理提醒可用性：null=未探测（每次进程启动重新探测），false=配额为0（走应用内通知），true=可用 */
+  static agentAvailable: boolean | null = null;
+
+  /** calKey → 日历本名称缓存（通知文案用），60 秒刷新一次 */
+  private static calNameCache: Map<string, string> = new Map();
+  private static calNameLoadedAt: number = 0;
+
+  /** 日历本名称（通知文案用）：缓存 60 秒，'local' = 本机日历 */
+  private static async calName(context: common.Context, calKey: string): Promise<string> {
+    if (Date.now() - ReminderService.calNameLoadedAt > 60000
+      || ReminderService.calNameCache.size === 0) {
+      const map: Map<string, string> = new Map();
+      map.set('local', '本机日历');
+      try {
+        const accounts = await AccountStore.loadAll(context);
+        for (const acc of accounts) {
+          for (let i: number = 0; i < acc.calendarHrefs.length; i++) {
+            const bookName: string = i < acc.calendarNames.length
+              ? acc.calendarNames[i] : `日历本${i + 1}`;
+            map.set(`${acc.id}_${i}`, `${acc.name}·${bookName}`);
+          }
+        }
+      } catch (err) {
+        // 读取失败用旧缓存
+      }
+      ReminderService.calNameCache = map;
+      ReminderService.calNameLoadedAt = Date.now();
+    }
+    const name: string | undefined = ReminderService.calNameCache.get(calKey);
+    return name !== undefined ? name : '日历';
+  }
+
+  private static delay(ms: number): Promise<void> {
+    return new Promise<void>((resolve: () => void) => {
+      setTimeout(resolve, ms);
+    });
+  }
+
+  /** 当前系统里本应用的有效提醒条数 */
+  private static async poolCount(): Promise<number> {
+    try {
+      const all = await reminderAgentManager.getValidReminders();
+      return all.length;
+    } catch (err) {
+      return -1;
+    }
+  }
+
+  /**
+   * 发布单条代理提醒，1700002（池满/配额0）时清空后等待释放再重试，最多 3 轮。
+   * 3 轮后仍满且池内为 0 → 判定配额为 0（需华为邮件申请权限），抛出标记错误。
+   */
+  private static async publishWithRetry(request: reminderAgentManager.ReminderRequestCalendar): Promise<void> {
+    try {
+      await reminderAgentManager.publishReminder(request);
+      ReminderService.agentAvailable = true;
+      return;
+    } catch (err) {
+      const e = err as BusinessError;
+      if (e.code !== 1700002) {
+        // ArkTS 只允许抛 Error：错误码编入消息，调用方从 message 解析
+        throw new Error(`${e.code}:${e.message}`);
+      }
+    }
+    for (let attempt: number = 1; attempt <= 3; attempt++) {
+      // 已触发的代理提醒会残留为通知，一并清理
+      try {
+        await notificationManager.cancelAll();
+      } catch (err) {
+        // 忽略
+      }
+      await reminderAgentManager.cancelAllReminders();
+      await ReminderService.delay(1500);
+      const remain: number = await ReminderService.poolCount();
+      LogUtil.write(`提醒池满（第 ${attempt} 次腾位）：清空后剩余 ${remain} 条，重试发布`);
+      try {
+        await reminderAgentManager.publishReminder(request);
+        ReminderService.agentAvailable = true;
+        return;
+      } catch (err) {
+        const e = err as BusinessError;
+        if (e.code !== 1700002) {
+          throw new Error(`${e.code}:${e.message}`);
+        }
+      }
+    }
+    throw new Error('1700002:提醒池腾位 3 轮后仍满');
+  }
+
+  /** 判定"配额为 0"：1700002 且系统内有效提醒为 0（没有超额却报超额 = 没有配额） */
+  private static async isQuotaZero(): Promise<boolean> {
+    const remain: number = await ReminderService.poolCount();
+    return remain <= 0;
+  }
+
+  /** 全量重建代理提醒（仅在代理提醒可用时调用）。返回发布条数 */
+  static async refreshReminders(context: common.Context): Promise<number> {
+    let published: number = 0;
+    if (ReminderService.agentAvailable === false) {
+      return 0; // 应用内通知模式接管，不再请求代理提醒
+    }
     try {
       await reminderAgentManager.cancelAllReminders();
+      const before: number = await ReminderService.poolCount();
+      if (before > 0) {
+        LogUtil.write(`取消全部提醒后系统仍剩 ${before} 条`);
+      }
       const now: number = Date.now();
       const rows: LocalEvent[] =
         await EventDb.queryRemindable(context, now, now + ReminderService.WINDOW);
       // 提醒静音的日历本（如别人分享的本）：其中所有日程都不再提醒
       const muted: string[] = await AppSettings.getMutedReminderKeys(context);
-      let published: number = 0;
       for (const e of rows) {
         if (muted.includes(e.calKey)) {
           continue;
@@ -29,37 +138,207 @@ export class ReminderService {
         if (published >= ReminderService.MAX_REMINDERS) {
           break;
         }
-        const remindAt: number = e.startTime - e.reminder * 60000;
-        if (remindAt <= now) {
-          continue; // 提醒时间已过
+        // 多提醒：每个提前量各发一条（含旧单提醒数据回退）
+        const rems: number[] = e.reminders.length > 0 ? e.reminders
+          : (e.reminder > 0 ? [e.reminder] : []);
+        for (const rem of rems) {
+          if (published >= ReminderService.MAX_REMINDERS) {
+            break;
+          }
+          const remindAt: number = e.startTime - rem * 60000;
+          if (remindAt <= now) {
+            continue; // 提醒时间已过
+          }
+          const d = new Date(remindAt);
+          const calName: string = await ReminderService.calName(context, e.calKey);
+          const request: reminderAgentManager.ReminderRequestCalendar = {
+            reminderType: reminderAgentManager.ReminderType.REMINDER_TYPE_CALENDAR,
+            dateTime: {
+              year: d.getFullYear(),
+              month: d.getMonth() + 1,
+              day: d.getDate(),
+              hour: d.getHours(),
+              minute: d.getMinutes(),
+              second: 0
+            },
+            title: '日程提醒',
+            content: `「${calName}」中的「${e.title}」将在 ${rem} 分钟后开始`,
+            notificationId: (e.id * 10 + rem) % 100000,
+            expiredContent: '该日程已开始',
+            ringDuration: 5,
+            snoozeTimes: 0,
+            timeInterval: 0
+          };
+          await ReminderService.publishWithRetry(request);
+          published++;
         }
-        const d = new Date(remindAt);
-        const startTimeText: string = ReminderService.fmt(e.startTime);
-        const request: reminderAgentManager.ReminderRequestCalendar = {
-          reminderType: reminderAgentManager.ReminderType.REMINDER_TYPE_CALENDAR,
-          dateTime: {
-            year: d.getFullYear(),
-            month: d.getMonth() + 1,
-            day: d.getDate(),
-            hour: d.getHours(),
-            minute: d.getMinutes(),
-            second: 0
-          },
-          title: '日程提醒',
-          content: `「${e.title}」将于 ${startTimeText} 开始（提前 ${e.reminder} 分钟）`,
-          notificationId: e.id % 100000,
-          expiredContent: '该日程已开始',
-          ringDuration: 5,
-          snoozeTimes: 0,
-          timeInterval: 0
-        };
-        await reminderAgentManager.publishReminder(request);
-        published++;
       }
-      LogUtil.write(`提醒刷新完成：发布 ${published} 个提醒（窗口 7 天，静音日历本 ${muted.length} 个）`);
+      const after: number = await ReminderService.poolCount();
+      LogUtil.write(`提醒刷新完成：发布 ${published} 个提醒（窗口 7 天，静音日历本 ${muted.length} 个，池内现有 ${after} 条）`);
+      return published;
+    } catch (err) {
+      const e = err as Error;
+      if (e.message.startsWith('1700002') && await ReminderService.isQuotaZero()) {
+        // 配额为 0：普通应用未获代理提醒权限，降级为应用内通知模式
+        ReminderService.agentAvailable = false;
+        await AppSettings.setReminderTick(context, Date.now());
+        LogUtil.write('代理提醒配额为 0（需向华为邮件申请权限），已自动切换为应用内通知模式');
+        return 0;
+      }
+      LogUtil.write(`提醒刷新失败: ${e.message}`);
+      return published;
+    }
+  }
+
+  /**
+   * 应用内提醒检查（降级模式）：由自动同步定时器高频调用。
+   * 把"提醒时刻落在上次检查~现在之间"的日程用本地通知发出。
+   * App 进程被杀期间的提醒会错过（超过 2 分钟不补发），长时任务可避免。
+   */
+  static async tickReminders(context: common.Context): Promise<number> {
+    if (ReminderService.agentAvailable !== false) {
+      return 0; // 代理提醒可用或未判定，不需要降级
+    }
+    try {
+      const now: number = Date.now();
+      const last: number = await AppSettings.getReminderTick(context);
+      if (last <= 0) {
+        await AppSettings.setReminderTick(context, now); // 首次运行：只记基线不补发
+        return 0;
+      }
+      const from: number = Math.max(last, now - 2 * 60000); // 最多补发 2 分钟内的错过提醒
+      await AppSettings.setReminderTick(context, now);
+      const rows: LocalEvent[] =
+        await EventDb.queryRemindable(context, now, now + ReminderService.WINDOW);
+      const muted: string[] = await AppSettings.getMutedReminderKeys(context);
+      let fired: number = 0;
+      for (const e of rows) {
+        if (muted.includes(e.calKey)) {
+          continue;
+        }
+        const rems: number[] = e.reminders.length > 0 ? e.reminders
+          : (e.reminder > 0 ? [e.reminder] : []);
+        for (const rem of rems) {
+          const remindAt: number = e.startTime - rem * 60000;
+          if (remindAt <= from || remindAt > now) {
+            continue; // 不在本次检查窗口内
+          }
+          const calName: string = await ReminderService.calName(context, e.calKey);
+          const minLeft: number = Math.max(1,
+            Math.ceil((e.startTime - Date.now()) / 60000));
+          const fired2: number = await ReminderService.notifyNow(
+            '日程提醒', `「${calName}」中的「${e.title}」将在 ${minLeft} 分钟后开始`,
+            (e.id * 10 + rem) % 100000);
+          if (fired2 === 0) {
+            fired++;
+          }
+        }
+      }
+      if (fired > 0) {
+        LogUtil.write(`应用内提醒：本次发出 ${fired} 条到点提醒`);
+      }
+      return fired;
+    } catch (err) {
+      const e = err as Error;
+      LogUtil.write(`应用内提醒检查失败: ${e.message}`);
+      return 0;
+    }
+  }
+
+  /** 日历本通知渠道（SOCIAL_COMMUNICATION 默认横幅+锁屏+响铃振动），只注册一次 */
+  private static slotReady: boolean = false;
+
+  private static async ensureSlot(): Promise<void> {
+    if (ReminderService.slotReady) {
+      return;
+    }
+    try {
+      // 本 SDK 无锁屏可见性 API（已废弃），锁屏显示由系统"锁屏通知"设置 + 渠道默认行为决定
+      await notificationManager.addSlot(notificationManager.SlotType.SOCIAL_COMMUNICATION);
+    } catch (err) {
+      // 渠道已存在等情况忽略
+    }
+    ReminderService.slotReady = true;
+  }
+
+  /** 立即发一条本地通知。返回 0 表示成功 */
+  private static async notifyNow(title: string, text: string, id: number): Promise<number> {
+    await ReminderService.ensureSlot();
+    try {
+      const request: notificationManager.NotificationRequest = {
+        id: id,
+        notificationSlotType: notificationManager.SlotType.SOCIAL_COMMUNICATION,
+        content: {
+          notificationContentType: notificationManager.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
+          normal: {
+            title: title,
+            text: text,
+            additionalText: ''
+          }
+        }
+      };
+      await notificationManager.publish(request);
+      return 0;
     } catch (err) {
       const e = err as BusinessError;
-      LogUtil.write(`提醒刷新失败: ${e.code} - ${e.message}`);
+      LogUtil.write(`本地通知发布失败: ${e.code} - ${e.message}`);
+      return -1;
+    }
+  }
+
+  /** 测试入口：代理可用时发 1 分钟后的代理提醒；降级模式发立即本地通知 */
+  static async publishTestReminder(context: common.Context): Promise<string> {
+    if (ReminderService.agentAvailable === false) {
+      const r: number = await ReminderService.notifyNow(
+        '测试通知（应用内模式）', '如果你看到这条通知，说明应用内提醒链路正常', 99998);
+      return r === 0
+        ? '已发出测试通知（应用内模式：代理提醒配额为 0，由 App 进程在提醒时刻发通知）'
+        : '本地通知发布失败，详见日志';
+    }
+    // request 构造放在 try 外：腾位重试也要用到
+    const t: number = Date.now() + 60 * 1000;
+    const d = new Date(t);
+    const request: reminderAgentManager.ReminderRequestCalendar = {
+      reminderType: reminderAgentManager.ReminderType.REMINDER_TYPE_CALENDAR,
+      dateTime: {
+        year: d.getFullYear(),
+        month: d.getMonth() + 1,
+        day: d.getDate(),
+        hour: d.getHours(),
+        minute: d.getMinutes(),
+        second: 0
+      },
+      title: '测试提醒',
+      content: '这是一条测试提醒：如果你看到它，说明提醒链路正常',
+      notificationId: 99999,
+      expiredContent: '测试提醒已过期',
+      ringDuration: 5,
+      snoozeTimes: 0,
+      timeInterval: 0
+    };
+    const before: number = await ReminderService.poolCount();
+    LogUtil.write(`测试提醒发布前池内提醒 ${before} 条`);
+    try {
+      await ReminderService.publishWithRetry(request);
+      LogUtil.write('测试提醒已发布：1 分钟后应弹出通知');
+      return `已发布（发布前池内 ${before} 条），1 分钟后应弹出通知`;
+    } catch (err) {
+      const e = err as Error;
+      if (e.message.startsWith('1700002') && await ReminderService.isQuotaZero()) {
+        ReminderService.agentAvailable = false;
+        await AppSettings.setReminderTick(context, Date.now());
+        LogUtil.write('代理提醒配额为 0（需向华为邮件申请权限），已切换为应用内通知模式');
+        const r: number = await ReminderService.notifyNow(
+          '测试通知（应用内模式）', '如果你看到这条通知，说明应用内提醒链路正常', 99998);
+        return r === 0
+          ? '代理提醒配额为 0（需邮件向华为申请），已切换为应用内通知模式并发出测试通知'
+          : '代理提醒配额为 0，已切换应用内模式，但测试通知发布失败（详见日志）';
+      }
+      LogUtil.write(`测试提醒发布失败: ${e.message}`);
+      const sep: number = e.message.indexOf(':');
+      return sep > 0
+        ? `发布失败：错误码 ${e.message.substring(0, sep)}（${e.message.substring(sep + 1)}）`
+        : `发布失败：${e.message}`;
     }
   }
 

entry/src/main/ets/common/SyncEngine.ets

@@ -277,6 +277,7 @@ export class SyncEngine {
     r.rrule = e.rrule;
     r.exdate = e.exdate;
     r.reminder = e.reminder;
+    r.reminders = e.reminders.slice();
     return r;
   }
 
@@ -319,7 +320,7 @@ export class SyncEngine {
         const ics: string = IcsUtil.build(e);
         const etag: string = await DavClient.putEvent(url, auth, ics);
         await EventDb.clearDirty(context, e.id, etag);
-        LogUtil.write(`推送保存「${e.title}」→ ${url}（${ics.length} 字节）`);
+        LogUtil.write(`推送保存「${e.title}」→ ${url}（${ics.length} 字节，提醒=${e.reminders.map((n: number): string => String(n)).join('/')}分钟，VALARM=${ics.toUpperCase().includes('BEGIN:VALARM') ? '有' : '无'}）`);
       }
     }
   }