dsh-social-trace 0.1.0 → 0.1.2

package/README.md

@@ -1,38 +1,108 @@
-# dsh-Social Trace
+# Social Trace
 
-DeepSeek Harness 的本地社交动态监控插件，支持微博和雪球。
+**把你在微博、雪球关注的博主说过的话，完整留在本地。**
 
-## 功能
+Social Trace 是 DeepSeek Harness 的本地社交动态监控插件。它按博主持续检查新动态，把正文、转发原文和配图归档到本机；有新内容时，可以通过 dsh-im 推送到 QQ / 微信。
 
-- 可视化监控流向，按平台、博主独立启停。
-- 定时检查新动态，按日期缓存历史消息，支持断点续传。
-- 按平台和博主保存正文、转发及图片，支持搜索和 Markdown / JSONL 导出。
-- 通过 dsh-im 向 QQ、微信等多个接收目标推送消息。
-- 内置版本检查；通过 npm 安装的插件支持一键更新。
+[![npm](https://img.shields.io/npm/v/dsh-social-trace.svg)](https://www.npmjs.com/package/dsh-social-trace)
+[![license](https://img.shields.io/npm/l/dsh-social-trace.svg)](LICENSE)
+
+## 为什么用它
+
+- **平台上的内容会消失。** 博主删帖、改口、设置半年可见，刷过去就找不到了。Social Trace 把看到的动态按博主留在本地，之后还能搜索、导出。
+- **不想每天手动刷主页。** 按博主设置检查频率和时间段，只在新动态出现时记录和提醒。
+- **不想把账号交给 AI。** 登录在插件自己的浏览器里完成，Cookie 不经过模型，资料库只落在本机。
+
+## 核心能力
+
+| 能力 | 说明 |
+| --- | --- |
+| 按博主监控 | 微博、雪球；每位博主独立开关、频率和时间段 |
+| 增量检查 | 定时读取新动态；关机/重启后补查期间仍可见的内容 |
+| 历史缓存 | 按日期范围回补旧动态，支持断点续传，不重复抓取 |
+| 完整留档 | 正文、转发原文、配图；按平台和博主 UID 分目录保存 |
+| 本地资料库 | SQLite + 按博主分目录的 Markdown；支持中文正文搜索 |
+| 导出 | 单博主 Markdown / JSONL，正文和来源一起带走 |
+| 可视化流向 | 博主 → 平台 → Social Trace → 资料库四层拓扑，状态、进度、异常一眼可见 |
+| dsh-im 推送 | 新动态原文推送到 QQ / 微信；支持多个接收目标；默认关闭 |
+| 本地优先 | 授权会话只存插件目录（0600），资料库不额外上传云端，不写进仓库 |
+
+## 它怎么工作
+
+1. **添加博主**：粘贴微博/雪球主页链接或数字 UID。
+2. **选择记录方式**：从现在开始，或按日期范围缓存历史消息。
+3. **交给它跑**：按设定频率检查；新内容入库后写 Markdown、下载配图；需要时通过 dsh-im 推送。
 
 ## 安装
 
-需要 DeepSeek Harness 桌面版、Google Chrome 和 Node.js 22.19 或以上。
+需要 DeepSeek Harness 桌面版、Google Chrome，以及 Node.js 22.19 或以上。
 
-在源码目录执行：
+从 npm 安装（也可以在 Harness 的插件管理里直接安装 `dsh-social-trace`）：
 
 ```sh
+dsh plugin --profile desktop add dsh-social-trace
+```
+
+也可以从源码安装：
+
+```sh
+git clone https://github.com/chiinsight/dsh-social-trace.git
+cd dsh-social-trace
 npm ci
 dsh plugin --profile desktop add .
 ```
 
-重新打开 Harness，在侧栏进入 Social Trace。
+安装后完全退出并重新打开 Harness，在侧栏打开 Social Trace。
+
+## 快速开始
+
+1. **选保存位置**：在「连接与设置」里选择资料库文件夹。
+2. **登录平台**：点「登录微博」/「登录雪球」，在独立浏览器窗口完成登录，回来点「我已登录，继续」。
+3. **添加博主**：粘贴主页或 UID，读取昵称/头像/总数，选择从现在记录或缓存历史。
+4. **调频率**：点大屏里的博主、平台或总控齿轮，设置检查频率、时间段和历史范围。
+5. **开推送（可选）**：先在 dsh-im 里连接机器人并创建接收目标，再到 Social Trace 的 dsh-im 节点添加渠道、选择博主范围、开启自动推送。
+
+## 通过 dsh-im 推送
+
+推送的是**新动态原文通知**，不是 AI 摘要：包含博主、发布时间、正文节选、转发引用和原文链接。
+
+- 默认关闭；安装、打开设置或选择目标都不会自动发送。
+- 只推送开启之后新采集的内容；历史缓存和此前已存内容不补发。
+- 支持多个接收目标（QQ、微信等），每个目标可单独开关；一个渠道失败不影响其他渠道。
+- 投递记录可查；失败或结果未知不会自动重发，避免重复打扰。
+- 机器人密钥由 dsh-im 管理，Social Trace 不重复保存。
+
+配置入口：大屏的 dsh-im 节点，或「连接与设置」里的消息推送区域。
+
+## 数据放在哪
+
+默认在 `~/.local/share/dsh-social-trace/`，也可以在设置里改到自己的文件夹。
+
+```text
+你选择的文件夹/
+  archive.sqlite       正文、任务、状态和消息
+  documents/
+    weibo/<UID>/       该博主的 Markdown 与配图
+    xueqiu/<UID>/
+```
+
+登录会话单独保存在插件目录，权限 0600，不进入仓库，也不会复制到资料文件夹。资料库不是加密数据库；需要更高保护时请把文件夹放在加密磁盘里。
 
-## 开始使用
+## 边界
 
-1. 在「连接与设置」选择信息保存位置，登录对应平台。
-2. 添加博主主页链接或 UID，选择从现在记录或缓存历史消息。
-3. 点击大屏节点齿轮，配置监控时间、频率及历史缓存范围。
-4. 如需推送，在 dsh-im 配好机器人和接收目标，再从大屏 dsh-im 节点添加渠道并开启推送。
+- 需要电脑唤醒且 Harness/插件在运行；关机期间不会采集，重开后补查仍可见的内容。
+- 已删除、被权限挡住或超出平台可见范围的内容无法补回。
+- 平台要求登录/验证时会暂停采集，处理后继续；不会绕过验证码、轮换账号或使用代理池。
+- 雪球文章只保存标题和原文链接，不保存文章正文。
+- 当前推送的是原文通知；AI 总结和 IM 内问答尚未接入。
 
-## 说明
+## 开发
 
-监控需要电脑唤醒且插件运行。重新启动后会补查期间仍可见的动态；已删除或无权访问的内容无法补存。平台要求登录或验证时会暂停采集，处理后可继续。雪球文章仅保存标题和原文链接。
+```sh
+npm ci
+npm test        # 254 项离线测试
+npm run test:ui # 5 项界面测试（需要 Chrome）
+```
 
 ## 许可
 

package/lib/client.js

@@ -101,6 +101,15 @@
   const taskProblem = job => job.kind === 'history' && /长文接口未返回全文/.test(job.message || '')
     ? '有一条长内容暂时无法完整读取，历史缓存已暂停；已保存内容保留，新动态监控不受此问题影响。'
     : (job.kind === 'history' ? '历史缓存已暂停：' : '新动态检查已暂停：') + (job.message || '读取未完成，请重试');
+  function checkHealthReason(source, uid = '') {
+    const health = source?.health;
+    if (!health) return '';
+    const delayed = health.delayed.filter(check => !uid || check.uid === uid);
+    const reasons = [];
+    if (delayed.length) reasons.push((uid ? '这位博主' : delayed.length + ' 位博主') + '未按设定频率及时检查');
+    if (health.capacityLimited) reasons.push(health.activeAuthors + ' 位博主共用账号，仅检查一轮最新页就至少需要 ' + Math.ceil(health.minimumCycleMs / 1000) + ' 秒，超出了当前频率的处理能力');
+    return reasons.join('；');
+  }
   function monitorStatus(state, platform = 'weibo', uid = '') {
     const target = state?.targets.find(item => item.uid === uid);
     const source = state?.platforms?.find(item => item.id === platform);
@@ -126,6 +135,8 @@
       return result(historyOnly ? names.length + ' 位博主的历史缓存已暂停' : names.length + ' 位博主的新动态检查需处理', jobs.some(job => job.status === 'queued') ? 'partial' : 'blocked', names.join('、') + '：' + taskProblem(problems[0]), 'tasks');
     }
     if (jobs.length && jobs.every(job => ['paused', 'complete'].includes(job.status))) return result('任务已暂停', 'paused', '在大屏开启需要执行的任务', 'tasks');
+    const healthReason = jobs.some(job => job.kind === 'updates' && job.status === 'queued') && checkHealthReason(source, uid);
+    if (healthReason) return result('检查延迟', 'partial', healthReason, 'frequency');
     const active = state.activeJobIds || [state.activeJobId];
     if (jobs.some(job => active.includes(job.id))) return result('正在读取', 'active', '新内容保存后会显示在本地档案中');
     return result(jobs.length ? '监控中' + (uid ? ' · ' + intervalText(checkInterval(state, platform, uid)) : '') : '监控就绪', 'ready', '更新按设置的检查间隔执行，历史内容分批缓存');
@@ -157,6 +168,7 @@
     if (state.enabled === false || state.platforms?.find(item => item.id === target.platform)?.enabled === false || target.enabled === false || job?.status === 'paused') return '已暂停';
     if (job.status === 'needs_review') return '需处理';
     if (!platformReady(state, target.platform || 'weibo')) return '等待连接';
+    if (kind === 'updates' && state.platforms?.find(item => item.id === (target.platform || 'weibo'))?.health?.delayed.some(check => check.uid === target.uid)) return '检查延迟';
     if (kind === 'updates' && progressFor(state, target.uid).catchup) return '补查中';
     return kind === 'history' ? '缓存中' : '监控中';
   }
@@ -494,6 +506,12 @@
           tab === 'frequency' ? h('form', { id: 'st-node-panel-frequency', role: 'tabpanel', 'aria-labelledby': embedded ? 'st-reader-tab-frequency' : 'st-node-tab-frequency', onSubmit: event => { event.preventDefault(); void run(target ? '/targets/policy' : '/settings', target ? { uid: target.uid, inherit: false, intervalMinutes: value.intervalMinutes, schedule: value.schedule } : { intervalMinutes: value.intervalMinutes, schedule: value.schedule }, '监控时间与频率已保存'); } },
             target ? h('p', { className: 'st-caption' }, target.policy ? '当前为这位博主单独设置。' : '已填入' + platformNames[context.platform] + '平台的时间；保存后只对这位博主生效。') : null,
             target ? h(TaskControl, { state, target, kind: 'updates', act, busy, openSettings: context => { setTab(context.tab || 'frequency'); } }) : null,
+            checkHealthReason(source, target?.uid) ? h('p', { className: 'st-inline-error', role: 'status' }, checkHealthReason(source, target?.uid), '。登录正常不代表每次检查都及时完成。') : null,
+            progress?.recentChecks?.length ? h('details', null, h('summary', null, '最近检查记录'), h('table', null,
+              h('thead', null, h('tr', null, ['检查时间', '接口结果', '返回的最新发布时间'].map(label => h('th', { key: label }, label)))),
+              h('tbody', null, progress.recentChecks.slice(-6).reverse().map((check, index) => h('tr', { key: index },
+                h('td', null, date(check.at)), h('td', null, check.status === 'success' ? '第 ' + check.page + ' 页 · 返回 ' + check.count + ' 条' : (check.stage === 'complete' ? '正文补全失败' : '动态列表读取失败')),
+                h('td', null, check.newestPublishedAt ? date(check.newestPublishedAt) : '—')))))) : null,
             h(FrequencyFields, { value, change: setValue, disabled: busy }),
 
             !target ? h('section', { className: 'st-independent', 'aria-label': '独立时间配置的博主' }, h('h3', null, '独立时间配置', independent.length ? ' · ' + independent.length + ' 位' : ''),

package/lib/index.js

@@ -59,7 +59,8 @@ export function createRuntime(directory = dataDirectory(), { adapterFactories =
     let worker;
     const browser = new Adapter(directory, options => worker.beforeRequest(options), () => store.account(id).uid);
     if (browser.defaults && !store.getSetting('targetDefaults:' + id, null)) store.setSetting('targetDefaults:' + id, { intervalMs: browser.defaults.intervalMs, historyGapMs: browser.defaults.historyGapMs });
-    worker = new Worker(store, browser, { documents, requestGapMs: Math.max(browser.defaults?.requestGapMs || 15000, store.getSetting(id === 'weibo' ? 'requestGapMs' : `requestGapMs:${id}`, browser.defaults?.requestGapMs || 15000)) });
+    worker = new Worker(store, browser, { documents, monitoringGapMs: id === 'weibo' ? 3000 : browser.defaults?.requestGapMs || 15000,
+      requestGapMs: Math.max(browser.defaults?.requestGapMs || 15000, store.getSetting(id === 'weibo' ? 'requestGapMs' : `requestGapMs:${id}`, browser.defaults?.requestGapMs || 15000)) });
     return [id, { browser, worker, loginBusy: false, historyBusy: false }];
   }));
   const { browser, worker } = sources.weibo;
@@ -174,6 +175,7 @@ export function createRuntime(directory = dataDirectory(), { adapterFactories =
             return { id, name: source.browser.name, enabled: store.getSetting('platformEnabled:' + id, true), schedule, targetDefaults,
               frequency: { intervalMs: intervalAt(schedule, targetDefaults.intervalMs, now), nextChangeAt: Number.isFinite(change) ? change : null,
                 nextIntervalMs: Number.isFinite(change) ? intervalAt(schedule, targetDefaults.intervalMs, change) : null },
+              health: store.monitoringHealth(id, Math.min(source.worker.requestGapMs, source.worker.monitoringGapMs)),
               requestGapMs: source.worker.requestGapMs, profileRequestAt: store.getSetting('profileRequestAt:' + id, 0), loginBusy: source.loginBusy, stopped: source.worker.stopping, lastFailure: store.getSetting('lastFailure:' + id, null) };
           }),
           targetDefaults: store.getSetting('targetDefaults', { intervalMs: 900000, historyGapMs: 60000 }),

package/lib/platforms/weibo/index.js

@@ -61,7 +61,7 @@ function browserError(error) {
   return new CaptureError('network', /closed|destroyed|disconnected/i.test(message) ? '微博采集页面已关闭或正在跳转，请重新打开登录窗口并确认连接'
     : /timeout|timed out|net::/i.test(message) ? '微博网页或接口连接超时，稍后自动重试，已保存内容不受影响'
     : /executable|browser.*not found/i.test(message) ? '找不到采集所需的 Chrome 浏览器，请检查 Chrome 是否已安装'
-    : '微博采集浏览器暂不可用，请重新打开登录窗口并确认连接');
+    : '微博接口连接失败，稍后自动重试；若持续失败，请检查网络或微博连接');
 }
 
 export class WeiboBrowser {
@@ -158,7 +158,8 @@ export class WeiboBrowser {
     let response;
     try {
       const context = await this.httpSession();
-      response = await context.get('https://weibo.com' + path, { maxRedirects: 0 });
+      response = await context.get('https://weibo.com' + path, { maxRedirects: 0,
+        ...(options?.monitoringHead ? { timeout: 10000, headers: { 'Cache-Control': 'no-cache' } } : {}) });
       let body;
       try { body = await response.json(); } catch { body = null; }
       const retry = response.headers()['retry-after'];
@@ -197,9 +198,9 @@ export class WeiboBrowser {
     return { name: user.screen_name.trim(), avatar: weiboAvatar(user), total: user.statuses_count != null && user.statuses_count !== '' && Number.isSafeInteger(Number(user.statuses_count)) && Number(user.statuses_count) >= 0 ? Number(user.statuses_count) : null };
   }
 
-  async timeline(uid, page, cursor) {
+  async timeline(uid, page, cursor, options) {
     const data = await this.request(`/ajax/statuses/mymblog?uid=${uid}&page=${page}&feature=0`
-      + (cursor ? '&since_id=' + encodeURIComponent(cursor) : ''));
+      + (cursor ? '&since_id=' + encodeURIComponent(cursor) : ''), options);
     if (!Array.isArray(data.list)) throw new CaptureError('schema', '时间线字段变化，已暂停');
     // An explicit end marker is needed: an empty page alone cannot prove completion.
     return { items: data.list, end: data.bottom_tips_visible === true || data.bottom_tips_visible === 1,

package/lib/store.js

@@ -195,13 +195,15 @@ export class Store {
     return this.decodeJob(this.db.prepare(`SELECT jobs.* FROM jobs JOIN targets ON targets.uid=jobs.uid
       WHERE jobs.status='queued' AND next_run_at<=? AND targets.platform=? AND targets.capture_mode<>'pending'
       AND NOT EXISTS (SELECT 1 FROM settings WHERE key='targetEnabled:' || targets.uid AND value='false')
-      ORDER BY CASE kind WHEN 'updates' THEN 0 ELSE 1 END,next_run_at LIMIT 1`).get(now, platform));
+      ORDER BY CASE WHEN kind='updates' AND COALESCE(json_extract(checkpoint,'$.page'),1)=1
+        AND NOT COALESCE(json_extract(checkpoint,'$.pageLoaded'),0) THEN 0 WHEN kind='updates' THEN 1 ELSE 2 END,next_run_at LIMIT 1`).get(now, platform));
   }
 
-  nextJobAt(platform, kind = '') {
+  nextJobAt(platform, kind = '', headOnly = false) {
     return this.db.prepare(`SELECT MIN(next_run_at) AS due FROM jobs JOIN targets ON targets.uid=jobs.uid
       WHERE jobs.status='queued' AND targets.platform=? AND targets.capture_mode<>'pending' AND (?='' OR jobs.kind=?)
-      AND NOT EXISTS (SELECT 1 FROM settings WHERE key='targetEnabled:' || targets.uid AND value='false')`).get(platform, kind, kind).due;
+      AND (?=0 OR COALESCE(json_extract(checkpoint,'$.page'),1)=1 AND NOT COALESCE(json_extract(checkpoint,'$.pageLoaded'),0))
+      AND NOT EXISTS (SELECT 1 FROM settings WHERE key='targetEnabled:' || targets.uid AND value='false')`).get(platform, kind, kind, Number(headOnly)).due;
   }
 
   updateJob(id, patch, now = Date.now()) {
@@ -320,6 +322,21 @@ export class Store {
     return this.getSetting('targetPolicy:' + target.uid, null) || { intervalMs: target.interval_ms, schedule: this.getSetting('schedule:' + target.platform, null) };
   }
 
+  monitoringHealth(platform, requestGapMs, now = Date.now()) {
+    const targets = new Map(this.targets().filter(target => target.platform === platform && target.capture_mode !== 'pending'
+      && this.monitoringEnabled(platform, target.uid)).map(target => [target.uid, target]));
+    const checks = this.jobs().filter(job => job.kind === 'updates' && job.status === 'queued' && targets.has(job.uid)).map(job => {
+      const policy = this.monitoringPolicy(targets.get(job.uid));
+      const intervalMs = intervalAt(policy.schedule, policy.intervalMs, now);
+      const lastCheckedAt = job.checkpoint.lastScanAt || job.last_success_at || null;
+      const dueAt = lastCheckedAt ? lastCheckedAt + intervalMs : job.next_run_at;
+      return { uid: job.uid, intervalMs, lastCheckedAt, lateMs: Math.max(0, now - dueAt) };
+    });
+    return { activeAuthors: checks.length, minimumCycleMs: checks.length * requestGapMs,
+      capacityLimited: checks.reduce((load, check) => load + requestGapMs / check.intervalMs, 0) > 1.001,
+      delayed: checks.filter(check => check.lateMs > Math.max(2 * requestGapMs, 5000)) };
+  }
+
   targetProgress(now = Date.now()) {
     const jobs = this.jobs(), summaries = this.archiveSummary();
     return this.targets().map(target => {
@@ -334,6 +351,7 @@ export class Store {
       const canCheck = updates?.status === 'queued' && this.monitoringEnabled(target.platform, target.uid) && account?.status === 'ready';
       return { uid: target.uid, catchup: updates?.checkpoint.catchupFrom != null ? { from: updates.checkpoint.catchupFrom, page: updates.checkpoint.page || 1, saved: Math.max(0, updates.saved - (updates.checkpoint.catchupSaved || 0)) } : null, intervalMs: intervalAt(policy.schedule, policy.intervalMs, now), nextChangeAt: Number.isFinite(policyChange) ? policyChange : null, nextIntervalMs: Number.isFinite(policyChange) ? intervalAt(policy.schedule, policy.intervalMs, policyChange) : null, saved, originals: summary?.original_count || 0, reposts: summary?.repost_count || 0, lastSavedAt: summary?.last_saved_at || null,
         lastCheckedAt: updates?.last_success_at || null,
+        recentChecks: this.getSetting('checkHistory:' + target.uid, []),
         nextCheckAt: canCheck ? Math.max(now, updates.next_run_at, account.next_request_at, account.cooldown_until) : null,
         history: { from: target.history_from, to: target.history_to, originalOnly, rangeBounded: target.history_from !== null || target.history_to !== null, rangeComplete: !!history?.checkpoint.rangeComplete,
           rangeSaved: target.history_from === null && target.history_to === null && !originalOnly ? saved : this.db.prepare('SELECT COUNT(*) AS n FROM posts WHERE uid=? AND published_at>=? AND published_at<=? AND (?=0 OR quote IS NULL)').get(target.uid, target.history_from ?? 0, target.history_to ?? Number.MAX_SAFE_INTEGER, Number(originalOnly)).n, id: history?.id, status: history?.status || 'not_started',

package/lib/worker.js

@@ -3,7 +3,7 @@ import { alignedCheckAt, intervalAt, nextBoundary } from './schedule.js';
 import { CaptureError } from './capture-error.js';
 
 export class Worker {
-  constructor(store, adapter, { now = Date.now, requestGapMs = 15000, documents = null } = {}) {
+  constructor(store, adapter, { now = Date.now, requestGapMs = 15000, monitoringGapMs = requestGapMs, documents = null } = {}) {
     this.store = store;
     this.adapter = adapter;
     this.documents = documents;
@@ -12,6 +12,7 @@ export class Worker {
     this.leaseKey = this.platform === 'weibo' ? 'worker' : 'worker:' + this.platform;
     this.now = now;
     this.requestGapMs = requestGapMs;
+    this.monitoringGapMs = monitoringGapMs;
     this.busy = null;
     this.currentJobId = null;
     this.stopping = false;
@@ -20,6 +21,8 @@ export class Worker {
     this.running = false;
     this.claimAfter = 0;
     this.boundaryAt = 0;
+    this.lastTickAt = null;
+    this.resumeCheckPending = false;
   }
 
   claim() {
@@ -62,9 +65,9 @@ export class Worker {
 
   pickJob() {
     const job = this.store.dueJob(this.now(), this.platform);
-    if (job?.kind === 'history' && !this.localStep(job)) {
-      const updateAt = this.store.nextJobAt(this.platform, 'updates');
-      if (updateAt > this.now() && updateAt <= this.now() + this.requestGapMs) return { wait: updateAt };
+    if (job && (job.kind === 'history' || job.checkpoint.pageLoaded || job.checkpoint.page > 1) && !this.localStep(job)) {
+      const updateAt = this.store.nextJobAt(this.platform, 'updates', true);
+      if (updateAt > this.now() && updateAt <= this.now() + Math.min(this.requestGapMs, this.monitoringGapMs)) return { wait: updateAt };
     }
     return { job };
   }
@@ -110,25 +113,36 @@ export class Worker {
     if (this.running && !this.stopping) return;
     this.claim();
     this.prepareRestartChecks();
+    this.lastTickAt = this.now();
+    this.resumeCheckPending = false;
     this.running = true;
     this.rescheduleUpdates();
     this.wake();
   }
 
-  async beforeRequest({ profileOnly = false, interactiveProfile = false, verifying = false } = {}) {
+  async beforeRequest({ profileOnly = false, interactiveProfile = false, verifying = false, monitoringHead = false } = {}) {
     const account = this.store.account(this.platform);
     const job = this.currentJobId ? this.store.job(this.currentJobId) : null;
     if (this.stopping || (verifying ? false : profileOnly ? !['ready', 'paused'].includes(account.status) : !this.store.monitoringEnabled(this.platform, job?.uid) || (job && job.status !== 'queued') || account.status !== 'ready')) throw new CaptureError('stopped', '账号已暂停');
     const interactive = profileOnly && interactiveProfile;
     const profileKey = 'profileRequestAt:' + this.platform;
-    const remaining = Math.max(interactive ? this.store.getSetting(profileKey, 0) : account.next_request_at, account.cooldown_until) - this.now();
+    const auxiliary = !monitoringHead && !interactive && !verifying;
+    const auxiliaryKey = 'auxiliaryRequestAt:' + this.platform;
+    const remaining = Math.max(interactive ? this.store.getSetting(profileKey, 0) : account.next_request_at,
+      auxiliary ? this.store.getSetting(auxiliaryKey, 0) : 0, account.cooldown_until) - this.now();
     if (remaining > 0) throw new CaptureError('wait', '等待下一次请求时间', remaining);
     if (interactive) this.store.setSetting(profileKey, this.now() + this.requestGapMs);
-    this.store.setAccount({ next_request_at: Math.max(account.next_request_at, this.now() + this.requestGapMs) }, this.platform);
+    if (auxiliary) this.store.setSetting(auxiliaryKey, this.now() + this.requestGapMs);
+    const gap = Math.min(this.requestGapMs, this.monitoringGapMs);
+    this.store.setAccount({ next_request_at: Math.max(account.next_request_at, this.now() + gap) }, this.platform);
   }
 
   async tick() {
     if (this.stopping || this.suspended || this.busy) return;
+    if (this.running) {
+      if (this.lastTickAt !== null && this.now() - this.lastTickAt > 120000) this.resumeCheckPending = true;
+      this.lastTickAt = this.now();
+    }
     const account = this.store.account(this.platform);
     if (!this.store.monitoringEnabled(this.platform) || account.status !== 'ready' || account.cooldown_until > this.now()) return;
     try { if (this.now() >= this.claimAfter) this.claim(); } catch (error) {
@@ -137,6 +151,10 @@ export class Worker {
       clearTimeout(this.timer);
       throw error;
     }
+    if (this.resumeCheckPending) {
+      this.prepareRestartChecks();
+      this.resumeCheckPending = false;
+    }
     if (this.now() >= this.boundaryAt) this.rescheduleUpdates();
     const { job } = this.pickJob();
     if (!job) return;
@@ -210,7 +228,7 @@ export class Worker {
       return;
     }
     const page = checkpoint.page || 1;
-    const result = await this.adapter.timeline(target.external_uid || job.uid, page, checkpoint.cursor);
+    const result = await this.adapter.timeline(target.external_uid || job.uid, page, checkpoint.cursor, { monitoringHead: job.kind === 'updates' && page === 1 });
     this.requestSucceeded();
     if (!this.canRun(job)) return;
     const detectedAt = this.now();
@@ -218,6 +236,7 @@ export class Worker {
     const pending = [];
     const unpinnedDates = [];
     let foundKnown = false;
+    let reachedBoundary = false;
     const firstPageIds = page === 1 ? [] : checkpoint.firstPageIds || [];
     for (const raw of result.items) {
       const post = this.normalizePost(raw, target);
@@ -229,20 +248,24 @@ export class Worker {
       if (!this.adapter.isPinned(raw)) {
         if (page === 1) firstPageIds.push(post.id);
         if (job.kind === 'history' && known) foundKnown = true;
+        if (checkpoint.boundaryIds?.includes(post.id) && post.publishedAt < scanFrom) reachedBoundary = true;
       }
       if (inRange(post)) {
         if (!this.store.hasCompletePost(post.id)) pending.push(raw);
         else if (job.kind === 'updates') this.store.observeUpdate(post.id, this.now());
       }
     }
-    // A known ID may come from history; only an older non-pinned page closes the time gap.
-    if (job.kind === 'updates') foundKnown = unpinnedDates.length > 0 && unpinnedDates.every(at => at < scanFrom);
+    // Only the previous update head is a baseline; arbitrary history IDs and pinned posts are not.
+    if (job.kind === 'updates') foundKnown = unpinnedDates.length > 0 && (unpinnedDates.every(at => at < scanFrom)
+      || checkpoint.catchupFrom == null && reachedBoundary);
     if (ids.length && JSON.stringify(ids) === JSON.stringify(checkpoint.lastPageIds)) {
       throw new CaptureError('schema', '平台重复返回上一页，已暂停，避免循环请求');
     }
     if (!ids.length && !result.end) {
       throw new CaptureError('schema', '平台返回空页且没有明确末尾说明，已暂停待检查');
     }
+    if (job.kind === 'updates') this.recordCheck(job.uid, { at: detectedAt, page, stage: 'timeline', status: 'success', count: ids.length,
+      newestPublishedAt: unpinnedDates.length ? Math.max(...unpinnedDates) : null });
     this.store.updateJob(job.id, {
       checkpoint: { ...checkpoint, scanFrom, pending, page, pageLoaded: true, lastPageIds: ids, detectedAt,
         firstPageIds, lastScanAt: page === 1 ? this.now() : checkpoint.lastScanAt, retryAt: 0,
@@ -294,6 +317,11 @@ export class Worker {
     if (account.status === 'ready' && (account.errors || account.reason)) this.store.setAccount({ errors: 0, reason: '' }, this.platform);
   }
 
+  recordCheck(uid, check) {
+    const key = 'checkHistory:' + uid;
+    this.store.setSetting(key, [...this.store.getSetting(key, []), check].slice(-32));
+  }
+
   failAccount(error) {
     const account = this.store.account(this.platform);
     let message = error.message;
@@ -318,6 +346,8 @@ export class Worker {
     }
     let message = error.kind && typeof error.message === 'string' ? error.message : '处理采集数据时发生内部错误，已暂停此任务并保留断点';
     this.store.setSetting('lastFailure:' + this.platform, { uid: job.uid, kind, at: this.now(), message, code: error.kind ? null : String(error.name || 'Error') });
+    if (job.kind === 'updates') this.recordCheck(job.uid, { at: this.now(), page: job.checkpoint.page || 1,
+      stage: job.checkpoint.pending?.length ? 'complete' : 'timeline', status: kind });
     if (kind === 'limited' || kind === 'network') {
       message = this.failAccount(error);
       const retryAt = this.store.account(this.platform).cooldown_until;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-social-trace",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Social Trace：微博与雪球增量监控、可视化拓扑、历史缓存与本地检索",
   "type": "module",
   "license": "MIT",