dsh-baleen 0.1.1 → 0.2.0

package/lib/jobs.js

@@ -58,7 +58,11 @@ export function planJobs({ db, now = Date.now, force = false }) {
       // yt 是 flat 列表 + 每条两次 yt-dlp（dump-single-json + 字幕轨落盘，一条 ≈2-6s）。
       // 通用 20s 在真机 run 17 上跑不完（run_end 之后适配器还在打 detail——孤儿调用）。
       // 更宽的预算配 pool 的"超时即 abort"：真超了也断得干净，不白烧配额不顶风控。
+      // xhs 同理（冒烟实证：search_feeds 冷启动会顶到工具内部 60s 限时）；再叠
+      // spawn 等待 + 登录探测 + 详情批（并发 2），90s/180s 真机两轮实证都不够
+      // （12 条详情装不下），预算放宽到 300s 并把每轮详情上限降到 6（分批续传）。
       if (s.type === 'bili' || s.type === 'yt') job.timeout_ms = 90000
+      if (s.type === 'xhs') job.timeout_ms = 300000
       return job
     })
 }

package/lib/mcp/xhs-client.js

@@ -0,0 +1,206 @@
+import { spawn } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import net from 'node:net'
+import fs from 'node:fs'
+import path from 'node:path'
+import { homeDir } from '../paths.js'
+
+/**
+ * xhs-client —— 小红书 MCP（xiaohongshu-mcp 官方 exe）的 HTTP 客户端 + 子进程生命周期。
+ *
+ * 选型与边界见 docs/v3-xhs-mcp-audit.md（V3）与 docs/superpowers/plans/2026-11-01-baleen-m6-xhs.md：
+ *  - 只读白名单：9 个只读工具之外的名字在这里就被拒掉，零 HTTP 往返——写平台动作
+ *    （发布/点赞/收藏/评论，共 8 个）永远不从 baleen 调用，也永远不进 agent 工具面（红线）；
+ *  - 子进程由 baleen 拉起：回环绑定 + 每 boot 随机 token（spawn 侧与 HTTP 侧同源，
+ *    不落盘不进日志）；cookie 收敛在 <home>/credentials/xhs-cookies.json（凭据只落本机）；
+ *  - 惰性 spawn：配了 xhs 源才会拉子进程；首次运行官方 exe 会先下载内置浏览器
+ *    （约 140-190MB，带 SHA256 校验），那一轮的源请求会按 mcp_unready 失败，下一轮自然恢复。
+ */
+
+/** 只读工具白名单（V3 审查清单逐字）。工具面对 agent 仍恰好六个，这里是摄取内部面。 */
+export const XHS_READ_TOOLS = new Set([
+  'check_login_status', 'get_login_qrcode', 'get_feed_detail', 'get_unread_count',
+  'list_feeds', 'list_notifications', 'search_feeds', 'user_profile', 'get_my_profile'
+])
+
+/** 端口就绪探测预算：浏览器已缓存时秒级；首次下载内置浏览器的那一轮等不到，如实报 mcp_unready。 */
+const READY_TIMEOUT_MS = 20000
+const READY_POLL_MS = 300
+
+function fail(message, props = {}) {
+  return Object.assign(new Error(message), props)
+}
+
+let active = null // { key, baseUrl, token, port, child, client }
+
+/** 供测试与 baleen 的 ctx.effect 清理用。 */
+export function stopXhsMcp() {
+  if (active?.child) {
+    try { active.child.kill() } catch { /* 已死即成功 */ }
+  }
+  active = null
+}
+
+/**
+ * 取（必要时拉起）小红书 MCP 的 HTTP 客户端。幂等：同一份 (exePath, port) 配置复用
+ * 已在跑的实例；配置变了才重启。mcp_path 空 / exe 不存在 → mcp_missing。
+ */
+export async function getXhsMcp(pref, log = () => {}) {
+  const cfg = pref?.xhs
+  if (!cfg?.mcp_path || !String(cfg.mcp_path).trim()) {
+    throw fail('xhs.mcp_path 未配置——小红书通道不启用（要启用就填官方 exe 路径）', { error_class: 'mcp_missing' })
+  }
+  const exePath = String(cfg.mcp_path).trim()
+  if (!fs.existsSync(exePath)) {
+    throw fail(`xhs MCP exe 不存在: ${exePath}`, { error_class: 'mcp_missing' })
+  }
+  const port = Number.isInteger(cfg.port) && cfg.port > 0 ? cfg.port : 18060
+  const key = `${exePath}|${port}`
+  if (active?.key === key && active.listening) return active.client
+
+  stopXhsMcp()
+  const token = randomBytes(24).toString('hex')
+  const cookiesPath = path.join(homeDir(), 'credentials', 'xhs-cookies.json')
+  fs.mkdirSync(path.dirname(cookiesPath), { recursive: true })
+
+  const child = spawn(exePath, ['-port', `127.0.0.1:${port}`, '-token', token], {
+    cwd: path.dirname(cookiesPath),
+    env: { ...process.env, AUTH_TOKEN: token, COOKIES_PATH: cookiesPath },
+    stdio: 'ignore'
+  })
+  const record = { key, baseUrl: `http://127.0.0.1:${port}`, token, port, child, listening: false, client: null }
+  active = record
+
+  await waitListening(port, READY_TIMEOUT_MS)
+  record.listening = true
+  record.client = makeClient(record, log)
+  log('xhs_mcp_up', `小红书 MCP 已就绪（127.0.0.1:${port}）`)
+  return record.client
+}
+
+/** 供 ctx.effect 注册清理；没拉起过就是空操作。 */
+export function xhsMcpRunning() {
+  return Boolean(active?.child)
+}
+
+function waitListening(port, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs
+    const tryOnce = () => {
+      const socket = net.connect(port, '127.0.0.1')
+      socket.once('connect', () => { socket.destroy(); resolve() })
+      socket.once('error', () => {
+        socket.destroy()
+        if (Date.now() > deadline) {
+          reject(fail(`xhs MCP 在 ${timeoutMs}ms 内没监听上 127.0.0.1:${port}——若是首次运行，多半还在下载内置浏览器（约 140-190MB），下一轮自然恢复`, { error_class: 'mcp_unready' }))
+        } else {
+          setTimeout(tryOnce, READY_POLL_MS)
+        }
+      })
+    }
+    tryOnce()
+  })
+}
+
+/** 单个 MCP 客户端实例：会话惰性建立、404 过期自动重初始化一次。 */
+function makeClient(record, log = () => {}) {
+  let sessionId = null
+  let rpcId = 0
+
+  const headers = () => ({
+    'Content-Type': 'application/json',
+    Accept: 'application/json, text/event-stream',
+    Authorization: 'Bearer ' + record.token,
+    ...(sessionId ? { 'Mcp-Session-Id': sessionId } : {})
+  })
+
+  async function rpc(method, params, isNotification = false) {
+    const body = { jsonrpc: '2.0', method, ...(params ? { params } : {}), ...(isNotification ? {} : { id: ++rpcId }) }
+    const res = await fetch(record.baseUrl + '/mcp', { method: 'POST', headers: headers(), body: JSON.stringify(body), signal: params?.signal })
+    const sid = res.headers.get('mcp-session-id')
+    if (sid && !sessionId) sessionId = sid
+    const ct = res.headers.get('content-type') || ''
+    let payload = null
+    if (ct.includes('event-stream')) {
+      const text = await res.text()
+      const dataLines = text.split('\n').filter((l) => l.startsWith('data:')).map((l) => l.slice(5).trim())
+      payload = dataLines.length ? JSON.parse(dataLines[dataLines.length - 1]) : null
+    } else {
+      const text = await res.text()
+      payload = text ? JSON.parse(text) : null
+    }
+    return { res, payload }
+  }
+
+  async function ensureSession() {
+    const { res } = await rpc('initialize', {
+      protocolVersion: '2025-03-26', capabilities: {},
+      clientInfo: { name: 'baleen-xhs', version: '0.1.0' }
+    })
+    if (res.status !== 200) throw fail(`xhs MCP initialize HTTP ${res.status}`, { error_class: 'mcp_unready' })
+    await rpc('notifications/initialized', undefined, true)
+  }
+
+  /**
+   * 调一个只读工具，返回 { texts: string[], images: [] }。白名单外的名字在这里
+   * 就地拒绝（零 HTTP 往返）——写平台动作从结构上进不了调用链。
+   */
+  async function callTool(name, args = {}) {
+    if (!XHS_READ_TOOLS.has(name)) {
+      throw fail(`工具 "${name}" 不在小红书只读白名单里——baleen 对写平台动作零调用`, { error_class: 'xhs_tool_forbidden' })
+    }
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (!sessionId) await ensureSession()
+      const { res, payload } = await rpc('tools/call', { name, arguments: args })
+      if (res.status === 404 || (payload?.error && /session/i.test(payload.error.message || ''))) {
+        sessionId = null // 会话过期：重初始化一次再试
+        continue
+      }
+      if (res.status === 401) throw fail('xhs MCP 鉴权被拒——token 与子进程不同源，属内部错误', { error_class: 'mcp_unready' })
+      if (payload?.error) throw fail(`xhs MCP ${name}: ${payload.error.message ?? '未知错误'}`, { error_class: 'xhs_tool_error' })
+      const content = payload?.result?.content ?? []
+      return {
+        texts: content.filter((x) => x.type === 'text').map((x) => x.text),
+        images: content.filter((x) => x.type === 'image')
+      }
+    }
+    throw fail('xhs MCP 会话两次初始化都失败', { error_class: 'mcp_unready' })
+  }
+
+  /** check_login_status 的结构化视图：{ loggedIn, username?, raw }。 */
+  async function checkLoginStatus() {
+    const { texts } = await callTool('check_login_status')
+    const text = texts.join('\n')
+    const loggedIn = /✅\s*已登录/.test(text)
+    const name = loggedIn ? (/用户名:\s*(.+)/.exec(text)?.[1]?.trim() ?? '') : ''
+    return { loggedIn, username: name, raw: text }
+  }
+
+  /** search_feeds：返回解析后的 { feeds: [...] }（工具以 JSON 文本回内容）。 */
+  async function searchFeeds(keyword) {
+    const { texts } = await callTool('search_feeds', { keyword })
+    return parseJsonTool(texts, 'search_feeds')
+  }
+
+  /** get_feed_detail：返回解析后的笔记详情 JSON。 */
+  async function getFeedDetail(noteId, xsecToken) {
+    const { texts } = await callTool('get_feed_detail', { feed_id: noteId, xsec_token: xsecToken })
+    return parseJsonTool(texts, 'get_feed_detail')
+  }
+
+  return { callTool, checkLoginStatus, searchFeeds, getFeedDetail }
+}
+
+/** 供测试打桩：对固定 baseUrl/token 的裸 HTTP 客户端（不经 spawn、不碰磁盘）。 */
+export function createXhsHttpClient(baseUrl, token, log = () => {}) {
+  return makeClient({ baseUrl, token }, log)
+}
+
+/** 工具把 JSON 以 text 形态回（搜索/详情都这样），这里统一解析；坏 JSON 如实抛。 */
+function parseJsonTool(texts, tool) {
+  const text = texts.join('\n').trim()
+  if (!text) throw fail(`xhs MCP ${tool} 返回空内容`, { error_class: 'xhs_tool_error' })
+  try { return JSON.parse(text) } catch (e) {
+    throw fail(`xhs MCP ${tool} 返回的不是 JSON: ${text.slice(0, 80)}`, { error_class: 'xhs_tool_error', parse: true })
+  }
+}

package/lib/normalize.js

@@ -33,6 +33,8 @@ function kwHit(hayLower, hayRaw, kw) {
  * missing（无语音）与 burned_in（字烧在画面上）绝不能合成一个值。
  */
 export function inferBodyState(raw) {
+  // 现取到的正文优先：它就是"全文"，不必再去比摘要长度
+  if (raw.fulltext_text) return 'full'
   if (raw.subtitle_text) return 'subtitle'
   if (raw.transcribed_text) return 'transcribed'
   const full = stripTags(raw.body_html)
@@ -86,7 +88,7 @@ export function matchThemes(text, pref) {
  * 输出可直接插库：判断与预筛需要的额外信息都塞在 match_json 里，不污染列。
  */
 export function normalize(raw, source, pref, now = Date.now) {
-  const haystack = [raw.title, (raw.tags ?? []).join(' '), stripTags(raw.body_html ?? ''), stripTags(raw.summary_html ?? '')]
+  const haystack = [raw.title, (raw.tags ?? []).join(' '), stripTags(raw.fulltext_text ?? ''), stripTags(raw.body_html ?? ''), stripTags(raw.summary_html ?? '')]
     .filter(Boolean).join('\n')
   const m = matchThemes(haystack, pref)
   const srcWeight = Number.isFinite(source?.weight) ? source.weight : 1
@@ -94,7 +96,7 @@ export function normalize(raw, source, pref, now = Date.now) {
   const srcUrl = cleanUrl(source?.url)
   const followed = !!srcUrl && (pref?.follow?.feeds ?? []).some(f => cleanUrl(f) === srcUrl)
   const score_follow = followed ? 0.6 : 0
-  const bodyText = stripTags(raw.body_html ?? raw.summary_html ?? '')
+  const bodyText = stripTags(raw.fulltext_text ?? raw.body_html ?? raw.summary_html ?? '')
 
   return {
     source_id: raw.source_id,

package/lib/preference.js

@@ -7,7 +7,7 @@ const FILE = 'preference.yaml'
 /** 模板与 writePreference 共用的文件头注释：写回时没有用户注释就带这句 */
 const FILE_HEADER = '# 改这里：themes / follow / sources 是你的，tuning 只由面板那两个按钮写。\n'
 const CLAMP = 0.5
-const KNOWN_TYPES = ['rss', 'bili', 'yt']   // xhs 由后续计划登记进来
+const KNOWN_TYPES = ['rss', 'bili', 'yt', 'xhs']   // xhs：M6 起接入，源主键是搜索关键词（query）
 const WINDOW_RE = /^([01]\d|2[0-3]):[0-5]\d-([01]\d|2[0-3]):[0-5]\d$/
 
 export const DEFAULTS = {
@@ -19,11 +19,15 @@ export const DEFAULTS = {
   limits: { max_age_days: 14, min_duration_sec: 90, skip_kinds: [] },
   require_theme_hit: true,
   inject_prompt: true,
+  sidebar_takeover: true,    // 会话里点 B 站/YouTube 链接是否落进侧栏播放 tab（M7）
+  sidebar_crop: true,        // 侧栏播 B 站时裁掉完整页自带的相关推荐（M7）
+  fulltext: true,            // RSS 只给摘要时去抓原文正文（抽不到就退回摘要，不覆盖已有内容）
   tuning: { source_delta: {} },
   redlines: ['广告代理', '引流私聊', '付费课程推销'],
   charter: '',
   yt_dlp_path: 'yt-dlp',       // yt 源（M4b）的 yt-dlp 可执行名/路径，缺省走 PATH
-  network: { proxy: '' }       // 只传给 yt-dlp 的 --proxy，不动全局 fetch；空 = 不走代理
+  network: { proxy: '' },      // 只传给 yt-dlp 的 --proxy，不动全局 fetch；空 = 不走代理
+  xhs: { mcp_path: '', port: 18060 }  // 小红书 MCP（M6）：官方 exe 路径，空 = 通道不启用；token 每 boot 随机生成不落盘
 }
 
 export function prefFile(dir = homeDir()) {
@@ -205,6 +209,7 @@ export function validate(obj) {
       if (s.type === 'rss' && (!str(s.url) || !/^https?:\/\//i.test(s.url))) errs.push(`sources[${i}].url: rss 源必须是 http(s) URL`)
       if (s.type === 'bili' && (!str(s.url) || !s.url.trim())) errs.push(`sources[${i}].url: bili 源要填 UP 主 space URL（space.bilibili.com/<uid>）`)
       if (s.type === 'yt' && (!str(s.url) || !/^https?:\/\//i.test(s.url))) errs.push(`sources[${i}].url: yt 源必须是 http(s) URL（频道 /videos、playlist 或单视频）`)
+      if (s.type === 'xhs' && (!str(s.url) || !/^https?:\/\//i.test(s.url))) errs.push(`sources[${i}].url: xhs 源要填搜索 URL（xiaohongshu.com/search?query=…）——sources 表只回传 url，关键词从它的 query 参数派生`)
       if (s.enabled !== undefined && typeof s.enabled !== 'boolean') errs.push(`sources[${i}].enabled: 必须是布尔`)
       if (s.interval_min !== undefined && !(Number.isInteger(s.interval_min) && s.interval_min >= 15)) errs.push(`sources[${i}].interval_min: ≥15 的整数`)
       if (s.weight !== undefined && !(finite(s.weight) && s.weight >= 0 && s.weight <= 2)) errs.push(`sources[${i}].weight: 0–2`)
@@ -237,6 +242,13 @@ export function validate(obj) {
   }
 
   if (obj.yt_dlp_path !== undefined && !str(obj.yt_dlp_path)) errs.push('yt_dlp_path: 必须是字符串（yt-dlp 可执行名或绝对路径，缺省 yt-dlp 走 PATH）')
+  if (obj.xhs !== undefined) {
+    if (!obj.xhs || typeof obj.xhs !== 'object' || isArr(obj.xhs)) errs.push('xhs: 必须是映射')
+    else {
+      if (obj.xhs.mcp_path !== undefined && !str(obj.xhs.mcp_path)) errs.push('xhs.mcp_path: 必须是字符串（空 = 通道不启用）')
+      if (obj.xhs.port !== undefined && !(Number.isInteger(obj.xhs.port) && obj.xhs.port > 0 && obj.xhs.port < 65536)) errs.push('xhs.port: 1-65535 的整数')
+    }
+  }
   if (obj.network !== undefined) {
     if (!obj.network || typeof obj.network !== 'object' || isArr(obj.network)) errs.push('network: 必须是映射')
     else if (obj.network.proxy !== undefined && !str(obj.network.proxy)) errs.push('network.proxy: 必须是字符串（空 = 不走代理；只传给 yt-dlp 的 --proxy，不动全局 fetch）')
@@ -248,6 +260,15 @@ export function validate(obj) {
   if (obj.inject_prompt !== undefined && typeof obj.inject_prompt !== 'boolean') {
     errs.push('inject_prompt: 必须是布尔')
   }
+  if (obj.sidebar_takeover !== undefined && typeof obj.sidebar_takeover !== 'boolean') {
+    errs.push('sidebar_takeover: 必须是布尔')
+  }
+  if (obj.sidebar_crop !== undefined && typeof obj.sidebar_crop !== 'boolean') {
+    errs.push('sidebar_crop: 必须是布尔')
+  }
+  if (obj.fulltext !== undefined && typeof obj.fulltext !== 'boolean') {
+    errs.push('fulltext: 必须是布尔')
+  }
   if (obj.redlines !== undefined && (!isArr(obj.redlines) || obj.redlines.some(s => !str(s)))) errs.push('redlines: 必须是字符串数组')
 
   if (obj.tuning?.source_delta !== undefined) {

package/lib/runner.js

@@ -4,10 +4,18 @@ import { normalize } from './normalize.js'
 import { putDraft } from './dedup.js'
 import { gate, summarizeGaps } from './prefilter.js'
 import { planJobs, syncSources } from './jobs.js'
-import { createRun, finishRun, setCursor, setSourceResult, setStatus, isCollected, knownExternalIds, listSources } from './store.js'
+import {
+  createRun, finishRun, setCursor, setSourceResult, setStatus, isCollected, knownExternalIds,
+  listSources, fulltextCandidates, refreshItem, getMeta, setMeta
+} from './store.js'
 
 export { planJobs, syncSources }
 
+/** 每轮最多补抓几条正文。故意小：这是"顺手把摘要补全"，不是另一个抓取系统。 */
+const FULLTEXT_PER_RUN = 8
+/** 同一条失败这么多次就不再试了——付费墙/需要登录的站重试一万次也不会开门。 */
+const FULLTEXT_MAX_TRIES = 2
+
 /**
  * 一轮摄取：计划 → 抓取 → 归一 → 去重 → 预筛 → 记账。
  * 不做判断（那是 M3 的 headless 会话），不碰网络细节（那是适配器），不改偏好。
@@ -16,7 +24,13 @@ export { planJobs, syncSources }
  *  1. **失败不推进游标**：只有成功的源才 setCursor，失败源下一轮自动补上缺口。
  *  2. **丢弃必须留痕**：预筛丢弃与"带标记保留"都进 stats.gaps，汇报区靠它写诚实的那一行。
  */
-export async function runOnce({ db, pref, now = Date.now, log = () => {}, fetchImpl, adapters, trigger = 'schedule', force = false } = {}) {
+export async function runOnce({
+  db, pref, now = Date.now, log = () => {}, fetchImpl, adapters, trigger = 'schedule', force = false,
+  // 正文补抓的实现（lib/fulltext.js 的 fetchFulltext）。刻意做成注入口而不是直接 import：
+  // ① 测试要能断言"没有实现就一条网络请求都不发"；② 宿主那边才有权决定用哪个 fetch。
+  // 不传 = 这一轮不补抓（29 处既有测试用例都不传，天然不受影响）。
+  fetchFulltextImpl = null
+} = {}) {
   const at = now()
 
   syncSources(db, pref)
@@ -129,6 +143,43 @@ export async function runOnce({ db, pref, now = Date.now, log = () => {}, fetchI
     emit('info', 'source_ok', `抓 ${local.fetched} → 候选 ${local.candidates}（丢弃 ${local.archived}）`, id)
   }
 
+  // 正文补抓（M8）：RSS 只搬 feed 的摘要，正文得回原文去抓。放在源循环之后、记账之前——
+  // 这样同一轮里"抓完正文的条目"直接进候选，面板上点开就是全文而不是一句话。
+  // 三条硬规矩：① 不注入实现就不抓（测试与默认路径零网络副作用）；② 只补 status='new'
+  // 且 kind='article' 的（判过的不必改正文，视频的正文是字幕、不该去爬播放页）；
+  // ③ 同一条失败满 2 次就记进 meta 不再试——付费墙不会因为我们坚持而打开。
+  if (pref?.fulltext !== false && typeof fetchFulltextImpl === 'function') {
+    const tried = fulltextCandidates(db, FULLTEXT_PER_RUN * 5)
+      .filter((it) => Number(getMeta(db, `fulltext:fail:${it.id}`) ?? 0) < FULLTEXT_MAX_TRIES)
+      .slice(0, FULLTEXT_PER_RUN)
+    stats.fulltext = { tried: tried.length, ok: 0, failed: 0 }
+    if (tried.length) {
+      // 复用 runJobs：超时即 abort、错误分类与源抓取同一套口径，不用另写一遍。
+      const out = await runJobs(tried.map((it) => ({ item: it, timeout_ms: 15000 })), {
+        limit: 2, // 回源是逐个打外部站点，并发给太大等于同时压好几个站
+        timeoutMs: 15000,
+        retries: 0, // 重试上限 1 次的红线：这里一次都不重试，失败留给下一轮
+        run: async (job, { signal } = {}) => fetchFulltextImpl(job.item.url, { signal })
+      })
+      for (const o of out) {
+        const id = o.job.item.id
+        if (o.ok && typeof o.value?.text === 'string' && o.value.text.length) {
+          // 只改正文两列 + fetched_at：不动 status（它还是候选），也不动 prefilter_score
+          // （分数是入库那轮的判断依据，抓到全文不该回头把已经做出的排序重写一遍）。
+          refreshItem(db, id, { body_text: o.value.text, body_state: 'full', fetched_at: now() })
+          setMeta(db, `fulltext:fail:${id}`, 0)
+          stats.fulltext.ok++
+          emit('info', 'fulltext_ok', `条目#${id} 补到 ${o.value.chars ?? o.value.text.length} 字`, null)
+        } else {
+          const n = Number(getMeta(db, `fulltext:fail:${id}`) ?? 0) + 1
+          setMeta(db, `fulltext:fail:${id}`, n)
+          stats.fulltext.failed++
+          emit('warn', 'fulltext_failed', `条目#${id} ${o.error_class ?? 'empty'}（第 ${n} 次）`, null)
+        }
+      }
+    }
+  }
+
   stats.gaps = summarizeGaps(gapLog)
   // held 挂进 gaps 才能活到面板：finishRun 只持久化 {status, candidates, gaps, per_source}。
   stats.gaps.held = stats.held

package/lib/store.js

@@ -181,6 +181,17 @@ export function candidates(db, limit) {
     ORDER BY prefilter_score DESC, published_at DESC, id ASC LIMIT ?`).all(limit)
 }
 
+/**
+ * 补抓正文的候选（M8）：还没判过、正文只有摘要、有链接的那些条目。
+ * 只挑 status='new'——判过的条目再改正文没有意义（判断结论已经落库），
+ * 归档的更不该因为"抓到全文"而复活。排序照 candidates：先高分的。
+ */
+export function fulltextCandidates(db, limit = 8) {
+  return db.prepare(`SELECT ${ITEM_COLS} FROM items
+    WHERE status = 'new' AND body_state = 'summary_only' AND kind = 'article'
+    ORDER BY prefilter_score DESC, published_at DESC, id ASC LIMIT ?`).all(limit)
+}
+
 export function counts(db) {
   const rows = db.prepare('SELECT status, COUNT(*) AS n FROM items GROUP BY status').all()
   const out = { new: 0, judged: 0, digest: 0, archived: 0, total: 0 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-baleen",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "信息源聚合 DSH 插件：定时摄取入库（RSS / B 站 / YouTube 三通道直连），本地预筛 + 三档判断 + 每轮增量汇报。彻底不做平台互动。",
   "type": "module",
   "main": "index.js",