dsh-bili-scroll 2.0.4 → 2.2.0

package/index.js

@@ -23,19 +23,22 @@ const hostDeps = await loadHostDeps()
 const z = hostDeps.z
 const defineTool = hostDeps.defineTool
 import { spawn } from 'node:child_process'
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import { createRequire } from 'node:module'
 import { fileURLToPath } from 'node:url'
 import { McpClient } from './lib/mcp.mjs'
 import { verifyRecent, appendVerifyToReport } from './lib/verify.mjs'
 import { WINDOWS, stateDirOf, readJson, writeJson, ensureHomeFiles, ensureCharter, charterPath, inWindow, dayKey } from './lib/state.mjs'
+import { diagnoseRound } from './lib/diagnose.mjs'
 import { loginStart, loginPoll, saveCredential, renderQrPng } from './lib/login.mjs'
 import { resolveUid } from './lib/uid.mjs'
 import { loadCred as dmCred, listSessions as dmList, fetchMsgs as dmFetch } from './lib/dm.mjs'
 import { ensureUv } from './lib/uvfetch.mjs'
 
 export const name = 'bili-scroll'
+// attachments / llm 故意**不**列进 inject：它们只在看图时才用 ctx.get 取，
+// 取不到就把图降级成文字说明；列进来会让没有这两个服务的宿主直接装不上。
 export const inject = ['webServer', 'tools', 'settings']
 
 /**
@@ -77,7 +80,8 @@ export const Config = !z ? undefined : z.object({
   /** dsh 的 bin.js（不填就试自动探测，再退化成 shell 里的 dsh） */
   dshBin: z.string().default('').extra('volatile', true),
   /** headless 那一轮用哪个 profile */
-  headlessProfile: z.string().default('headless').extra('volatile', true),
+  // ⭐ 2.0.5：默认换成"最小权限 profile"（只有 B站 MCP + 窄口 IO，没有文件系统/命令/联网）
+  headlessProfile: z.string().default('bili-duty').extra('volatile', true),
   /** 给那一轮叠一份插件自己的 patch（把 B站 MCP 挂上）—— 用户 profile 一个字都不用改 */
   overlayMcp: z.boolean().default(true).extra('volatile', true),
   /** 跑 headless 时的工作目录 */
@@ -269,7 +273,15 @@ function reportMeta() {
     const p = { ...patch }
     if ('perDay' in p) p.perDay = Math.max(0, Math.min(Number(p.perDay) || 0, 50))
     if ('reportLevel' in p) p.reportLevel = ['full', 'brief', 'off'].includes(String(p.reportLevel)) ? String(p.reportLevel) : 'full'
-    if ('personaPrompt' in p) p.personaPrompt = String(p.personaPrompt || '').slice(0, 8000)
+    // ⭐ 2.0.5（issue #89）：人设上限 8000 → 60000；**截断时要出声**（以前静默砍，用户以为写进去了 ✗）
+    if ('personaPrompt' in p) {
+      const raw = String(p.personaPrompt || '')
+      const LIMIT = 60000
+      if (raw.length > LIMIT) {
+        log('⚠️ 人设提示词 ' + raw.length + ' 字符，超过保存上限 ' + LIMIT + ' ⇒ 只存前 ' + LIMIT + '（截掉 ' + (raw.length - LIMIT) + ' 字）')
+        p.personaPrompt = raw.slice(0, LIMIT)
+      } else p.personaPrompt = raw
+    }
     if ('dmWatch' in p) p.dmWatch = Boolean(p.dmWatch)
     if ('dmWatchMinutes' in p) p.dmWatchMinutes = Math.max(1, Math.min(120, Number(p.dmWatchMinutes) || 1))
     if ('dmReplyPerDay' in p) p.dmReplyPerDay = Math.max(0, Math.min(20, Number(p.dmReplyPerDay) || 0))
@@ -495,6 +507,12 @@ function reportMeta() {
     return client.call(toolName, args, opts)
   }
 
+  /** 同 call，但保留 MCP 返回里的图片块（封面/画面要用）—— 见 lib/mcp.mjs 的 callRaw */
+  const callRaw = async (toolName, args, opts) => {
+    const client = await ensureMcp()
+    return client.callRaw(toolName, args, opts)
+  }
+
   const hasCredential = () => existsSync(join(stateDir, 'bili_credential.json'))
 
   /* ─────────────── 工具 ─────────────── */
@@ -518,7 +536,7 @@ function reportMeta() {
 
   const tool = (spec) => ctx.tools.register(defineTool({
     ...spec,
-    output: textOutput,
+    output: spec.output || textOutput,
     async execute(args, exec) { return safe(await spec.execute(args, exec)) },
   }))
 
@@ -573,6 +591,109 @@ function reportMeta() {
     },
   })
 
+  /* ─────────────── 看画面：把图交给模型 ───────────────
+   * 图片在工具结果里是附件引用 { type:'image', attachment }，不是 image_url；
+   * 字节先存进 ctx.get('attachments')，由 render 拼进返回内容。
+   * 模型不支持图片输入时退化成文字（查 llm.resolveModelInfo 的 inputModalities）。
+   */
+  const imageOutput = {
+    schema: { type: 'object', properties: {}, additionalProperties: true },
+    render: (_args, value) => {
+      const src = value && typeof value === 'object' ? value : { value }
+      const { image, images, ...rest } = src
+      const parts = [{ type: 'text', text: JSON.stringify(rest, null, 2) }]
+      const refs = [...(image ? [image] : []), ...(Array.isArray(images) ? images : [])]
+      for (const ref of refs) parts.push({ type: 'image', attachment: ref })
+      return parts
+    },
+  }
+
+  /** 把 MCP 回来的图存成附件引用，返回 { ok, refs } 或 { ok:false, reason, hint } */
+  const attachImages = async (exec, images) => {
+    const attachments = ctx.get('attachments')
+    if (!attachments?.saveImages) {
+      return { ok: false, reason: 'attachments', hint: '宿主的图片服务不可用（ctx.get("attachments") 是空的）' }
+    }
+
+    const llm = ctx.get('llm')
+    const routed = exec?.agent?.session?.requestHeader?.()?.config
+    const provider = routed?.provider ?? exec?.agent?.options?.provider
+    const model = routed?.model ?? exec?.agent?.options?.model
+    if (!llm?.resolveModelInfo) {
+      return { ok: false, reason: 'model_probe', hint: `查不到模型能力（provider=${provider} model=${model}）` }
+    }
+    let modalities
+    try {
+      modalities = (await llm.resolveModelInfo(provider, model, exec?.signal))?.inputModalities
+    } catch (e) {
+      return { ok: false, reason: 'model_probe', hint: `查模型能力失败（${provider}/${model}）：${String(e?.message ?? e)}` }
+    }
+    if (!Array.isArray(modalities)) {
+      return { ok: false, reason: 'model_probe', hint: `模型 ${provider}/${model} 没声明输入模态` }
+    }
+    if (!modalities.includes('image')) {
+      return { ok: false, reason: 'model_no_image', hint: `模型 ${provider}/${model} 不支持图片输入（${modalities.join(',') || '无'}）` }
+    }
+
+    try {
+      const refs = await attachments.saveImages(
+        images.map((i) => ({ data: Buffer.from(i.data, 'base64'), mediaType: i.mimeType })),
+      )
+      return { ok: true, refs }
+    } catch (e) {
+      return { ok: false, reason: 'save_failed', hint: '存图片失败：' + String(e?.message ?? e) }
+    }
+  }
+
+  tool({
+    name: 'bili_cover',
+    description: '看一个视频的封面（等比缩到 512px 宽）。最便宜的一档"看一眼"：'
+      + '能看出风格、标题美术、大致题材，但看不出视频里具体发生了什么。',
+    parameters: { bvid: { type: 'string', description: 'BV号' } },
+    output: imageOutput,
+    async execute(args, exec) {
+      const { json, images } = await callRaw('bili_cover', { bvid: String(args.bvid ?? '') }, { signal: exec?.signal })
+      const meta = json && typeof json === 'object' ? json : { raw: json }
+      if (!meta.ok) return meta
+      const img = images[0]
+      if (!img) return { ...meta, ok: false, error: 'MCP 没返回图片' }
+
+      const a = await attachImages(exec, [img])
+      return a.ok
+        ? { ...meta, image_attached: true, image: a.refs[0] }
+        : { ...meta, image_attached: false, image_skip_reason: a.reason, hint: a.hint }
+    },
+  })
+
+  tool({
+    name: 'bili_frames',
+    description: '看视频里的画面（从 B 站自带的故事板裁 1-6 帧，每帧 480×270）。\n'
+      + '想知道"这条视频到底拍了什么"就用它 —— 字幕告诉你说什么，画面告诉你拍的是什么。\n'
+      + '默认按时长均匀取 3 帧；想盯某个时刻（比如字幕里提到的那段）就传 at。',
+    parameters: {
+      bvid: { type: 'string', description: 'BV号' },
+      num: { type: 'number', description: '取几帧，1-6，默认 3' },
+      at: { type: 'array', items: { type: 'number' }, description: '指定时间点（秒）列表；传了就以它为准，忽略 num' },
+    },
+    output: imageOutput,
+    async execute(args, exec) {
+      const at = Array.isArray(args.at) ? args.at.map(Number).filter(Number.isFinite) : undefined
+      const { json, images } = await callRaw('bili_frames', {
+        bvid: String(args.bvid ?? ''),
+        num: Math.max(1, Math.min(Number(args.num) || 3, 6)),
+        ...(at && at.length ? { at } : {}),
+      }, { signal: exec?.signal })
+      const meta = json && typeof json === 'object' ? json : { raw: json }
+      if (!meta.ok) return meta
+      if (!images.length) return { ...meta, ok: false, error: 'MCP 没返回图片' }
+
+      const a = await attachImages(exec, images)
+      return a.ok
+        ? { ...meta, image_attached: true, images: a.refs }
+        : { ...meta, image_attached: false, image_skip_reason: a.reason, hint: a.hint }
+    },
+  })
+
   tool({
     name: 'bili_reply',
     description: '在视频下发评论（或回复某条评论）。这就是"@ 本人"那一下：短、干净、纯文本 @ 写在正文里。\n'
@@ -630,9 +751,6 @@ function reportMeta() {
         dmMode: cfg.dmMode,
         dmUid: Number(cfg.dmUid) || 0,
         transcribe: cfg.transcribe,
-        // ⭐ 2.0.4：认人改成"只认显式 UID / 登录账号自己"之后，**用小号登录、大号聊天**的人会静默失去私信回复 ✗
-      //    ⇒ 这里只给一条**提示**（不自动改！），界面上让他一键确认 —— 自动把"私信对象"当主人等于把安全修复撤销 ✗
-      ownerInfo: ownerInfo(),
       loggedIn: hasCredential(),
         home: stateDir,
         report: join(outDir, `${dayKey(now)}.md`),
@@ -756,6 +874,20 @@ function reportMeta() {
     return st.day === dayKey(now) ? Number(st.count || 0) : 0
   }
 
+  // ⭐⭐ 2.0.5（2026-10-24 用户实证，群友「羽涅」）：一键升级以前把 profile 写死成 web ✗
+  //    桌面版用户的 profile 是 desktop ⇒ 升级失败，反而把 0.1.7 装进 web 里，越修越乱 ✓
+  //    现在从"自己这个模块的真实路径"里取 profile 名：挂载点是 ~/.dsh/profiles/<名字>/node_modules/<包>/
+  const ownProfileName = (() => {
+    try {
+      const u = String(import.meta.url || '').replace(/\\/g, '/')
+      const m = u.match(/\/profiles\/([^/]+)\/node_modules\//)
+      return m ? m[1] : ''
+    } catch { return '' }
+  })()
+  const profileArg = ownProfileName || 'web'
+  // ⭐ 顺带：把"我是从哪个 profile 加载的"报出来，排障时一眼看得出
+  try { log('插件加载自 profile：' + profileArg + (ownProfileName ? '' : '（没识别到，按默认 web 处理）')) } catch { /* 忽略 */ }
+
   // ⭐ 一键升级：由宿主自己跑 `dsh plugin --profile web add dsh-bili-scroll`
   //    ⚠️ 装完必须重启 dsh 才生效；⚠️ Windows 上"替换正在运行的插件"可能被文件占用挡住（我们踩过）
   let upgrading = false
@@ -794,17 +926,17 @@ function reportMeta() {
         // ⚠️ 2026-10-19：找不到 dsh 时不再硬跑，直接把要做的事说清楚
         if (dsh.missing) {
           appendInstall('=== 没法自动升级：找不到 dsh。' + dsh.hint + ' ===\n')
-          appendInstall('=== 也可以自己手动跑一次：dsh plugin --profile web add dsh-bili-scroll ===\n')
+          appendInstall('=== 也可以自己手动跑一次：dsh plugin --profile ' + profileArg + ' add dsh-bili-scroll ===\n')
           upgrading = false
           return
         }
         let cmd = dsh.command || 'dsh'
-        let args = [...(dsh.args || []), 'plugin', '--profile', 'web', 'add', spec]
+            let args = [...(dsh.args || []), 'plugin', '--profile', profileArg, 'add', spec]
         if (dsh.shell) { args = ['/c', cmd, ...args]; cmd = 'cmd.exe' }
         appendInstall('$ ' + cmd + ' ' + args.join(' ') + '\n')
         const code = await spawnTo(cmd, args, { sink: appendInstall })
         if (code === 0) appendInstall('=== 升级完成 —— 重启一次 dsh 才生效 ===\n')
-        else appendInstall('=== 升级没成功（exit ' + code + '）。可以自己手动跑一次：dsh plugin --profile web add dsh-bili-scroll ===\n')
+        else appendInstall('=== 升级没成功（exit ' + code + '）。可以自己手动跑一次：dsh plugin --profile ' + profileArg + ' add dsh-bili-scroll ===\n')
       } catch (e) { appendInstall('升级崩了：' + (e?.stack ?? e) + '\n') } finally { upgrading = false }
     })()
     return { ok: true, started: true, log: installLogFile, hint: '正在升级 —— 完成后重启一次 dsh 才生效' }
@@ -993,16 +1125,28 @@ function reportMeta() {
       }
     }
     if (persona) {
+      // ⭐ 2.0.5（issue #89）：6000 → 40000；超了要写一行日志，别让用户以为"规则生效了" ✗
+      const PERSONA_LIMIT = 40000
+      const personaText = (() => {
+        const raw = String(persona)
+        if (raw.length > PERSONA_LIMIT) {
+          log('⚠️ 人设提示词 ' + raw.length + ' 字符，超过上限 ' + PERSONA_LIMIT + ' ⇒ 只送前 ' + PERSONA_LIMIT + '（截掉 ' + (raw.length - PERSONA_LIMIT) + ' 字）')
+          return raw.slice(0, PERSONA_LIMIT)
+        }
+        return raw
+      })()
       ownerDoc = '\n\n===== 使用者的人设' + (personaFromFile ? '（读自 ' + personaFromFile + '）' : '提示词') + '（**按这个来**）=====\n'
-        + persona.slice(0, 6000)
+        + personaText
         + '\n===== 人设结束 =====\n'
     }
       const wsDir = String(cfg.workspace || '').trim()
       const agents = (!persona && wsDir) ? join(wsDir, 'AGENTS.md') : ''
       if (agents && existsSync(agents)) {
         const text = readFileSync(agents, 'utf8')
+        const AG_LIMIT = 40000
+        if (text.length > AG_LIMIT) log('⚠️ 工作区的 AGENTS.md ' + text.length + ' 字符，超过上限 ' + AG_LIMIT + ' ⇒ 只送前 ' + AG_LIMIT + '（截掉 ' + (text.length - AG_LIMIT) + ' 字）')
         ownerDoc = '\n\n===== 使用者的 AGENTS.md（他写给自己 AI 的人设与准则，**按这个来**）=====\n'
-          + text.slice(0, 6000)
+          + text.slice(0, AG_LIMIT)
           + '\n===== 设定结束 =====\n'
       }
     } catch { /* 读不到就算了，别因此跑不成 */ }
@@ -1038,7 +1182,11 @@ function reportMeta() {
       + (already > 0
         ? `今天已经挑过 ${already} 条了 ⇒ **这一轮最多再挑 ${left} 条**（「每天最多 ${quota} 条」是全天总量，不是每轮）；`
         : `今天最多挑 ${quota} 条；`)
-      + `关键词${kws.length ? `用这些：${kws.join('、')}` : '用章程里的默认那几组'}。`
+      // ⭐ 2026-10-24：留空不再用内置关键词（那会让所有用户刷同一批视频、评论区扎堆）
+      //    ⇒ 留空 = 用 `bili_recommend` 刷**这个账号的首页推荐流**，按各自画像天然散开 ✓
+      + (kws.length
+        ? `关键词用这些：${kws.join('、')}（用 bili_search 搜）。`
+        : '没填关键词 ⇒ **这一轮用 bili_recommend 刷首页推荐流**（不要用 bili_search 搜固定词）。')
       + `本地转写：${cfg.transcribe
         ? (asrReadyNow()
           ? '开着，而且装好了（没字幕的视频用家里那份 asr.py 转，命令见章程）'
@@ -1050,6 +1198,18 @@ function reportMeta() {
       + `⭐ 另外把这一轮**看过的每一条视频（挑中的和跳过的都算）**追加进归档：${join(digestDir, `${dayKey().slice(0, 7)}.md`)}`
       + ` —— 一行一条：日期 · BV 号 · 标题 · UP · 一句话结论 · 链接（跳过的那条在后面注明理由）；`
       + `这是**给以后检索用**的（报告是给人看的，归档是给"回头翻"用的），别省略、也别只写挑中的。`
+      // ⭐ 2026-11 语感：把"它自己以前发过的评论"喂进去 —— 没有这段，它每轮都从零开始，
+      //    自然每条都往"平均腔调"上靠（那就是鱼八股）。有这段它才会长出自己的口癖、并避开重复开头。
+      + (() => {
+        try {
+          const led = join(stateDir, 'comments.md')
+          if (!existsSync(led)) return ''
+          const rows = readFileSync(led, 'utf8').split('\n').filter((l) => l.trim().startsWith('- '))
+          const bodies = rows.slice(-5).map((l) => (l.includes('·') ? l.split('·').slice(1).join('·') : l.slice(2)).trim()).filter(Boolean)
+          if (!bodies.length) return ''
+          return `⭐ **你以前发过的评论**（写新的之前先看一遍：**别用相同的开头、别套同一个句式**，它应该越来越像"这一个它"而不是模板）：` + bodies.map((b) => '「' + b.slice(0, 60) + '」').join(' ') + '。'
+        } catch { return '' }
+      })()
       + `自动评论并 @ ${cfg.mentionName || '（还没填要 @ 谁）'} 是${commentOn
         ? `开着的（每轮最多 ${cfg.commentPerRound} 条评论，每条在正文里纯文本 @ ${cfg.mentionName}，150 字内）`
         : (dmModeEff === 'only'
@@ -1099,7 +1259,12 @@ function reportMeta() {
    *    要读全就手工改这个列表（或者直接跑 mcp_server.py，不设这个变量 = 全放）。
    */
   const mcpWhitelist = () => {
-    const list = ['bili_search', 'bili_subtitle', 'bili_comments', 'bili_video_info']
+    const list = ['bili_search', 'bili_subtitle', 'bili_comments', 'bili_video_info',
+      'bili_cover', 'bili_frames', 'bili_danmaku', 'bili_recommend']  // 看封面 / 画面帧 / 弹幕：只读，不需要额外的闸
+    // ⭐⭐ 2.0.5（issue #96 安全加固）：值班轮改成最小权限 profile（没有 fs / shell / web）⇒
+    //    写日报 / 判重表 / 归档、以及无字幕转写，全走这几只**固定路径的窄口工具** ✓
+    list.push('duty_paths', 'duty_report_append', 'duty_seen_append', 'duty_digest_append', 'duty_seen_recent')
+    if (cfg.asrInstalled !== false) list.push('bili_transcribe')
     // ⭐⭐ 2.0.4（第三方体检第 3 条）：**"只发私信"时评论通道必须硬关** —— 以前只看 autoComment，
     //    用户以前开过自动评论、后来切到"只私信"，那个 true 还在 config 里 ⇒ 评论工具照样下发 ✗
     const dmOnly = String(cfg.dmMode || '').trim() === 'only'
@@ -1111,6 +1276,34 @@ function reportMeta() {
     return list
   }
 
+
+  // ⭐⭐ 2.0.5（issue #96 / PR #97 思路）：把「值班轮专用 profile」铺到 <DSH_HOME>/profiles/bili-duty/
+  //    · 组成 = dsh-base + dsh-headless + 我们那层 cordis.patch.yml（关掉 fs / shell / web / subagent / skill…）
+  //    · 铺不上就明确退回 headless，并在日志里说清"这一轮不是最小权限"（失败要出声）
+  let dutyProfileState = 'unknown'   // ok / missing / failed
+  const dutyProfileDir = join(dirname(stateDir), 'profiles', 'bili-duty')
+  const ensureDutyProfile = () => {
+    try {
+      const src = join(pluginDir, 'profile-template', 'bili-duty')
+      if (!existsSync(src)) { dutyProfileState = 'missing'; return false }
+      mkdirSync(dirname(dutyProfileDir), { recursive: true })
+      // 每次启动都覆盖（模板很小；这是安全边界，用户改它也会被覆盖）
+      cpSync(src, dutyProfileDir, { recursive: true, force: true })
+      dutyProfileState = existsSync(join(dutyProfileDir, 'cordis.patch.yml')) ? 'ok' : 'failed'
+      return dutyProfileState === 'ok'
+    } catch (e) {
+      dutyProfileState = 'failed'
+      log('⚠️ 最小权限 profile 没铺成功（' + String(e?.message ?? e) + '）⇒ 这一轮会退回 headless')
+      return false
+    }
+  }
+  // 真正用的 profile：用户手填了别的就尊重；还是老默认 has headless ⇒ 用最小权限那个
+  const effectiveProfile = () => {
+    const want = String(cfg.headlessProfile || '').trim()
+    if (want && want !== 'headless' && want !== 'bili-duty') return want
+    return dutyProfileState === 'ok' ? 'bili-duty' : (want || 'headless')
+  }
+
   const ensureOverlay = () => {
     const file = join(stateDir, 'headless-overlay.yml')
     const script = join(stateDir, 'mcp_server.py')
@@ -1198,9 +1391,13 @@ function reportMeta() {
 
   /**
    * ⭐ 保底：那一轮**没写出报告**时，宿主自己补一份"占位报告"。
-   * 起因（2026-10-16 用户实测反馈）：有一轮卡在"转写返回空 ⇒ 以为 ASR 坏了"上反复重试，
-   *   最后 `out/` 是空的、判重表也没建 ⇒ **使用者完全看不到发生了什么**，也不知道白烧了钱 ✗。
-   * ⚠️ 只在"报告本来该有却没有"时补（`reportLevel: off` 不补 ✓），不覆盖已有的报告 ✓。
+   * 起因①（2026-10-16 用户实测）：有一轮卡在"转写返回空 ⇒ 以为 ASR 坏了"上反复重试，
+   *   最后 `out/` 空、判重表也没建 ⇒ 使用者完全看不到发生了什么 ✗。
+   * 起因②（2026-10-24 用户实测）：`NO_ADAPTER: no adapter registered for provider "…"`
+   *   ⇒ 那一轮 1 秒 exit 1，报告里只有 code=1 ⇒ 用户看不懂 ✗。
+   * 现在：先从日志尾部认已知失败形态（`lib/diagnose.mjs`，纯函数），能认出来就把"是什么+怎么办"
+   *   写进报告顶部；认不出来就走原来的兜底文案（行为跟以前一样）。
+   * ⚠️ 只在"报告本来该有却没有"时补（`reportLevel: off` 不补），不覆盖已有报告。
    */
   const stubReportIfMissing = (code) => {
     try {
@@ -1208,16 +1405,36 @@ function reportMeta() {
       const f = join(outDir, `${dayKey()}.md`)
       if (existsSync(f)) return
       let tail = ''
-      try { tail = readFileSync(logFile, 'utf8').slice(-1500) } catch { /* 读不到就算了 */ }
+      try { tail = readFileSync(logFile, 'utf8').slice(-6000) } catch { /* 读不到就算了 */ }
+      // ⚠️ diagnoseRound 是纯函数、自己不会抛；这里再包一层是"绝不因为诊断把人搞挂"
+      let why = null
+      try { why = diagnoseRound(tail) } catch (e) { log(`诊断失败（已兜住）：${e?.message ?? e}`) }
+      if (why) log(`这一轮没跑起来：${why.title}`)
+      const head = why
+        ? [
+            `# 刷B站 · ${dayKey()} —— 这一轮没跑起来`,
+            '',
+            `> ⚠️ **${why.title}**（退出码 ${code}）`,
+            '',
+            why.body,
+            '',
+            '---',
+            '',
+            '## 日志尾部（完整版在 `duty.log`）',
+            '',
+          ]
+        : [
+            `# 刷B站 · ${dayKey()} —— 这一轮没写出报告`,
+            '',
+            `> ⚠️ 那一轮结束了，但没有生成正常报告（退出码 ${code}）。`,
+            '> 常见原因是它卡在某个工具上反复重试、或者把预算烧完了。下一轮它会重来。',
+            '> 下面附日志尾部，方便定位（插件数据目录里的 `duty.log` 有完整版）。',
+            '',
+          ]
       writeFileSync(f, [
-        `# 刷B站 · ${dayKey()} —— 这一轮没写出报告`,
-        '',
-        `> ⚠️ 那一轮结束了，但没有生成正常报告（退出码 ${code}）。`,
-        '> 常见原因是它卡在某个工具上反复重试、或者把预算烧完了。下一轮它会重来。',
-        '> 下面附日志尾部，方便定位（插件数据目录里的 `duty.log` 有完整版）。',
-        '',
+        ...head,
         '```',
-        String(tail).trim(),
+        String(tail).trim().slice(-4000),
         '```',
         '',
       ].join('\n'), 'utf8')
@@ -1227,6 +1444,47 @@ function reportMeta() {
 
   // ⭐⭐ 2.0.4（第三方体检第 2 条）：**同一时间只允许一轮在跑**，并且**登记这个子进程**，
   //    关页面/卸载插件时能把它一起收掉（以前它没有锁、也不归 ctx.effect 管 ✗）。
+  // ⭐⭐ 2026-10-25：**跨宿主的运行锁**（issue 提到"没加原子锁"—— 那一半是真的）。
+  //    同一台机器可能同时开着网页版和桌面版两个 DSH，两边都装了插件、都有自己的定时器：
+  //    同一分钟两个都到点 ⇒ 都开跑 ⇒ **同一条视频被推两遍**，`seen.md` 也会多出重复行 ✗
+  //    （私信监听早就有 `dm-lock.json` 了，跑一轮这块一直只有"进程内"的标志位 ✗）
+  //    设计：一张带 pid + 时间的纸条，谁先写成谁跑，另一个让开；10 分钟自动过期（防进程崩了锁死）。
+  //    ⚠️ **写不了锁就照常跑** —— 宁可偶尔重复一次，也不能因为锁坏了就不干活。
+  const runLockFile = join(stateDir, 'run-lock.json')
+  const RUN_LOCK_TTL = 10 * 60_000
+  const pidAlive = (pid) => {
+    if (!pid) return false
+    try { process.kill(pid, 0); return true } catch { return false }
+  }
+  /** 试着占锁：拿到 ⇒ true；有人正占着（新鲜的、进程还活着、不是我）⇒ false */
+  const acquireRunLock = (why) => {
+    try {
+      let lock = null
+      try { lock = JSON.parse(readFileSync(runLockFile, 'utf8')) } catch { lock = null }
+      if (lock && Number(lock.pid) !== process.pid) {
+        const fresh = Number(lock.ts) > Date.now() - RUN_LOCK_TTL
+        if (fresh && pidAlive(Number(lock.pid))) {
+          log(`这一轮没跑（${why}）：另一个宿主正在跑（pid=${lock.pid}）⇒ 让给它`)
+          return false
+        }
+        if (!fresh) log('运行锁已过期（' + Math.round((Date.now() - Number(lock.ts)) / 60000) + ' 分钟前那个），这一轮照跑')
+      }
+      writeFileSync(runLockFile, JSON.stringify({ pid: process.pid, ts: Date.now(), why }), 'utf8')
+      return true
+    } catch (e) {
+      // 锁文件坏了/写不进去 ⇒ 不拦路（fail-open，但留痕）
+      log('运行锁读写失败（这一轮照跑）：' + String(e?.message ?? e))
+      return true
+    }
+  }
+  /** 放锁：只放自己的那张（别把别人的删了） */
+  const releaseRunLock = () => {
+    try {
+      const lock = JSON.parse(readFileSync(runLockFile, 'utf8'))
+      if (Number(lock?.pid) === process.pid) writeFileSync(runLockFile, '{"pid":0,"ts":0}', 'utf8')
+    } catch { /* 没有锁 / 读不出来 / 写不进去都无所谓，靠 10 分钟过期兜底 */ }
+  }
+
   let dutyChild = null
   let dutyStartedAt = 0
   const runDuty = (why = 'window') => {
@@ -1248,8 +1506,10 @@ function reportMeta() {
       try { stubReportIfMissing(1) } catch { /* 补不上也不影响这句话已经进日志 */ }
       return { started: false, why, error: msg }
     }
+    // ⭐ 跨宿主运行锁：拿到才跑（写不了锁时照常跑，函数内部已经 fail-open）
+    if (!acquireRunLock(why)) return { started: false, why, busy: true, error: '另一个宿主正在跑这一轮' }
     const overlay = ensureOverlay()
-    const args = [...dsh.args, '--profile', cfg.headlessProfile || 'headless']
+      const args = [...dsh.args, '--profile', effectiveProfile()]
     if (overlay) args.push('--patch', overlay)
     args.push(promptFor())
     // ⭐ 这一轮的工作目录 = 使用者（或别的用户）的**工作区** —— 只有这样它的 `AGENTS.md` 才会自动加载。
@@ -1291,6 +1551,7 @@ function reportMeta() {
     child.stdout?.on('data', pick)
     child.stderr?.on('data', pick)
     child.on('exit', (code) => {
+      releaseRunLock()            // ⭐ 这一轮结束了，把锁放开（删不掉也没事，10 分钟自动过期）
       log(`刷B站结束（${why}，code=${code}）`)
       stubReportIfMissing(code)   // ⭐ 没写报告就补一份占位 —— 别让使用者什么都看不到
     // ⭐ 2026-10-20：这一轮跑成了、并且使用者选了收藏夹 ⇒ 把挑中的存进去（后台做，别拖住收尾）
@@ -1314,7 +1575,7 @@ function reportMeta() {
     child.on('close', () => { if (dutyChild === child) dutyChild = null })
     dutyChild = child
     dutyStartedAt = Date.now()
-    child.on('error', (e) => log(`刷B站起不来：${e?.message ?? e}`))
+    child.on('error', (e) => { releaseRunLock(); log(`刷B站起不来：${e?.message ?? e}`) })
     // ⭐ 起不来/被杀掉也要把锁放开，否则之后每一轮都会被判成'上一轮还没结束' ✗
     child.on('close', () => { if (dutyChild === child) dutyChild = null })
     return { started: true, why, profile: cfg.headlessProfile, cwd, log: logFile }
@@ -1404,6 +1665,46 @@ function reportMeta() {
     } catch { return null }
   }
 
+  // ⭐⭐ 2.0.5（有人反馈"私信没有上下文" —— 属实）：以前每条私信都是一次全新会话 ⇒ 它永远"初次见面" ✗
+  //    现在固定**续同一个会话**：headless 支持 `--session-id <id>`，历史由 DSH 自己带着、超上限它自己压缩 ✓
+  //    第一次跑完把开出来的会话 id 记到 dm-session.json；之后每次都带上；会话失效就丢掉重开（不会卡死）✓
+  const dmSessionFile = join(stateDir, 'dm-session.json')
+  const readDmSession = () => {
+    try {
+      const j = JSON.parse(readFileSync(dmSessionFile, 'utf8'))
+      return j && typeof j.id === 'string' && j.id ? j.id : ''
+    } catch { return '' }
+  }
+  const writeDmSession = (id) => { try { writeFileSync(dmSessionFile, JSON.stringify({ id, at: Date.now() }, null, 2), 'utf8') } catch { /* 写不了下次再认 */ } }
+  // 跑完之后，从 $DSH_HOME/sessions/*/<id>/ 里找"这次新出现的那个"（mtime 晚于启动时刻）
+  const discoverDmSession = (sinceTs) => {
+    try {
+      const root = join(process.env.DSH_HOME || join(process.env.USERPROFILE || '', '.dsh'), 'sessions')
+      if (!existsSync(root)) return ''
+      // ⚠️ 只认"这一轮工作目录 = 插件家"那个 workspace（否则会误认到自己聊天那条会话 ✗）
+      //    命名规则：--<盘符去掉冒号>-<路径用横线拼>--（如 --C-Users-99496-.dsh-bili-duty--）
+      const wantWs = '--' + stateDir.replace(/:/g, '').replace(/[\\/]/g, '-') + '--'
+      let best = ''
+      let bestAt = 0
+      const scanWs = [wantWs].filter((w) => existsSync(join(root, w)))
+      const list = scanWs.length ? scanWs : readdirSync(root)
+      for (const ws of list) {
+        const wsDir = join(root, ws)
+        let dirs = []
+        try { dirs = readdirSync(wsDir) } catch { continue }
+        for (const d of dirs) {
+          const full = join(wsDir, d)
+          try {
+            const st = statSync(full)
+            if (!st.isDirectory()) continue
+            if (st.mtimeMs >= sinceTs && st.mtimeMs > bestAt) { bestAt = st.mtimeMs; best = d }
+          } catch { /* 跳过 */ }
+        }
+      }
+      return best
+    } catch { return '' }
+  }
+
   function dmPromptFor(fromUid, text) {
     const raw = String(text || '').slice(0, 600)
     const bv = (raw.match(/BV[0-9A-Za-z]{10}/) || [])[0] || ''
@@ -1431,10 +1732,14 @@ function reportMeta() {
       const dsh = resolveDsh()
       if (dsh.missing) { log('私信回复没跑：找不到 dsh（' + dsh.hint + '）'); return { ok: false } }
       const overlay = ensureOverlay()
-      const args = [...dsh.args, '--profile', cfg.headlessProfile || 'headless']
-      if (overlay) args.push('--patch', overlay)
-      args.push(dmPromptFor(fromUid, text))
-      log(`私信回复开跑：来自 uid=${fromUid}`)
+      const base = [...dsh.args, '--profile', effectiveProfile()]
+      if (overlay) base.push('--patch', overlay)
+      if (dmReplyRunning) { log('私信回复：上一条还在跑 ⇒ 这条等下一跳'); return { ok: false, busy: true } }
+      dmReplyRunning = true
+      const savedSid = readDmSession()
+      const args = savedSid ? [...base, '--session-id', savedSid, dmPromptFor(fromUid, text)] : [...base, dmPromptFor(fromUid, text)]
+      log(`私信回复开跑：来自 uid=${fromUid}` + (savedSid ? '（续会话 ' + savedSid.slice(0, 20) + '…）' : '（开新会话）'))
+      const startedAt = Date.now()
       const child = spawn(dsh.command, args, {
         cwd: stateDir, shell: dsh.shell, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'],
         env: uvEnv({ BILI_DUTY_HOME: stateDir, ...(process.versions.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}) }),
@@ -1443,13 +1748,31 @@ function reportMeta() {
       const pick = (buf) => { try { appendFileSync(logFile, toText(buf), 'utf8') } catch { /* 丢日志也不能抛 */ } }
       child.stdout?.on('data', pick)
       child.stderr?.on('data', pick)
-      child.on('exit', (code) => { log(`私信回复结束（code=${code}）`); rotateLogIfBig() })
+      child.on('exit', (code) => {
+        dmReplyRunning = false
+        log(`私信回复结束（code=${code}）`)
+        rotateLogIfBig()
+        // ① 本来没有会话 id：跑完把它开出来的那个认领下来，下一条就能接着聊
+        if (!savedSid && code === 0) {
+          const id = discoverDmSession(startedAt)
+          if (id) { writeDmSession(id); log('私信会话已记录：' + id.slice(0, 24) + '…（以后私信都接着这个会话）') }
+          else log('⚠️ 没找到这次的会话 id ⇒ 下一条私信还是新会话（不影响回复，只是没上下文）')
+        }
+        // ② 带了 id 却失败（会话被删/迁移过）⇒ 丢掉它，下一条重开，别卡死在坏 id 上
+        if (savedSid && code !== 0) {
+          writeDmSession('')
+          log('⚠️ 续会话失败（' + savedSid.slice(0, 16) + '…）⇒ 清掉 id，立刻用新会话重试一次（这条不能没回）')
+          setTimeout(() => { try { runDmReply(fromUid, text) } catch { /* 兜住 */ } }, 800)
+        }
+      })
       return { ok: true }
     } catch (e) { log('私信回复出错：' + String(e?.message ?? e)); return { ok: false } }
   }
 
   let dmTimer = null
   let dmBusy = false
+  // ⭐ 2.0.5：一条私信回复没跑完时，不要让下一条进来（不然两个进程抢同一个会话，DSH 会报 "already owned by an active write handle"）
+  let dmReplyRunning = false
   async function dmTick() {
     if (dmBusy) return
     dmBusy = true
@@ -2087,6 +2410,8 @@ function reportMeta() {
       pickedToday: countPickedToday(),                          // 今天挑到几条（从报告里数）
       lastRunAt: st.lastRunAt || null,
       lastWhy: st.lastWhy || null,
+      // ⭐ 2.0.4：界面上"它会认谁当主人"那行用这个（用小号登录、大号聊天的会看错）
+      ownerInfo: ownerInfo(),
       loggedIn: hasCredential(),
       venvReady: venvReadyNow(),
       version: myVersion(),
@@ -2403,7 +2728,7 @@ function reportMeta() {
         '版本：' + myVersion(),
         '平台：' + process.platform + ' ' + process.arch + ' · node ' + process.versions.node + (process.versions.electron ? ' · electron ' + process.versions.electron : ''),
         'dsh：' + (() => { try { const d = resolveDsh(); return d.missing ? '没找到（' + d.hint + '）' : d.command + ' ' + d.args.join(' ') } catch (e) { return '探测失败：' + e?.message } })(),
-        'headless profile：' + (cfg.headlessProfile || 'headless'),
+        'headless profile：' + effectiveProfile() + '（最小权限：' + dutyProfileState + '）',
         'pythonPath：' + cfg.pythonPath,
         'venv 就绪：' + (venvReadyNow() ? '是' : '否') + (missingVenvDeps().length ? '（缺：' + missingVenvDeps().join(' / ') + '）' : ''),
         '转写环境：' + (existsSync(join(stateDir, '.venv-asr')) ? '在' : '没装'),
@@ -2516,37 +2841,101 @@ function reportMeta() {
     return sendJson(res, 404, { ok: false, error: `unknown ${req.method} ${path}` })
   }
 
-  try {
   const sameOriginOk = (req) => {
     try {
       const host = String(req.headers.host || '')
       if (!host) return true   // 没有 Host 头 = 不是浏览器/不是外来的 HTTP 请求
       if (!/^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i.test(host)) return false
       const pick = String(req.headers.origin || req.headers.referer || '')
-      if (!pick) return true   // 不是浏览器发的（本机脚本/宿主内部）—— 本机进程本来就有权限
+      if (!pick) return true   // 不是浏览器发的（本机脚本/宿主内部）
       try {
         const u = new URL(pick)
-        return /^(127\.0\.0\.1|localhost|\[::1\])$/i.test(u.hostname)
+        // ⭐ 2.0.5（采纳 PR #94）：**端口也要比** —— 只比 hostname 的话，
+        //    本机上另一个端口的页面（dev server / Jupyter / 有 XSS 的本地页）也能驱动这些写接口 ✗
+        const originAuthority = String(u.host || '').toLowerCase()
+        const hostAuthority = String(host).toLowerCase()
+        if (originAuthority && originAuthority === hostAuthority) return true
+        const defaultPort = u.protocol === 'https:' ? '443' : '80'
+        const withPort = (u.hostname + ':' + (u.port || defaultPort)).toLowerCase()
+        return withPort === hostAuthority
       } catch { return false }
     } catch { return false }
   }
+
+  // ⭐⭐ 2.0.5（issue #88）：**走 DSH 自己的信任栅栏** —— 隧道把 Host 改写成回环时，
+  //    我们那层"本机同源"会被绕过；connection.requestRejection 才是真正的鉴权（认 cookie/token）✓
+  //    取法照 DSH 内部写法：Reflect.get(ctx, "connection") ⇒ requestRejection(req)
+  //    返回 undefined = 放行；返回数字 = 回这个状态码（通常 401）
+  //    ⚠️ 栅栏不可用时不静默放行：仍要求过"本机同源"，两道都不成 ⇒ 拒 ✓
+  let fenceWarned = false
+  // ⭐ 取 connection 的三种写法都试（实测：Reflect.get 在插件 ctx 上拿不到 ⇒ 2026-10-23 真机验证后发现）
+  let nodeConnCached = null
+  let nodeConnTried = false
+  const getConnection = () => {
+    if (nodeConnTried) return nodeConnCached
+    nodeConnTried = true
+    const tries = [
+      ['ctx.get("connection")', () => (typeof ctx.get === 'function' ? ctx.get('connection') : null)],
+      ['Reflect.get(ctx, "connection")', () => Reflect.get(ctx, 'connection')],
+      ['ctx.root.connection', () => (ctx.root && typeof ctx.root === 'object' ? ctx.root.connection : null)],
+    ]
+    for (const [how, fn] of tries) {
+      try {
+        const c = fn()
+        if (c && typeof c.requestRejection === 'function') {
+          nodeConnCached = c
+          log('信任栅栏：用 ' + how + ' 拿到了 connection 服务 ✓')
+          return c
+        }
+      } catch { /* 换下一个 */ }
+    }
+    log('⚠️ 三种写法都拿不到 connection.requestRejection ⇒ 退回"本机同源"这一道')
+    return null
+  }
+  const fenceReject = (req, res) => {
+    const conn = getConnection()
+    if (!conn) {
+      if (!fenceWarned) { fenceWarned = true; log("⚠️ 拿不到 DSH 信任栅栏（connection.requestRejection）⇒ 退回本机同源这一道") }
+      return false
+    }
+    try {
+      // ⭐ 2.0.5（采纳 PR #94）：契约入参是 `{ headers }`（ConnectionTrustRequest），不是原始 IncomingMessage；
+      //    两种形状都给一遍，谁的实现都能接住（实测传原始 req 也能过，但按契约来更稳）
+      const rejection = conn.requestRejection({ headers: req.headers })
+      if (rejection === undefined) return false
+      res.statusCode = typeof rejection === "number" ? rejection : 403
+      try { res.end() } catch { /* 忽略 */ }
+      return true
+    } catch (err) {
+      log("信任栅栏调用出错，按不通过处理：" + String(err?.message ?? err))
+      res.statusCode = 403
+      try { res.end() } catch { /* 忽略 */ }
+      return true
+    }
+  }
+
+  try {
     ctx.effect(() => ctx.webServer.register({
       kind: 'prefix',
       path: '/api/bili-duty',
-  // ⭐ 2026-10-23 安全加固（审计点名"未鉴权的控制接口"）：**只接受本机同源请求** ——
-  //    别的网页在你浏览器里也能打到 127.0.0.1，所以要比对 Host 与本机、Origin/Referer 与同源 ✓
       handler: async (req, res) => {
-    if (!sameOriginOk(req)) {
-      try { sendJson(res, 403, { ok: false, error: '只接受本机同源请求' }) } catch { /* 忽略 */ }
-      return
-    }
-        try { await handle(req, res, new URL(req.url, 'http://127.0.0.1')) } catch (e) {
-          sendJson(res, 500, { ok: false, error: e?.message ?? String(e) })
+        // ① 先过 DSH 的信任栅栏（真鉴权）
+        if (fenceReject(req, res)) return
+        // ② 再过本机同源（栅栏拿不到时的兜底，也挡浏览器里别的网页）
+        if (!sameOriginOk(req)) {
+          try { sendJson(res, 403, { ok: false, error: '只接受本机同源请求' }) } catch { /* 忽略 */ }
+          return
+        }
+        try { await handle(req, res, new URL(req.url, 'http://127.0.0.1')) } catch (err) {
+          sendJson(res, 500, { ok: false, error: err?.message ?? String(err) })
         }
       },
     }), 'bili-duty: /api/bili-duty 路由')
   } catch (e) { log(`HTTP 路由没挂上：${e?.message ?? e}`) }
 
   ctx.effect(() => () => { try { mcp?.stop() } catch { /* 收摊 */ } }, 'bili-duty: 收 MCP 子进程')
+  try { ensureDutyProfile() } catch { /* 上面已记日志 */ }
+  if (dutyProfileState === 'ok') log('值班轮用最小权限 profile：bili-duty（无文件系统 / 无命令 / 无联网）')
+  else log('⚠️ 最小权限 profile 不可用（' + dutyProfileState + '）⇒ 值班轮仍用 headless（这一轮能力偏大）')
   log(`已挂载（家=${stateDir}，python=${cfg.pythonPath}，峰谷=${cfg.peakValley ? '开' : '关'}）`)
 }