dsh-foxy-weibo 0.2.3 → 0.3.0

package/README.md

@@ -6,13 +6,13 @@ Foxy 的微博子插件：按 foxy3 预设关注微博账号、阅读博文、
 
 ## 功能
 
-- **博文评论回复**：检查指定的监控账号 UID，读取其新博文下的评论，只回复未处理的他人评论；登录账号是机器人自己，监控账号通常是主人账号；
-- 可设置每日检查时间（`HH:MM`，最多 6 个），例如 `08:30, 20:00`；
-- 回复前按 foxy3 预设判断 `skip / comment`，不设最少字数，最多 80 字；
-- 旧模式保留：关注一个或多个微博 UID，定时读取时间线并评论；
-- 可选自动回复/评论，支持 `replyOthers`、每日上限；
-- 浏览、评论、回复事件写入 Foxy 记忆，字段包含 `platform: weibo`、`channelType: weibo_post|weibo_comment`、`eventType: weibo_browse|weibo_comment|weibo_reply`；
-- 设置页提供扫码登录、Cookie 备用、自己的 UID、关注 UID、模型、每日时间、回复模式、调试日志与立即运行。
+- **阅读目标账号博文**：按设定时间阅读监控账号的博文，每篇写入一条“目标账号博文”记忆，按博文 ID 去重；
+- 可选对博文发表一级评论；可设置评论起始时间（`replyAfter`），只评论该时间之后的博文；
+- 评论前按 foxy3 预设判断 `skip / comment`，不设最少字数，最多 80 字；
+- 自检去重：已评论/已跳过的博文写入 `postSeen`，不会重复评论同一篇；
+- 旧模式保留：关注一个或多个微博 UID，定时读取时间线并评论（`replyOwnPosts: false`）；
+- 阅读、评论事件写入 Foxy 记忆，字段包含 `platform: weibo`、`channelType: weibo_post`、`eventType: weibo_owner_post|weibo_comment`；
+- 设置页提供扫码登录、Cookie 备用、监控账号 UID、关注 UID、模型、每日时间、评论模式、评论起始时间、记忆开关、调试日志与立即检查/立即回复。
 
 ## 安装
 
@@ -47,7 +47,7 @@ Cookie 只保存在本机 `~/.dsh/foxy-weibo/settings.json`，不会回传给前
 
 ### 自己的 UID / 关注 UID
 
-`监控账号 UID` 是要检查博文评论的目标账号（通常是主人账号）；`当前账号` 是扫码登录的机器人账号，两者可以不同。
+`监控账号 UID` 是被阅读、被评论的目标账号（通常是主人账号）；`当前账号` 是扫码登录的机器人账号，两者可以不同。插件不会把登录的机器人账号当成监控账号。
 
 `关注 UID` 是旧模式使用，多个 UID 用逗号分隔，最多 20 个。UID 是微博用户主页 URL 里的数字 ID，例如 `https://weibo.com/u/1234567890`。
 
@@ -64,18 +64,17 @@ Cookie 只保存在本机 `~/.dsh/foxy-weibo/settings.json`，不会回传给前
 ## 建议顺序
 
 1. 扫码登录，填监控账号 UID，`enabled: true`、`replyMode: off`；
-2. 设置每日检查时间，或先点「立即运行」，看日志和「调试」里的模型决策；
+2. 设置每日检查时间，或先点「立即检查」，看日志和「调试」里的模型决策；
 3. 确认判断正常后，再开启 `replyMode: auto`，每日上限先设为 1；
-4. 「立即检查」只判断不发布，用来预览回复；「立即回复」会真实发布一条，适合测试；
-5. 微博评论有账号风控，不要高频、不要对陌生人全自动回复。
+4. 「立即检查」只预览、不评论；「立即回复」会真实评论一篇，适合测试；
+5. 评论有账号风控，不要高频；阅读往期博文会写入记忆，但按博文 ID 去重。
 
 ## 记忆事件
 
 微博插件写入的示例：
 
-- 浏览：`我在微博看到 <博主> 的博文「...」，觉得...`
-- 评论：`我在微博评论了 <博主> 的博文「...」：...`
-- 回复：`我在微博回复了 <网友> 在自己博文「...」下的评论：...`
+- 阅读目标博文：`我看到 <博主> 发了一条微博：「...」`
+- 评论博文：`我在微博评论了 <博主> 的博文「...」：...`
 
 事件字段：
 

package/cordis.patch.yml

@@ -14,10 +14,12 @@
         targetUids: []
         replyOwnPosts: true
         replyMode: 'off'
+        replyAfter: ''
+        learnPosts: true
         scheduleTimes:
           - '20:00'
         intervalMinutes: 60
-        maxPostsPerRun: 5
+        maxPostsPerRun: 20
         commentMode: 'off'
         maxCommentsPerDay: 1
         replyOthers: true

package/lib/client.js

@@ -224,9 +224,11 @@ window.__ModuleLoader__.load({
                 ? '正在运行，请稍候'
                 : result.skipped === 'no-target'
                   ? '未开始：请先填写监控账号 UID'
-                  : `运行完成：检查 ${result.checked || 0} 条，回复 ${result.replied || 0} 条` +
+                  : `运行完成：博文 ${result.posts || 0} 篇，读取记忆 ${result.memories || 0} 条，` +
+                    `评论 ${result.commented || 0} 条` +
                     (result.previewed ? `，预览 ${result.previewed} 条` : '') +
-                    `，跳过 ${result.skipped || 0} 条`,
+                    `，跳过 ${result.skipped || 0} 条` +
+                    (result.errors ? `，失败 ${result.errors} 条` : ''),
           )
         } catch (e) { setError(e.message) } finally { setBusy('') }
       }
@@ -246,7 +248,8 @@ window.__ModuleLoader__.load({
               ? '未开始：请先填写监控账号 UID'
               : result.skipped === 'busy'
                 ? '正在运行，请稍候'
-                : `检查完成：检查 ${result.checked || 0} 条评论，预览 ${result.previewed || 0} 条，跳过 ${result.skipped || 0} 条` +
+                : `检查完成：博文 ${result.posts || 0} 篇，可评论 ${result.previewed || 0} 条，` +
+                  `读取记忆 ${result.memories || 0} 条，跳过 ${result.skipped || 0} 条` +
                   (result.errors ? `，失败 ${result.errors} 条` : ''),
           )
         } catch (e) { setError(e.message) } finally { setBusy('') }
@@ -264,11 +267,11 @@ window.__ModuleLoader__.load({
             return
           }
           setNotice(
-            result.replied > 0
-              ? `已立即回复 ${result.replied} 条，可在下方日志查看`
+            result.commented > 0
+              ? `已评论 ${result.commented} 篇博文，可在下方日志查看`
               : result.skipped === 'no-target'
                 ? '未开始：请先填写监控账号 UID'
-                : '没有可立即回复的评论（可能已处理或模型选择跳过）',
+                : `已浏览 ${result.posts || 0} 篇博文，但没有可立即评论的新博文（可能已处理或模型选择跳过）`,
           )
         } catch (e) { setError(e.message) } finally { setBusy('') }
       }
@@ -326,21 +329,28 @@ window.__ModuleLoader__.load({
         ),
 
         h('section', { className: 'fw-card' },
-          h(SectionHead, { title: '博文评论回复', description: '每日按设定时间检查目标账号的新博文，并回复其评论区中尚未处理的他人评论。' }),
+          h(SectionHead, { title: '博文阅读与评论', description: '阅读目标账号的博文并写入记忆；仅对设定时间之后的博文发表评论。' }),
           h(Toggle, { checked: settings.enabled, onChange: (v) => setField('enabled', v), label: '启用自动检查', hint: '关闭后定时任务不运行，仍可使用「立即运行」。' }),
           h(Toggle, { checked: settings.replyOwnPosts, onChange: (v) => setField('replyOwnPosts', v), label: '仅监控目标账号的博文', hint: '关闭后回到旧模式，浏览关注账号的时间线并评论博文。' }),
           h('div', { className: 'fw-grid' },
             h(Field, { label: '每日检查时间', hint: 'HH:MM，多个用逗号分隔，最多 6 个，例如 08:30, 20:00' },
               h('input', { value: scheduleText, placeholder: '20:00', onChange: (e) => setScheduleText(e.target.value) })),
-            h(Field, { label: '回复模式', hint: '自动才会发布回复；建议先仅记录' },
+            h(Field, { label: '评论模式', hint: '自动才会发布博文评论；建议先仅检查' },
               h('select', { value: settings.replyMode, onChange: (e) => setField('replyMode', e.target.value) },
                 h('option', { value: 'off' }, '仅检查，不回复'),
                 h('option', { value: 'auto' }, '自动回复'),
               )),
-            h(Field, { label: '每轮检查博文数', hint: '范围 1–20' },
-              h('input', { type: 'number', min: 1, max: 20, value: settings.maxPostsPerRun, onChange: (e) => setField('maxPostsPerRun', e.target.value) })),
-            h(Field, { label: '每日回复上限', hint: '0–10，同时限制评论' },
+            h(Field, { label: '浏览范围（博文条数）', hint: '按时间倒序检查；1–100，填 100 即尽量浏览全部' },
+              h('input', { type: 'number', min: 1, max: 100, value: settings.maxPostsPerRun, onChange: (e) => setField('maxPostsPerRun', e.target.value) })),
+            h(Field, { label: '每日评论上限', hint: '0–10，仅统计自动评论' },
               h('input', { type: 'number', min: 0, max: 10, value: settings.maxCommentsPerDay, onChange: (e) => setField('maxCommentsPerDay', e.target.value) })),
+            h(Field, { label: '评论起始时间', hint: '只评论此时间之后的博文；留空表示不限制' },
+              h('input', { type: 'datetime-local', value: settings.replyAfter || '', onChange: (e) => setField('replyAfter', e.target.value) })),
+            h(Field, { label: '阅读后写入记忆', hint: '每篇未读博文写一条“目标账号博文”记忆，按博文去重' },
+              h('select', { value: settings.learnPosts === false ? 'off' : 'on', onChange: (e) => setField('learnPosts', e.target.value === 'on') },
+                h('option', { value: 'on' }, '写入'),
+                h('option', { value: 'off' }, '不写入'),
+              )),
           ),
           h('div', { className: 'fw-grid' },
             h(Field, { label: '时间线轮询（旧模式备用）', hint: '关闭“仅监控目标账号的博文”时使用，分钟' },
@@ -351,8 +361,7 @@ window.__ModuleLoader__.load({
                 h('option', { value: 'auto' }, '自动评论'),
               )),
           ),
-          h(Toggle, { checked: settings.replyOthers, onChange: (v) => setField('replyOthers', v), label: '回复他人评论', hint: '旧模式可从评论区选择一条评论回复。' }),
-          h(Toggle, { checked: settings.enableMemory, onChange: (v) => setField('enableMemory', v), label: '写入 Foxy 记忆', hint: '通过 foxyMemory 写入微博事件，按 preset 召回。' }),
+          h(Toggle, { checked: settings.enableMemory, onChange: (v) => setField('enableMemory', v), label: '启用 Foxy 记忆', hint: '通过 foxyMemory 写入微博事件，按 preset 召回。' }),
           h(Toggle, { checked: settings.runOnStart, onChange: (v) => setField('runOnStart', v), label: '启动 DSH 后自动运行', hint: '启动约 20 秒后执行一轮。' }),
           h(Toggle, { checked: settings.debug, onChange: (v) => setField('debug', v), label: '记录调试日志', hint: '保存模型输出与记忆写入结果，便于排查。' }),
           h('div', { className: 'fw-actions' },

package/lib/index.js

@@ -30,6 +30,9 @@ function loadState() {
       seen: parsed.seen && typeof parsed.seen === 'object' ? parsed.seen : {},
       commentSeen:
         parsed.commentSeen && typeof parsed.commentSeen === 'object' ? parsed.commentSeen : {},
+      postSeen: parsed.postSeen && typeof parsed.postSeen === 'object' ? parsed.postSeen : {},
+      postMemory:
+        parsed.postMemory && typeof parsed.postMemory === 'object' ? parsed.postMemory : {},
       days: parsed.days && typeof parsed.days === 'object' ? parsed.days : {},
       history: Array.isArray(parsed.history) ? parsed.history.slice(0, 50) : [],
       debug: Array.isArray(parsed.debug) ? parsed.debug.slice(0, 80) : [],
@@ -37,7 +40,17 @@ function loadState() {
       lastResult: parsed.lastResult || null,
     }
   } catch {
-    return { seen: {}, commentSeen: {}, days: {}, history: [], debug: [], lastRun: 0, lastResult: null }
+    return {
+      seen: {},
+      commentSeen: {},
+      postSeen: {},
+      postMemory: {},
+      days: {},
+      history: [],
+      debug: [],
+      lastRun: 0,
+      lastResult: null,
+    }
   }
 }
 
@@ -65,6 +78,13 @@ function firstLine(text, limit = 120) {
   return String(text || '').replace(/\s+/g, ' ').trim().slice(0, limit)
 }
 
+function entryReason(decision) {
+  return (
+    String(decision?.mood || decision?.memory || decision?.reason || '').trim() ||
+    '模型判断不需要评论'
+  )
+}
+
 function pushHistory(state, entry) {
   state.history = [entry, ...(Array.isArray(state.history) ? state.history : [])].slice(0, 50)
 }
@@ -158,6 +178,200 @@ async function rememberReply(ctx, config, state, post, comment, replyText) {
   }
 }
 
+async function rememberPost(ctx, config, state, post) {
+  if (!config.enableMemory || config.learnPosts === false) {
+    return { ok: false, reason: 'disabled' }
+  }
+  if (state.postMemory?.[post.id]) return { ok: false, reason: 'already' }
+  const provider = memoryProvider(ctx)
+  if (!provider?.record) return { ok: false, reason: 'no-provider' }
+  const excerpt = firstLine(post.text, 180)
+  const text = `我看到 ${post.author.name || '目标账号'} 发了一条微博：「${excerpt}」`
+  try {
+    await provider.record({
+      role: 'assistant',
+      text,
+      sessionId: `weibo-post:${post.id}`,
+      presetId: config.memoryPresetId || 'foxy3（Character）',
+      platform: 'weibo',
+      sourceLabel: '目标账号博文',
+      eventType: 'weibo_owner_post',
+      channelType: 'weibo_post',
+      channelId: post.id,
+      title: excerpt,
+      url: post.url,
+      scene: 'weibo',
+    })
+    state.postMemory = state.postMemory || {}
+    state.postMemory[post.id] = Date.now()
+    debugLog(state, config, {
+      kind: 'memory',
+      post: post.id,
+      memory: 'written',
+      eventType: 'weibo_owner_post',
+      text: firstLine(text, 300),
+    })
+    return { ok: true, reason: 'written', text }
+  } catch (error) {
+    const reason = error?.message || String(error)
+    debugLog(state, config, { kind: 'memory', post: post.id, memory: 'error', reason })
+    return { ok: false, reason }
+  }
+}
+
+async function scanTargetPosts(ctx, config, state, log, force = false, options = {}) {
+  if (!config.enabled && !force) return { skipped: 'disabled' }
+  const previewOnly = options.previewOnly === true
+  const forceReply = options.forceReply === true
+  const canComment = !previewOnly && (forceReply || config.replyMode === 'auto')
+  const targetUid = String(config.targetUid || '').trim()
+  const result = {
+    mode: options.mode || 'target-posts',
+    posts: 0,
+    checked: 0,
+    commented: 0,
+    previewed: 0,
+    skipped: 0,
+    errors: 0,
+    memories: 0,
+    items: [],
+  }
+  if (!targetUid) return { ...result, skipped: 'no-target' }
+  if (!config.cookie) return { ...result, errors: 1, error: '请先扫码登录微博账号' }
+  const account = await fetchAccount(config.cookie)
+  if (!account.uid) return { ...result, errors: 1, error: '微博登录态无效，请重新扫码登录后再检查' }
+  const loginUid = String(config.accountUid || account.uid || '')
+  const maxPosts = Math.max(1, Math.min(100, Number(options.maxPosts ?? config.maxPostsPerRun) || 5))
+  const cutoff = config.replyAfter ? Date.parse(config.replyAfter) : 0
+  const maxComments = Math.max(1, Math.min(10, Number(config.maxCommentsPerDay) || 1))
+  let posts = []
+  try {
+    posts = await fetchTimeline(targetUid, config, {
+      maxPosts,
+      maxPages: Math.ceil(maxPosts / 10) + 1,
+    })
+    result.posts = posts.length
+  } catch (error) {
+    return { ...result, errors: 1, error: error?.message || String(error) }
+  }
+  debugLog(state, config, {
+    kind: 'timeline',
+    targetUid,
+    posts: posts.length,
+    replyAfter: config.replyAfter || '',
+  })
+
+  for (const post of posts) {
+    if (!post.id) continue
+    const memory = await rememberPost(ctx, config, state, post)
+    if (memory.ok) result.memories += 1
+    if (state.postSeen?.[post.id]) continue
+    if (cutoff && post.createdAtMs && post.createdAtMs < cutoff) continue
+    if (!canComment && config.replyMode === 'off' && !previewOnly) {
+      // Still preview in check mode; normal runs with reply off only learn.
+    }
+    if (canComment && commentCount(state) >= maxComments) {
+      result.skipped += 1
+      debugLog(state, config, {
+        kind: 'quota',
+        post: post.id,
+        message: '每日评论额度已用完',
+      })
+      continue
+    }
+    result.checked += 1
+    let entry
+    try {
+      const decision = await judgePost(config, {
+        summary: postSummary(post),
+        comments: [],
+        commentsText: '',
+        targetPost: post,
+        mayComment: true,
+        mayReply: false,
+        forceComment: forceReply,
+      })
+      const comment = String(decision.comment || '').trim()
+      if (decision.action === 'comment' && comment && canComment) {
+        const published = await postComment({ mid: post.mid || post.id, text: comment, config })
+        result.commented += 1
+        bumpComments(state)
+        state.postSeen[post.id] = { status: 'commented', at: Date.now(), commentId: published.cid }
+        entry = {
+          at: Date.now(),
+          kind: 'weibo-post',
+          postId: post.id,
+          title: firstLine(post.text, 80),
+          url: post.url,
+          author: post.author.name,
+          action: 'comment',
+          comment,
+          commentId: published.cid,
+          memory: memory.ok ? 'written' : memory.reason,
+        }
+        ctx.logger?.info?.(`[foxy-weibo] 评论博文 ${post.id}：${firstLine(comment, 80)}`)
+      } else if (decision.action === 'comment' && comment) {
+        result.previewed += 1
+        entry = {
+          at: Date.now(),
+          kind: 'weibo-post',
+          postId: post.id,
+          title: firstLine(post.text, 80),
+          url: post.url,
+          author: post.author.name,
+          action: 'preview',
+          comment,
+          memory: memory.ok ? 'written' : memory.reason,
+        }
+      } else {
+        result.skipped += 1
+        state.postSeen[post.id] = { status: 'skipped', at: Date.now() }
+        entry = {
+          at: Date.now(),
+          kind: 'weibo-post',
+          postId: post.id,
+          title: firstLine(post.text, 80),
+          url: post.url,
+          author: post.author.name,
+          action: 'skip',
+          reason: entryReason(decision),
+          memory: memory.ok ? 'written' : memory.reason,
+        }
+      }
+      debugLog(state, config, {
+        kind: 'target-judge',
+        post: post.id,
+        action: decision.action,
+        memory: memory.ok ? 'written' : memory.reason,
+        raw: String(decision.raw || '').slice(0, 500),
+      })
+    } catch (error) {
+      result.errors += 1
+      entry = {
+        at: Date.now(),
+        kind: 'weibo-post',
+        postId: post.id,
+        title: firstLine(post.text, 80),
+        action: 'error',
+        error: error?.message || String(error),
+      }
+    }
+    if (entry) {
+      pushHistory(state, entry)
+      result.items.push(entry)
+      log(
+        `[foxy-weibo] 博文 ${entry.postId} 《${entry.title}》 -> ${ACTION_LABELS[entry.action] || entry.action}` +
+          (entry.error ? `（${firstLine(entry.error, 100)}）` : ''),
+      )
+    }
+    if (result.commented >= maxComments) break
+    await new Promise((resolve) => setTimeout(resolve, 600))
+  }
+  state.lastRun = Date.now()
+  state.lastResult = result
+  return result
+}
+
 async function scanOwnComments(ctx, config, state, log, force = false, options = {}) {
   if (!config.enabled && !force) return { skipped: 'disabled' }
   const previewOnly = options.previewOnly === true
@@ -171,6 +385,8 @@ async function scanOwnComments(ctx, config, state, log, force = false, options =
     previewed: 0,
     skipped: 0,
     errors: 0,
+    posts: 0,
+    comments: 0,
     items: [],
   }
   const targetUid = String(config.targetUid || '').trim()
@@ -189,12 +405,16 @@ async function scanOwnComments(ctx, config, state, log, force = false, options =
   } else {
     return { ...result, errors: 1, error: '请先扫码登录微博账号' }
   }
-  const maxPosts = Math.max(1, Math.min(20, Number(config.maxPostsPerRun) || 5))
+  const maxPosts = Math.max(1, Math.min(100, Number(config.maxPostsPerRun) || 5))
   const maxReplies = Math.max(1, Math.min(8, Number(options.maxReplies ?? config.maxCommentsPerDay) || 1))
   const ignoreQuota = forceReply
   let posts = []
   try {
-    posts = await fetchTimeline(targetUid, config)
+    posts = await fetchTimeline(targetUid, config, {
+      maxPosts,
+      maxPages: Math.ceil(maxPosts / 10) + 1,
+    })
+    result.posts = posts.length
   } catch (error) {
     return { ...result, errors: 1, error: error?.message || String(error) }
   }
@@ -209,6 +429,7 @@ async function scanOwnComments(ctx, config, state, log, force = false, options =
       log(`[foxy-weibo] 读取评论失败 ${post.id}：${error?.message || error}`)
       continue
     }
+    result.comments += comments.length
     for (const comment of comments) {
       if (targetCid && String(comment.cid) !== targetCid) continue
       if (canReply && result.replied >= maxReplies) break
@@ -482,7 +703,7 @@ export function apply(ctx, rawConfig = {}) {
       const result =
         config.replyOwnPosts === false
           ? await scanOnce(ctx, config, state, log, force)
-          : await scanOwnComments(ctx, config, state, log, force)
+          : await scanTargetPosts(ctx, config, state, log, force)
       saveState(state)
       log(`[foxy-weibo] 运行结束 ${JSON.stringify(result)}`)
       return result
@@ -500,9 +721,9 @@ export function apply(ctx, rawConfig = {}) {
     running = true
     try {
       log('[foxy-weibo] 开始立即检查')
-      const result = await scanOwnComments(ctx, config, state, log, true, {
+      const result = await scanTargetPosts(ctx, config, state, log, true, {
         previewOnly: true,
-        mode: 'own-comments-check',
+        mode: 'target-posts-check',
       })
       saveState(state)
       log(`[foxy-weibo] 立即检查结束 ${JSON.stringify(result)}`)
@@ -521,11 +742,10 @@ export function apply(ctx, rawConfig = {}) {
     running = true
     try {
       log(`[foxy-weibo] 开始立即回复${cid ? ` cid=${cid}` : ''}`)
-      const result = await scanOwnComments(ctx, config, state, log, true, {
+      const result = await scanTargetPosts(ctx, config, state, log, true, {
         forceReply: true,
-        maxReplies: 1,
-        cid,
-        mode: 'own-comments-reply-now',
+        maxPosts: 100,
+        mode: 'target-posts-reply-now',
       })
       saveState(state)
       log(`[foxy-weibo] 立即回复结束 ${JSON.stringify(result)}`)

package/lib/judge.js

@@ -125,6 +125,7 @@ function finalize(parsed, input, fallbackText) {
   if (action === 'comment' && !comment) action = 'remember'
   let replyTo = input.mayReply ? String(parsed.replyTo || '0') : '0'
   if (input.targetComment?.cid) replyTo = String(input.targetComment.cid)
+  if (input.targetPost) replyTo = '0'
   return {
     action,
     comment: comment.slice(0, 300),
@@ -139,14 +140,20 @@ export async function judgePost(config, input) {
   const persona = readFoxyPersona(config)
   const prompt = [
     '你正在浏览微博，不是回复 QQ/微信，也不是客服。',
-    '下面是一个微博账号的博文与评论。请用 Foxy 的判断，决定：',
+    input.targetPost
+      ? '下面是一条目标账号的博文。请阅读后判断是否值得在博文下发表一条评论：'
+      : '下面是一个微博账号的博文与评论。请用 Foxy 的判断，决定：',
     '- skip：广告、无意义、纯转发抽奖、引战、没信息量，跳过；',
     '- remember：有点意思，但不必公开评论，自己记一笔；',
     '- comment：值得在评论区说一句，才评论。',
     input.mayComment ? '本次允许评论。' : '本次不允许评论，只能 skip 或 remember。',
     '',
-    '评论要求：像 Foxy 自己刷到后随口说的，中文第一人称；不设最少字数，能一句说清就一句，最多 80 字；不要客服腔，不要复述原文，不要写 @。',
-    '记忆要求：如果值得记，用真实事件写第一人称，例如“我在微博看到 xx 说……，觉得……”。不要把所有事件都写成“我刷到”。不超过 180 字。',
+    input.targetPost
+      ? '评论是发在这条博文下的一级评论，不是回复某个人；不要写 @，不要假设对方在跟你对话。'
+      : '评论要求：像 Foxy 自己刷到后随口说的，中文第一人称；不设最少字数，能一句说清就一句，最多 80 字；不要客服腔，不要复述原文，不要写 @。',
+    input.targetPost
+      ? '评论要求：像一个了解对方的人看到这条博文后的自然回应；不设最少字数，能一句说清就一句，最多 80 字。'
+      : '记忆要求：如果值得记，用真实事件写第一人称，例如“我在微博看到 xx 说……，觉得……”。不要把所有事件都写成“我刷到”。不超过 180 字。',
     '',
     input.targetComment
       ? [
@@ -156,7 +163,7 @@ export async function judgePost(config, input) {
           '如果是广告、引战、辱骂、诈骗或无意义内容，输出 action=skip。',
           'replyTo 填这条评论的 cid，不要回复其他人。',
         ].join('\n')
-      : input.mayReply && input.comments.length
+      : input.mayReply && Array.isArray(input.comments) && input.comments.length
         ? [
             '回复规则：可以回复下面某条评论。replyTo 填要回复的 cid；只发一级评论时填 0。',
             '不要回复自己，不要回复广告/引战/辱骂/诈骗。',

package/lib/settings.js

@@ -8,7 +8,9 @@ export const DEFAULTS = {
   targetUid: '',
   targetUids: [],
   replyOwnPosts: true,
-  replyMode: 'off', // off | auto
+  replyMode: 'off',
+  replyAfter: '',
+  learnPosts: true,
   scheduleTimes: ['20:00'],
   intervalMinutes: 60,
   maxPostsPerRun: 5,
@@ -30,6 +32,8 @@ export const SETTING_KEYS = [
   'targetUids',
   'replyOwnPosts',
   'replyMode',
+  'replyAfter',
+  'learnPosts',
   'scheduleTimes',
   'intervalMinutes',
   'maxPostsPerRun',
@@ -46,6 +50,7 @@ export const SETTING_KEYS = [
 
 const TEXT_KEYS = new Set([
   'targetUid',
+  'replyAfter',
   'commentMode',
   'replyMode',
   'memoryPresetId',
@@ -56,6 +61,7 @@ const BOOLEAN_KEYS = new Set([
   'enabled',
   'replyOwnPosts',
   'replyOthers',
+  'learnPosts',
   'enableMemory',
   'runOnStart',
   'debug',
@@ -97,7 +103,7 @@ function clampNumber(key, value, fallback) {
   const n = Number(value)
   if (!Number.isFinite(n)) return fallback
   if (key === 'intervalMinutes') return Math.max(5, Math.min(24 * 60, Math.round(n)))
-  if (key === 'maxPostsPerRun') return Math.max(1, Math.min(20, Math.round(n)))
+  if (key === 'maxPostsPerRun') return Math.max(1, Math.min(100, Math.round(n)))
   if (key === 'maxCommentsPerDay') return Math.max(0, Math.min(10, Math.round(n)))
   return n
 }
@@ -124,6 +130,7 @@ export function normalizePatch(current = {}, patch = {}) {
   next.enabled = next.enabled === true
   next.replyOwnPosts = next.replyOwnPosts !== false
   next.replyOthers = next.replyOthers !== false
+  next.learnPosts = next.learnPosts !== false
   next.enableMemory = next.enableMemory !== false
   next.replyMode = next.replyMode === 'auto' ? 'auto' : 'off'
   next.targetUids = normalizeUids(next.targetUids)

package/lib/weibo.js

@@ -79,10 +79,41 @@ async function readJson(response) {
   }
 }
 
+export function parseWeiboTime(value, now = Date.now()) {
+  const text = String(value || '').trim()
+  if (!text) return 0
+  const current = new Date(now)
+  const at = (year, month, day, hour = 0, minute = 0) =>
+    new Date(year, month - 1, day, hour, minute).getTime()
+  let match = text.match(/^(\d+)\s*秒前/)
+  if (match) return now - Number(match[1]) * 1000
+  match = text.match(/^(\d+)\s*分钟前/)
+  if (match) return now - Number(match[1]) * 60_000
+  match = text.match(/^(\d+)\s*小时前/)
+  if (match) return now - Number(match[1]) * 3_600_000
+  if (/^刚刚/.test(text)) return now
+  match = text.match(/^今天\s*(\d{1,2}):(\d{2})/)
+  if (match) return at(current.getFullYear(), current.getMonth() + 1, current.getDate(), Number(match[1]), Number(match[2]))
+  match = text.match(/^昨天\s*(\d{1,2}):(\d{2})/)
+  if (match) {
+    const day = new Date(current.getFullYear(), current.getMonth(), current.getDate() - 1)
+    return at(day.getFullYear(), day.getMonth() + 1, day.getDate(), Number(match[1]), Number(match[2]))
+  }
+  match = text.match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:\s+(\d{1,2}):(\d{2}))?/)
+  if (match) return at(Number(match[1]), Number(match[2]), Number(match[3]), Number(match[4] || 0), Number(match[5] || 0))
+  match = text.match(/^(\d{1,2})-(\d{1,2})(?:\s+(\d{1,2}):(\d{2}))?/)
+  if (match) return at(current.getFullYear(), Number(match[1]), Number(match[2]), Number(match[3] || 0), Number(match[4] || 0))
+  match = text.match(/^(\d{1,2})月(\d{1,2})日(?:\s+(\d{1,2}):(\d{2}))?/)
+  if (match) return at(current.getFullYear(), Number(match[1]), Number(match[2]), Number(match[3] || 0), Number(match[4] || 0))
+  const parsed = Date.parse(text)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
 export function normalizePost(raw) {
   const mblog = raw?.mblog || raw || {}
   const mid = String(mblog.mid || mblog.id || mblog.mblogid || '')
   const id = String(mblog.mblogid || mid)
+  const createdAt = String(mblog.created_at || '')
   return {
     id,
     mid,
@@ -92,7 +123,8 @@ export function normalizePost(raw) {
       uid: String(mblog.user?.id || mblog.user?.idstr || ''),
       name: String(mblog.user?.screen_name || ''),
     },
-    createdAt: String(mblog.created_at || ''),
+    createdAt,
+    createdAtMs: parseWeiboTime(createdAt),
     commentsCount: Number(mblog.comments_count || 0),
     attitudesCount: Number(mblog.attitudes_count || 0),
     repostsCount: Number(mblog.reposts_count || 0),
@@ -100,11 +132,11 @@ export function normalizePost(raw) {
   }
 }
 
-async function fetchWebTimeline(uid, config = {}) {
+async function fetchWebTimeline(uid, config = {}, page = 1) {
   const target = String(uid || '').trim()
   const url =
     `https://weibo.com/ajax/statuses/mymblog?uid=${encodeURIComponent(target)}` +
-    `&page=1&feature=0`
+    `&page=${Math.max(1, page)}&feature=0`
   const response = await fetch(url, { headers: headersFor(config, false) })
   if (!response.ok) throw new WeiboError(`读取微博失败：HTTP ${response.status}`, 'HTTP')
   const text = await response.text()
@@ -122,39 +154,70 @@ async function fetchWebTimeline(uid, config = {}) {
   return list.map(normalizePost).filter((post) => post.id && post.text)
 }
 
-export async function fetchTimeline(uid, config = {}) {
+function uniquePosts(posts) {
+  const seen = new Set()
+  const out = []
+  for (const post of posts) {
+    const key = post.id || post.mid
+    if (!key || seen.has(key)) continue
+    seen.add(key)
+    out.push(post)
+  }
+  return out
+}
+
+export async function fetchTimeline(uid, config = {}, options = {}) {
   const target = String(uid || '').trim()
   if (!/^\d{5,20}$/.test(target)) throw new WeiboError('微博 UID 格式不正确', 'BAD_UID')
-  const url =
-    `https://m.weibo.cn/api/container/getIndex?type=uid&value=${encodeURIComponent(target)}` +
-    `&containerid=107603${encodeURIComponent(target)}&page=1`
-  try {
-    const response = await fetch(url, { headers: headersFor(config, true) })
-    if (!response.ok) throw new WeiboError(`读取微博失败：HTTP ${response.status}`, 'HTTP')
-    const json = await readJson(response)
-    const cards = Array.isArray(json?.data?.cards) ? json.data.cards : []
-    return cards
-      .filter((card) => card?.mblog)
-      .map((card) => normalizePost(card.mblog))
-      .filter((post) => post.id && post.text)
-  } catch (error) {
-    if (config.cookie) {
-      try {
-        return await fetchWebTimeline(target, config)
-      } catch (webError) {
-        throw new WeiboError(
-          `${error.message}；备用接口也失败：${webError.message}`,
-          'FETCH_FAILED',
-          webError.detail,
-        )
+  const maxPosts = Math.max(1, Math.min(100, Number(options.maxPosts) || 20))
+  const maxPages = Math.max(1, Math.min(20, Number(options.maxPages) || Math.ceil(maxPosts / 10) + 1))
+  const collected = []
+
+  for (let page = 1; page <= maxPages && collected.length < maxPosts; page += 1) {
+    const url =
+      `https://m.weibo.cn/api/container/getIndex?type=uid&value=${encodeURIComponent(target)}` +
+      `&containerid=107603${encodeURIComponent(target)}&page=${page}`
+    try {
+      const response = await fetch(url, { headers: headersFor(config, true) })
+      if (!response.ok) throw new WeiboError(`读取微博失败：HTTP ${response.status}`, 'HTTP')
+      const json = await readJson(response)
+      const cards = Array.isArray(json?.data?.cards) ? json.data.cards : []
+      const posts = uniquePosts(
+        cards
+          .filter((card) => card?.mblog)
+          .map((card) => normalizePost(card.mblog))
+          .filter((post) => post.id && post.text),
+      )
+      if (!posts.length) break
+      collected.push(...posts)
+      if (posts.length < 10) break
+    } catch (error) {
+      if (config.cookie) {
+        try {
+          const posts = uniquePosts(await fetchWebTimeline(target, config, page))
+          if (!posts.length) break
+          collected.push(...posts)
+          if (posts.length < 10) break
+          continue
+        } catch (webError) {
+          if (collected.length) break
+          throw new WeiboError(
+            `${error.message}；备用接口也失败：${webError.message}`,
+            'FETCH_FAILED',
+            webError.detail,
+          )
+        }
       }
+      if (collected.length) break
+      throw new WeiboError(
+        `${error.message}；微博接口可能要求登录 Cookie（设置 → Foxy-weibo → 微博 Cookie）`,
+        'LOGIN_REQUIRED',
+        error.detail,
+      )
     }
-    throw new WeiboError(
-      `${error.message}；微博接口可能要求登录 Cookie（设置 → Foxy-weibo → 微博 Cookie）`,
-      'LOGIN_REQUIRED',
-      error.detail,
-    )
   }
+
+  return uniquePosts(collected).slice(0, maxPosts)
 }
 
 function normalizeComment(raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-foxy-weibo",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Foxy's Weibo transport for DeepSeek Harness: follow users, read posts, comment, reply, and remember events.",
   "type": "module",
   "main": "lib/index.js",
@@ -48,4 +48,5 @@
     "test": "node test/test-weibo.cjs && node test/test-client.cjs"
   }
 }
-
+
+