koishi-plugin-ll-schedule 1.1.0 → 1.3.0

package/index.js

@@ -1,88 +1,72 @@
 'use strict'
 
 // koishi-plugin-ll-schedule
-// 定时发送插件：设置时间自动向指定群发送文字
+// 定时提醒插件：到点自动向订阅群发送"提醒"（文字/图片/QQ官方Markdown卡片）
 // v1.0.6：一个任务支持多个时间（逗号分隔），群内"订阅"关键词自动注册推送群
-// v1.1.0：新增"排班表 slots"（按星期设置不同时间/内容）+ QQ官方Markdown卡片 + 模板变量
+// v1.1.0：新增排班表 slots + QQ 官方 Markdown 卡片 + 模板变量
+// v1.2.0：设置页重做 —— 任务 = "时间段列表，每行 = 星期 + 时间 + 内容"，删掉零散子字段，更直观
+//         （向后兼容：旧 time/text、旧 slots(days) 配置仍能识别）
 
 const { Schema, h } = require('koishi')
 
 exports.name = 'll-schedule'
 
-exports.usage = `定时发送插件：设置时间自动向指定群发送文字/卡片。
+exports.usage = `定时提醒插件：到时间自动向订阅了该任务的群发送提醒。每个任务 = 一张"时间段列表"，点 + 添加一行，每行填 星期 / 时间 / 内容。
 
-## 快速上手（推荐用法）
+## 快速上手
 
-1. 在插件设置页的 \`tasks\` 表格中添加任务：**键=任务名**，设置 \`time\`（发送时间，**可多个**）和 \`text\`（推送内容）
-2. 在任意群里 @机器人 发：\`订阅 任务名\` → 这个群就加入了该任务的推送列表（自动记录，重启不丢）
-3. 到点后插件自动把内容推送到所有订阅了该任务的群
+1. 在插件设置页的 \`tasks\` 里**添加任务**（键=任务名），在任务里 **添加时间段**：每行填 星期（留空=每天）/ 时间 / 内容
+2. 在任意群 @机器人 发：\`订阅 任务名\` → 该群加入此任务的订阅列表
+3. 到时间，插件自动把该时间段的内容发给所有订阅群
 
-## 排班表 slots（按星期设置不同的时间/内容）
+## 每个时间段三格子
 
-每个任务除了简单的 \`time\` + \`text\`，还可以填一张**排班表 \`slots\`**。每行 = 星期 + 时间 + 内容，互不影响：
+- **星期**：留空 = 每天；写 \`周一\` \`周六\`...、\`工作日\`（周一到周五）、\`周末\`（周六日）、或 \`1,3,5\` 数字
+- **时间**：\`HH:MM\`，可填多个用逗号分隔，如 \`12:20, 18:20, 21:20\`（这些时间点都发同一段内容）
+- **内容**：到点发送的话；支持 Markdown 语法和模板变量 \`{date}\` \`{time}\` \`{week}\` \`{task}\`
 
-\`\`\`yaml
-tasks:
-  每日推送:
-    slots:
-      - time: "12:20, 18:20, 21:20"   # 时间（可多个，逗号分隔）
-        days: ""                       # 星期：留空=每天；1,2,3=周一~周三；工作日；周末；一,三,五
-        text: "这段内容在设定的星期和时间发送"
-      - time: "20:55"                  # 同一任务可加任意多行
-        days: "工作日"
-        text: "工作日晚上说的话"
-      - time: "14:55, 20:55"
-        days: "周末"
-        text: "周末说的话（周六日各发两次）"
-\`\`\`
-
-- \`days\` 填写规则：留空 = **每天**；数字 \`1\`~\`7\`（1=周一，逗号分隔如 \`1,3,5\`）；中文 \`一,三,五\`；快捷词 \`工作日\`（周一~周五）/ \`周末\`（周六日）；也支持范围 \`1-5\`
-- **任务一旦填了 slots，就完全以 slots 为准**，旧的 \`time\`/\`text\` 自动忽略（不会重复发）；不填 slots 则行为和旧版完全一样
-- 以后要加时段/改内容，直接增删改表格行即可，群订阅不用重新弄
-
-## Markdown 卡片（官方QQ机器人）
-
-任务或排班行勾选 \`markdown\` 后，推送会用 **QQ官方 Markdown 卡片**发送（仅官机生效；失败自动回退纯文本，其他平台始终纯文本）。支持标题、加粗、引用、链接、图片等：
+## 示例：每天定时提醒
 
-\`\`\`markdown
-# 🎉 每日公告
+任务「轻功」，添加 1 行： 星期=空（每天） 时间=\`12:20, 18:20, 21:20\` 内容=\`⏰ 轻功时间到了！\`
+→ 每天这三个点都发这句。
 
-> 今天是 **{date}**（{week}），现在是 {time}
+## 示例：按天/按时段发不同内容（如世界BOSS）
 
-[官网点此访问](https://example.com)
-![配图](https://example.com/pic.jpg)
+任务「世界BOSS」，添加多行：
 \`\`\`
+周一  21:00   世界BOSS刷新！仙幻岛 → 白青山脉
+周二  21:00   世界BOSS刷新！仙幻岛 → 大漠
+周三  21:00   世界BOSS刷新！仙幻岛 → 御龙林
+周四  21:00   世界BOSS刷新！仙幻岛 → 水月平原
+周五  21:00   世界BOSS刷新！白青山脉 → 大漠
+周六  15:00   世界BOSS刷新！仙幻岛 → 白青山脉
+周六  21:00   世界BOSS刷新！仙幻岛 → 御龙林
+周日  15:00   世界BOSS刷新！仙幻岛 → 大漠
+周日  21:00   世界BOSS刷新！仙幻岛 → 水月平原
+\`\`\`
+每行对应一个时间段，内容各不相同。
+
+## Markdown 卡片（官方QQ机器人）
 
-\`text\` 中可用模板变量（发送时自动替换）：
-- \`{date}\`：今天日期（如 2026-08-23）
-- \`{time}\`：当前时间（如 12:20）
-- \`{week}\`：今天星期（如 星期三）
-- \`{task}\`：任务名
+任务勾选 \`markdown\` 后，会用 QQ 官方 Markdown 卡片发送（仅官机生效，失败自动回退纯文本；其他平台始终纯文本）。内容里可用标题/加粗/引用/链接/图片（图片直接写在内容里，如 \`![配图](https://...)\`），模板变量自动替换。
 
-## 任务配置
+## 其他配置
 
-- \`time\`：发送时间（24小时制 HH:MM），**可填多个，用逗号分隔**，如 \`09:00, 21:30\`（一条内容会在每个时间点各发一次）
-- \`text\`：推送内容（文字，可留空；支持 Markdown 语法和模板变量）
-- \`image\`：图片 URL（可选，随文本一起发送；markdown 模式自动嵌入为图片）
-- \`markdown\`：是否用 QQ官方 Markdown 卡片发送（默认关闭）
-- \`slots\`：排班表（可选，见上方说明；填了就以排班表为准）
-- \`groups\`：手动指定的目标群列表（**推荐留空**，用群内"订阅"命令添加更省事；留空且无订阅 = 发给所有已知群）
-- \`enabled\`：是否启用
+- \`groups\`：手动指定目标群（推荐留空，用群内"订阅"命令自动添加）
+- \`enabled\`：是否启用该任务
 
 ## 群内命令
 
-- \`订阅 [任务名]\`：当前群订阅指定任务的推送（不填任务名时，只有一个启用任务则自动选它）
+- \`订阅 [任务名]\`：当前群订阅指定任务
 - \`取消订阅 [任务名]\`：当前群取消订阅
 - \`订阅列表\`：查看所有任务的订阅群
-- \`schedule.list\`：查看任务列表（含排班表详情）
+- \`schedule.list\`：查看任务列表（含每段时间段）
 - \`schedule.test <任务名>\`：立即测试发送
-- \`lls.*\`：以上命令的备用入口（lls.sub / lls.unsub / lls.sublist / lls.list / lls.test）
-
-订阅/取消订阅所需权限等级在设置页 \`subscribeAuthority\` 调整（默认 1=所有人都能订阅）。\`subscribeAdminBypass\`（默认开启）：群主/群管理可无视权限等级直接订阅——插件从群消息自带的成员角色判断（\`owner\`/\`admin\`），**不需要申请接口权限**。想验证自己角色可发 \`我的ID\`。
+- \`lls.*\`：以上命令的备用入口
 
 ## 官机（官方QQ机器人）说明
 
-官方平台没有"群号"，只有 openid——用群内"订阅"命令即可，插件会自动记录当前群的 openid，无需手动填写。手动填 \`groups\` 时可用 \`schedule.groups\` 查看已知群的 openid。官机主动发群消息有平台频率限制，且机器人需在群里。
+官方平台没有群号只有 openid——用群内"订阅"命令即可，插件自动记录当前群 openid。手动填 \`groups\` 时用 \`schedule.groups\` 查看已知群 openid。官机主动发群消息有平台频率限制，且机器人需在群里。
 `
 
 // ===== 纯函数（可单测） =====
@@ -106,7 +90,7 @@ function todayDay(date) {
 const WEEK_CN = ['', '一', '二', '三', '四', '五', '六', '日']
 
 // 解析星期配置：返回 Set(1..7) 或 null（null = 每天）
-// 支持：留空/每天/每日、1-7 数字逗号分隔、范围 1-5、中文 一,三,五 / 星期X / 周X、工作日、周末
+// 支持：留空/每天/每日、1-7 数字逗号分隔、范围 1-5、中文 一,三,五 / 星期X / 周X / 每周X、工作日、周末
 function parseDays(daysStr) {
   if (daysStr === undefined || daysStr === null) return null
   const s = String(daysStr).trim()
@@ -125,7 +109,7 @@ function parseDays(daysStr) {
       }
       continue
     }
-    const cn = p.match(/^(?:星期|周|礼拜)?([一二三四五六日天])$/)
+    const cn = p.match(/^(?:每)?(?:星期|周|礼拜)?([一二三四五六日天])$/)
     if (cn) {
       set.add(cnMap[cn[1]])
       continue
@@ -144,35 +128,41 @@ function dayMatches(daysSet, day) {
   return !daysSet || daysSet.has(day)
 }
 
+// 把任务的时间段解析成统一行列表：[{ idx, wd(星期), time, text }]
+// 兼容三种写法：新 slots 数组（优先）、旧 time/text（每天）、旧 slots(days)
+function parseScheduleRows(task) {
+  if (!task) return []
+  if (Array.isArray(task.slots) && task.slots.length) {
+    return task.slots
+      .map((s, i) => ({
+        idx: i,
+        wd: s.wd !== undefined ? s.wd : s.days, // 兼容旧 slots 的 days 字段
+        time: s.time,
+        text: s.text || '',
+      }))
+      .filter(r => r.time)
+  }
+  if (task.time) {
+    return [{ idx: 0, wd: '', time: task.time, text: task.text || '' }]
+  }
+  return []
+}
+
 // 计算"现在这一刻该发什么"：返回 [{ name, key, text, markdown, image }]
-// date 为 Date 对象、hm 为 "HH:MM" 字符串；纯函数便于测试
 function computeFires(tasks, date, hm) {
   const day = todayDay(date)
   const fires = []
   for (const [name, task] of Object.entries(tasks || {})) {
     if (!task || task.enabled === false) continue
-    const slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
-    if (slots) {
-      slots.forEach((slot, idx) => {
-        if (!slot || !dayMatches(parseDays(slot.days), day)) return
-        const timeList = parseTimes(slot.time)
-        if (!timeList.includes(hm)) return
-        fires.push({
-          name,
-          key: `${name}@${hm}@${idx}`,
-          text: slot.text || '',
-          markdown: slot.markdown !== undefined ? !!slot.markdown : !!task.markdown,
-          image: task.image,
-        })
-      })
-    }
-    else {
-      const timeList = parseTimes(task.time)
+    const rows = parseScheduleRows(task)
+    for (const row of rows) {
+      if (!dayMatches(parseDays(row.wd), day)) continue
+      const timeList = parseTimes(row.time)
       if (!timeList.includes(hm)) continue
       fires.push({
         name,
-        key: `${name}@${hm}`,
-        text: task.text || '',
+        key: `${name}@${hm}@${row.idx}`,
+        text: row.text || '',
         markdown: !!task.markdown,
         image: task.image,
       })
@@ -212,58 +202,41 @@ function buildTextFromMd(md) {
     .trim()
 }
 
-exports._test = { parseTimes, todayDay, parseDays, dayMatches, computeFires, renderText, buildMd, buildTextFromMd }
+exports._test = { parseTimes, todayDay, parseDays, dayMatches, parseScheduleRows, computeFires, renderText, buildMd, buildTextFromMd }
 
 // ===== 配置 Schema =====
 
-const TimeSlot = Schema.object({
+const SlotItem = Schema.object({
+  wd: Schema.string()
+    .default('')
+    .description('星期：留空=每天；周一/周二...；工作日（周一到五）/周末（周六日）；或 1,3,5 / 1-5'),
   time: Schema.string()
     .required()
-    .description('发送时间（24小时制 HH:MM），可多个用逗号分隔，如 09:00, 21:30'),
-  days: Schema.string()
-    .default('')
-    .description('星期几生效：留空=每天；1-7（1=周一）逗号分隔如 1,3,5；快捷词"工作日"（周一~五）/"周末"（周六日）；中文"一,三,五"'),
+    .description('时间（24小时制 HH:MM），可多个用逗号分隔，如 12:20, 18:20, 21:20'),
   text: Schema.string()
     .default('')
-    .description('该时段发送的内容（文字，可留空；支持 Markdown 语法和模板变量 {date} {time} {week} {task}）'),
-  markdown: Schema.boolean()
-    .description('用 QQ官方 Markdown 卡片发送（留空则跟随任务级 markdown 设置）'),
+    .description('内容：到点发送的话，支持 Markdown 和模板变量 {date} {time} {week} {task}'),
 })
 
 const TaskItem = Schema.object({
-  time: Schema.string()
-    .required()
-    .description('发送时间（24小时制 HH:MM），可填多个用逗号分隔，如 09:00, 21:30；填了下方 slots 排班表时此项自动忽略'),
+  slots: Schema.array(SlotItem)
+    .default([])
+    .description('📅 时间段列表：每行 = 星期 + 时间 + 内容，点 + 可添加多行；每行内容各自独立'),
   groups: Schema.array(Schema.string())
     .default([])
     .description('手动指定的目标群 ID（可留空；推荐用群内"订阅"命令自动添加，无需手动填 openid）'),
-  text: Schema.string()
-    .default('')
-    .description('推送内容（文字，可留空；支持 Markdown 语法和模板变量 {date} {time} {week} {task}）'),
-  image: Schema.string()
-    .default('')
-    .description('图片 URL（可选）：随文本一起发送（markdown 模式自动嵌入为图片）'),
   markdown: Schema.boolean()
     .default(false)
     .description('用 QQ官方 Markdown 卡片发送（仅官方QQ机器人生效，失败自动回退纯文本；其他平台始终纯文本）'),
   enabled: Schema.boolean()
     .default(true)
     .description('是否启用'),
-  slots: Schema.array(TimeSlot)
-    .default([])
-    .description('📅 排班表（可选）：每行=星期+时间+内容，按星期设置不同时段/内容；一旦填写就完全以排班表为准，上方 time/text 自动忽略'),
 })
 
 const Config = Schema.object({
   tasks: Schema.dict(TaskItem)
     .default({})
-    .description('📋 定时任务表格（键=任务名，设置时间和推送内容）'),
-  subscribeKeyword: Schema.string()
-    .default('订阅')
-    .description('群内订阅推送的关键词（如"订阅 任务名"，只输关键词则订阅唯一启用的任务）'),
-  unsubscribeKeyword: Schema.string()
-    .default('取消订阅')
-    .description('群内取消订阅的关键词（如"取消订阅 任务名"）'),
+    .description('📋 推送任务表格（键=任务名；每个任务 = 时间段列表：星期/时间/内容）'),
   subscribeAuthority: Schema.number()
     .min(1).max(4).default(1)
     .description('执行订阅命令所需的最低权限等级（Koishi 用户权限等级，与QQ群主/管理员身份无关；默认 1=所有人都能订阅。如需限制，先在控制台"用户管理"给指定账号提权，再调高此值）'),
@@ -281,19 +254,17 @@ const Config = Schema.object({
 exports.Config = Config
 
 // 需要数据库：持久化学习到的群（重启不丢）
-// 必须声明 required：确保插件在数据库就绪后才启动，模型表能正常注册建表
 exports.inject = { required: ['database'] }
 
 function apply(ctx, config) {
   const logger = ctx.logger('ll-schedule')
 
-  // 记录当天已发送的任务，防止同一分钟重复发
+  // 记录当天已发送的，防止同一分钟重复发
   let firedToday = {}
 
   // ===== 已知群（从收到的消息中学习） =====
-  // key: `${botSid}:${guildId}` -> { botSid, guildId, platform, learnedAt }
   const knownGroups = new Map()
-  const groupNameCache = new Map() // key: botSid:guildId -> { v, t }
+  const groupNameCache = new Map()
   const TTL = 60 * 60 * 1000
 
   function cacheGet(map, key) {
@@ -304,7 +275,7 @@ function apply(ctx, config) {
     map.set(key, { v: value, t: Date.now() })
   }
 
-  // 数据库模型（可选）
+  // 数据库模型
   if (ctx.database) {
     ctx.model.extend('ll_schedule_groups', {
       botSid: 'string',
@@ -312,7 +283,6 @@ function apply(ctx, config) {
       platform: 'string',
       learnedAt: 'unsigned',
     }, { primary: ['botSid', 'guildId'] })
-    // 群订阅表：taskName + botSid + guildId（群内"订阅"命令注册的推送目标）
     ctx.model.extend('ll_schedule_subs', {
       taskName: 'string',
       botSid: 'string',
@@ -321,8 +291,7 @@ function apply(ctx, config) {
     }, { primary: ['taskName', 'botSid', 'guildId'] })
   }
 
-  // ===== 群订阅（群内发关键词注册推送目标） =====
-  // subs: Map<taskName, Map<`${botSid}:${guildId}`, { botSid, guildId, createdAt }>>
+  // ===== 群订阅 =====
   const subs = new Map()
 
   function getTaskSubs(taskName) {
@@ -436,7 +405,6 @@ function apply(ctx, config) {
     return ''
   }
 
-  // 从消息事件学习群
   ctx.on('message', (session) => {
     learnGroup(session)
   })
@@ -452,7 +420,6 @@ function apply(ctx, config) {
   }
 
   // ===== 发送 =====
-  // 官机 markdown 发送时忽略的已知错误码（主动消息受限等）
   const KNOWN_IGNORE_CODES = new Set([11293, 40034101, 40034105, 304101, 304102])
 
   function errCode(e) {
@@ -466,7 +433,6 @@ function apply(ctx, config) {
     return typeof code === 'number' && KNOWN_IGNORE_CODES.has(code)
   }
 
-  // 向一个目标发送一段内容；markdown 模式仅官机生效，失败自动回退纯文本
   async function sendOne(bot, target, text, { markdown, image }) {
     if (markdown && bot.platform === 'qq' && bot.internal && typeof bot.internal.sendMessage === 'function') {
       const md = buildMd(text, image)
@@ -515,7 +481,6 @@ function apply(ctx, config) {
     const taskSubs = subs.get(name)
 
     for (const bot of bots) {
-      // 该任务下、该机器人订阅的群（群内"订阅"命令注册的）
       const subTargets = taskSubs
         ? [...taskSubs.values()].filter(s => s.botSid === bot.sid).map(s => s.guildId)
         : []
@@ -524,7 +489,6 @@ function apply(ctx, config) {
         for (const rawTarget of groups || []) {
           const target = String(rawTarget).trim()
           if (!target) continue
-          // 官机：群 ID 是 openid；数字群号在官机上无法直接使用
           if (bot.platform === 'qq' && /^\d+$/.test(target)) {
             logger.warn(`[schedule] 任务 "${name}"：官方QQ机器人不能用数字群号 "${target}" 发送，请用群内"订阅"命令或 schedule.groups 查看 openid`)
             continue
@@ -548,7 +512,6 @@ function apply(ctx, config) {
         }
       }
       else if (config.sendAllWhenEmpty) {
-        // 未指定群也没有订阅 → 发送给该 bot 所有已知群
         const targets = [...knownGroups.values()].filter(g => g.botSid === bot.sid)
         if (!targets.length) {
           logger.warn(`[schedule] 任务 "${name}" 未指定群且机器人 ${bot.sid} 暂无已知群（先让机器人收过该群消息，或用 schedule.groups 查看）`)
@@ -573,7 +536,6 @@ function apply(ctx, config) {
   async function checkAndSend() {
     const now = new Date()
     const today = todayStr(now)
-    // 跨天重置
     if (firedToday.date !== today) {
       firedToday = { date: today }
     }
@@ -582,7 +544,6 @@ function apply(ctx, config) {
     const fires = computeFires(config.tasks, now, hm)
 
     for (const f of fires) {
-      // 今天这个时间点已经发过 → 跳过
       if (firedToday[f.key]) continue
       firedToday[f.key] = true
 
@@ -593,7 +554,6 @@ function apply(ctx, config) {
     }
   }
 
-  // 每 20 秒检查一次（保证同一分钟内能触发）
   const timer = setInterval(checkAndSend, 20000)
 
   ctx.on('dispose', () => clearInterval(timer))
@@ -614,42 +574,29 @@ function apply(ctx, config) {
   function formatTaskList() {
     const tasks = config.tasks || {}
     const keys = Object.keys(tasks)
-    if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加'
+    if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加任务'
     return keys.map(k => {
       const t = tasks[k]
       const s = t.enabled === false ? '⛔' : '✅'
       const staticGroups = (t.groups || []).join(',')
       const subCount = (subs.get(k) || new Map()).size
       const target = staticGroups ? staticGroups : (subCount ? `订阅${subCount}群` : '所有已知群')
-      const slots = Array.isArray(t.slots) && t.slots.length ? t.slots : null
-
-      let timeStr, contentStr
-      if (slots) {
-        const lines = slots.map((sl, i) => {
-          const ds = sl.days ? `[${sl.days}]` : '[每天]'
-          const ts = parseTimes(sl.time).join(',')
-          return `  ${i + 1}. ${ds} ${ts} → ${sl.text || '(空)'}${sl.markdown || t.markdown ? ' (md卡片)' : ''}`
-        })
-        timeStr = `排班表 ${slots.length} 行`
-        contentStr = lines.join('\n')
-      }
-      else {
-        const times = parseTimes(t.time)
-        timeStr = times.length ? times.join(', ') : (t.time || '(无时间)')
-        contentStr = [t.text && '文字', t.image && '图片'].filter(Boolean).join('+') || '(空)'
-        if (t.markdown) contentStr += ' (md卡片)'
-      }
-
-      return `${s} ${k} @ ${timeStr} → ${contentStr} → 群:${target}${subCount && staticGroups ? ` +订阅${subCount}群` : ''}`
+      const rows = parseScheduleRows(t)
+      const lines = rows.map((r, i) => {
+        const wd = r.wd || '每天'
+        return `  ${i + 1}. ${wd} ${r.time} → ${r.text || '(空)'}`
+      })
+      const head = `${s} ${k} → ${rows.length} 个时间段 → 群:${target}${t.markdown ? ' (md卡片)' : ''}`
+      return [head, ...lines].join('\n')
     }).join('\n')
   }
 
   ctx.command('schedule', '定时发送管理')
     .action(() => {
       logger.info('[schedule] 命令被调用: schedule')
-      return '⚙️ 管理：插件设置页 → ll-schedule → tasks 表格设置时间和内容\n' +
-        `群内发"${config.subscribeKeyword} 任务名"即可让本群订阅推送\n` +
-        `命令：${config.subscribeKeyword} | ${config.unsubscribeKeyword} | 订阅列表 | schedule.list | schedule.groups | schedule.test <任务名>`
+      return '⚙️ 管理：插件设置页 → ll-schedule → tasks 添加任务和时间段（星期/时间/内容）\n' +
+        `群内发"订阅 任务名"即可让本群订阅推送\n` +
+        `命令：订阅 | 取消订阅 | 订阅列表 | schedule.list | schedule.groups | schedule.test <任务名>`
     })
 
   ctx.command('schedule.list', '查看定时任务')
@@ -670,32 +617,20 @@ function apply(ctx, config) {
       const tasks = config.tasks || {}
       const task = tasks[name]
       if (!task) return `未找到任务 "${name}"，可用 schedule.list 查看任务名`
-      // 测试时：任务没配群也没订阅就发到当前群
       const testTask = { ...task }
       if (!testTask.groups || !testTask.groups.length) {
         testTask.groups = session.guildId ? [String(session.guildId)] : []
       }
-      // 有排班表时：发"今天会命中的第一行"的内容，更贴近真实
-      const slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
-      let sendText, sendMarkdown
-      if (slots) {
-        const day = todayDay()
-        const hit = slots.find(sl => dayMatches(parseDays(sl.days), day))
-        sendText = hit ? (hit.text || '') : (task.text || '')
-        sendMarkdown = hit ? (hit.markdown !== undefined ? !!hit.markdown : !!task.markdown) : !!task.markdown
-      }
-      else {
-        sendText = task.text || ''
-        sendMarkdown = !!task.markdown
-      }
-      await sendTask(name, testTask, { text: sendText, markdown: sendMarkdown, onlyBotSid: session.bot?.sid })
+      // 发"今天会命中的第一行"的内容，更贴近真实
+      const rows = parseScheduleRows(task)
+      const day = todayDay()
+      const hit = rows.find(r => dayMatches(parseDays(r.wd), day))
+      const sendText = hit ? (hit.text || '') : (task.text || '')
+      await sendTask(name, testTask, { text: sendText, markdown: task.markdown, onlyBotSid: session.bot?.sid })
       return `✅ 已发送任务 "${name}"`
     })
 
   // ===== 群内订阅命令 =====
-  // 判断发送者是否群主/群管理：
-  // 1) 优先用消息事件自带的成员角色（官机/OneBot 群消息都会带，零 API 调用，不受接口权限限制）
-  // 2) 兜底调 getGuildMember（需要接口权限，拿不到就忽略）
   async function isGroupAdmin(session) {
     if (!session.guildId || !session.userId) return false
     const role = session.author?.roles?.[0]?.id || session.event?.member?.roles?.[0]?.id
@@ -722,7 +657,6 @@ function apply(ctx, config) {
       (config.subscribeAdminBypass ? '，或为本群群主/群管理' : '')
   }
 
-  // 解析订阅命令的任务名：明确指定 → 用它；不填且只有一个启用任务 → 用它；否则返回提示
   function resolveSubscribeTaskName(taskName) {
     const tasks = config.tasks || {}
     if (taskName) {
@@ -748,16 +682,8 @@ function apply(ctx, config) {
     taskSubs.set(key, entry)
     persistSub(name, entry)
     logger.info(`[schedule] 群 ${session.guildId} 已订阅任务 "${name}"`)
-    const slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
-    let timeDesc
-    if (slots) {
-      timeDesc = `排班表 ${slots.length} 个时段（schedule.list 查看详情）`
-    }
-    else {
-      const times = parseTimes(task.time)
-      timeDesc = times.length ? times.join(', ') : '(未设置)'
-    }
-    return `✅ 本群已加入任务 "${name}" 的推送列表\n时间：${timeDesc}\n内容：${task.text || '（空）'}`
+    const rows = parseScheduleRows(task)
+    return `✅ 本群已加入任务 "${name}" 的推送列表\n时间段：${rows.length} 个（schedule.list 查看详情）`
   }
 
   async function unsubscribeCurrentGroup(session, taskName) {
@@ -774,7 +700,7 @@ function apply(ctx, config) {
     return `✅ 本群已取消订阅任务 "${name}"`
   }
 
-  ctx.command(config.subscribeKeyword + ' [taskName:text]', '让当前群订阅指定任务的推送')
+  ctx.command('订阅 [taskName:text]', '让当前群订阅指定任务的推送')
     .action(async ({ session }, taskName) => {
       if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await subscribeCurrentGroup(session, taskName)
@@ -786,7 +712,7 @@ function apply(ctx, config) {
       return await subscribeCurrentGroup(session, taskName)
     })
 
-  ctx.command(config.unsubscribeKeyword + ' [taskName:text]', '让当前群取消订阅指定任务的推送')
+  ctx.command('取消订阅 [taskName:text]', '让当前群取消订阅指定任务的推送')
     .action(async ({ session }, taskName) => {
       if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await unsubscribeCurrentGroup(session, taskName)
@@ -801,7 +727,7 @@ function apply(ctx, config) {
   ctx.command('订阅列表', '查看所有任务的订阅群')
     .action(async () => {
       logger.info('[schedule] 命令被调用: 订阅列表')
-      if (!subs.size) return '暂无任何群订阅。群内发"' + config.subscribeKeyword + ' 任务名"即可订阅'
+      if (!subs.size) return '暂无任何群订阅。群内发"订阅 任务名"即可订阅'
       const lines = []
       for (const [taskName, taskSubs] of subs) {
         const entries = [...taskSubs.values()]
@@ -818,7 +744,7 @@ function apply(ctx, config) {
   ctx.command('lls.sublist', '查看订阅列表（备用入口）')
     .action(async () => {
       logger.info('[schedule] 命令被调用: lls.sublist')
-      if (!subs.size) return '暂无任何群订阅。群内发"' + config.subscribeKeyword + ' 任务名"即可订阅'
+      if (!subs.size) return '暂无任何群订阅。群内发"订阅 任务名"即可订阅'
       const lines = []
       for (const [taskName, taskSubs] of subs) {
         const entries = [...taskSubs.values()]
@@ -837,11 +763,7 @@ function apply(ctx, config) {
       logger.info('[schedule] 命令被调用: 我的ID')
       const role = session.author?.roles?.[0]?.id || session.event?.member?.roles?.[0]?.id
       const roleName = role === 'owner' ? '群主' : role === 'admin' ? '群管理' : role === 'member' ? '普通成员' : (role || '未知')
-      const lines = [
-        '👤 我的账号信息：',
-        `平台：${session.platform}`,
-        `用户ID：${session.userId}`,
-      ]
+      const lines = ['👤 我的账号信息：', `平台：${session.platform}`, `用户ID：${session.userId}`]
       if (session.guildId) lines.push(`当前群ID：${session.guildId}`)
       if (session.guildId) lines.push(`本群角色：${roleName}`)
       if (session.channelId && session.channelId !== session.guildId) lines.push(`频道ID：${session.channelId}`)
@@ -853,18 +775,13 @@ function apply(ctx, config) {
       logger.info('[schedule] 命令被调用: lls.me')
       const role = session.author?.roles?.[0]?.id || session.event?.member?.roles?.[0]?.id
       const roleName = role === 'owner' ? '群主' : role === 'admin' ? '群管理' : role === 'member' ? '普通成员' : (role || '未知')
-      const lines = [
-        '👤 我的账号信息：',
-        `平台：${session.platform}`,
-        `用户ID：${session.userId}`,
-      ]
+      const lines = ['👤 我的账号信息：', `平台：${session.platform}`, `用户ID：${session.userId}`]
       if (session.guildId) lines.push(`当前群ID：${session.guildId}`)
       if (session.guildId) lines.push(`本群角色：${roleName}`)
       if (session.channelId && session.channelId !== session.guildId) lines.push(`频道ID：${session.channelId}`)
       return lines.join('\n')
     })
 
-  // 备用命令入口（避免与其他插件的 schedule 命令冲突）
   ctx.command('lls', 'll-schedule 管理（备用入口）')
     .action(() => {
       logger.info('[schedule] 命令被调用: lls')
@@ -893,26 +810,17 @@ function apply(ctx, config) {
       if (!testTask.groups || !testTask.groups.length) {
         testTask.groups = session.guildId ? [String(session.guildId)] : []
       }
-      const slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
-      let sendText, sendMarkdown
-      if (slots) {
-        const day = todayDay()
-        const hit = slots.find(sl => dayMatches(parseDays(sl.days), day))
-        sendText = hit ? (hit.text || '') : (task.text || '')
-        sendMarkdown = hit ? (hit.markdown !== undefined ? !!hit.markdown : !!task.markdown) : !!task.markdown
-      }
-      else {
-        sendText = task.text || ''
-        sendMarkdown = !!task.markdown
-      }
-      await sendTask(name, testTask, { text: sendText, markdown: sendMarkdown, onlyBotSid: session.bot?.sid })
+      const rows = parseScheduleRows(task)
+      const day = todayDay()
+      const hit = rows.find(r => dayMatches(parseDays(r.wd), day))
+      const sendText = hit ? (hit.text || '') : (task.text || '')
+      await sendTask(name, testTask, { text: sendText, markdown: task.markdown, onlyBotSid: session.bot?.sid })
       return `✅ 已发送任务 "${name}"`
     })
 
   logger.info('[schedule] 命令已注册: schedule / schedule.list / schedule.groups / schedule.test / ' +
-    `"${config.subscribeKeyword}" / "${config.unsubscribeKeyword}" / 订阅列表 / lls.*`)
+    `"订阅" / "取消订阅" / 订阅列表 / lls.*`)
 
-  // 启动时：加载已知群 + 订阅 + 立即检查一次
   Promise.all([loadKnownGroups(), loadSubs()]).then(() => checkAndSend())
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-ll-schedule",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Scheduled message sender with weekly slots (per-day time & content), QQ official markdown card support",
   "main": "index.js",
   "files": [
@@ -18,3 +18,5 @@
     }
   }
 }
+
+