dsh-second-review 1.3.4 → 1.3.6

package/README.md

@@ -3,7 +3,7 @@
 > Independent second-opinion review for DeepSeek Harness.
 > 主模型负责执行，副模型负责复核；结论以卡片形式附在原回复下方。
 
-![version](https://img.shields.io/badge/version-1.3.4-blue)
+![version](https://img.shields.io/badge/version-1.3.6-blue)
 ![license](https://img.shields.io/badge/license-MIT-green)
 ![platform](https://img.shields.io/badge/platform-Windows-lightgrey)
 ![dsh](https://img.shields.io/badge/DSH-0.2.2--rc.1%20verified-informational)
@@ -60,7 +60,8 @@ SEC 是一个**主执行者 + 独立监督者**的组合：主模型完成回答
 | 功能 | 作用 | 费用 |
 |-|-|-|
 | **二次评审** | 复核当前轮（含此前对话） | 一次副模型调用 |
-| **自动评审** | 新回复到达后自动复核一次（默认可关闭） | 同上，按条计 |
+| **自动评审** | 新回复到达后自动复核一次（**默认关闭**）；范围可选「每条」或「只有动过手」 | 同上，按条计 |
+| **用量** | 卡片末尾写出本轮主模型与本次复核的 token | 无（从日志算，不调模型） |
 | **副模型主刀** | 交换角色：下一轮由副模型回答，原主模型复核 | 按对应模型计 |
 | **让主模型读** | 将评审结论交给主模型，促其正面回应 | 一次主模型调用 |
 | **停止** | 中止进行中的复核；已生成内容保留可查 | 已产生费用不退回 |
@@ -129,7 +130,7 @@ SEC 是一个**主执行者 + 独立监督者**的组合：主模型完成回答
 | 反复挑标点、路径、措辞 | 多为模型话多，换一个即可，不必修改需求 |
 | 长对话中持续变慢 | 部分模型会逐句过一遍，属模型行为，不是插件故障 |
 
-> 模型名称为写作时的示例。实际可选范围以你 DSH 中已配置的 provider 为准；未指定时默认 `deepseek-flash`。
+> 模型名称为写作时的示例。实际可选范围以你 DSH 中已配置的 provider 为准；不指定时默认走 **Pro 档**（自动跟随，见 07 `modelAuto`）。
 
 ---
 
@@ -173,11 +174,11 @@ file:C:\Users\<用户名>\Documents\dsh-second-review
 
 **方式三：压缩包**
 
-将 `dsh-second-review-1.3.4.tgz` 发给对方，在「添加插件」中选择该压缩包。
+将 `dsh-second-review-1.3.6.tgz` 发给对方，在「添加插件」中选择该压缩包。
 
 **设置页**位于 **插件 → 二次评审**，分四段：01 模型 / 02 评审模式 / 03 权限 / 04 关于。修改后需点击底部「保存」，未保存时页面会提示。
 
-**首次使用**：建议自动评审保持关闭，先点「先看效果（不花钱）」，再做第一次真实复核（首次会展示费用与数据去向说明）。
+**首次使用**：建议自动评审保持关闭，先点「先看效果（不花钱）」，再做第一次真实复核（首次会展示费用与数据去向说明）。副模型默认就是 **Pro 档**、跟着版本走；主模型如果也是它，点评审时会先弹一个窗让你换——同一双眼睛看不见自己。
 
 **更新**：以新版本覆盖同一目录，再重新添加一次相同路径，然后重启 DSH。配置与评审记录保存在插件目录之外，不会因覆盖丢失。
 
@@ -189,8 +190,11 @@ file:C:\Users\<用户名>\Documents\dsh-second-review
 
 | 字段 | 默认 | 说明 |
 |-|-|-|
-| `provider` / `model` | `deepseek-account` / `deepseek-flash` | 副模型 |
+| `provider` / `model` | `deepseek-account` / `deepseek-v4-pro` | 副模型（`modelAuto` 打开时以自动挑到的 Pro 档为准） |
+| `modelAuto` | `true` | 自动挑这个 provider 里名字带 `pro` 的最新一版；关掉就用 `model` 里那个具体 id |
+| `hideSameSourceModal` | `false` | 主副重合提示窗的「不再提示」 |
 | `auto` | `false` | 新回复自动复核 |
+| `autoMode` | `every` | 自动评审范围：`every` 每条都评／`actions` 只有动过手（写文件、跑命令、发消息、工作区有改动）才评 |
 | `mock` | `false` | 测试模式：模拟数据，不调模型、不落盘 |
 | `allowWrite` | `false` | 是否向副模型提供写文件工具 |
 | `budgetSec` | `0` | 总时长上限（秒），`0` 为不限 |
@@ -285,7 +289,7 @@ file:C:\Users\<用户名>\Documents\dsh-second-review
 
 ## 12 · 版本
 
-当前 **1.3.4**。
+当前 **1.3.6**。
 
 | 版本 | 主要内容 |
 |-|-|
@@ -305,6 +309,8 @@ file:C:\Users\<用户名>\Documents\dsh-second-review
 | **1.3.2** | 上架 npm；补仓库与 Issue 入口；README 增补 30 秒速览、设计动机、卡片示例图、故障排查、反馈渠道 |
 | **1.3.3** | 仓库根目录化后同步：repository 去掉 directory，README 图片改回相对路径（由 npm 依仓库地址解析） |
 | **1.3.4** | 安装文档补「按包名安装」；修正压缩包版本号与更新日志里的错字 |
+| **1.3.5** | 副模型与主模型是同一个模型时，卡片标出「与主模型相同 · 自评」；设置页补默认值提醒；修正「自动评审默认可关闭」这句歧义 |
+| **1.3.6** | 副模型默认改走 **Pro 档**、且 `modelAuto` 跟着 DSH 的模型清单自动换代；点「二次评审」前若主副重合，弹一个明暗跟随皮肤的黑白窗，可直接换模型（可勾「不再提示」）；评审中随机轮播九句碎碎念；卡片末尾显示用量（本轮主模型＋本次复核，全从日志和回执算，不额外调模型）；自动评审加「范围」开关：每条都评／只有动过手才评，跳过的轮次卡片上写明；设置页加三个预设（只改开关，不换模型） |
 
 ---
 

package/client.js

@@ -31,6 +31,21 @@ window.__ModuleLoader__.load({
        用 em 而不是 px，他自己调了系统/界面字号，卡片跟着一起变。 */
     const FS = { body: '1em', small: '0.95em', min: '0.9em' }
 
+    /* ---------------- 思考中的碎碎念（1.3.6） ----------------
+       ↓↓↓ 文案填这里：一行一句，随便加、随便删，随机轮着放 ↓↓↓
+       他 2026-11-11 亲手写的九句，就按这个顺序存，每次随机挑一句、不连着重复。 */
+    const THINK_LINES = [
+      '嗯……帮你理一理',
+      '正在认真评审，稍等哦',
+      '让我沉下来想一想',
+      '试着从这边看看',
+      '搬个小板凳坐下来想',
+      '嗯……这个说法稳妥吗',
+      '让我多问自己一个为什么',
+      '补一块砖，站得更稳',
+      '调调焦距，看得更清',
+    ]
+
     /* ---------------- 玻璃（方案 B：搬「开关」，不搬代码） ----------------
        壁纸插件 dsh-plugin-wallpaper-engine 把玻璃参数写成 <body> 上的 CSS 变量，
        body 下面所有元素都能读到。我们只读这几个：
@@ -46,6 +61,21 @@ window.__ModuleLoader__.load({
 
     const R = 10 // "角圆润的方形"（他 2026-11-09 说的）—— 不是胶囊，也不是直角
     const ACCENT = 'var(--we-accent, #3b82f6)'
+
+    /* 1.3.6：弹窗要"非黑即白" —— 跟着现在的皮肤判个明暗，不猜也不写死深色 */
+    const isDarkUI = () => {
+      try {
+        const bg = getComputedStyle(document.body).backgroundColor || ''
+        const m = bg.match(/\d+(\.\d+)?/g)
+        if (!m || m.length < 3) return true
+        const r = Number(m[0])
+        const g = Number(m[1])
+        const b = Number(m[2])
+        return 0.299 * r + 0.587 * g + 0.114 * b < 128
+      } catch {
+        return true
+      }
+    }
     const HAIRLINE = 'rgba(128,128,128,0.24)'
     const HAIRLINE_SOFT = 'rgba(128,128,128,0.16)'
     const INK_SOFT = 'rgba(128,128,128,0.18)'
@@ -414,7 +444,7 @@ window.__ModuleLoader__.load({
 
     /* ---------------- 设置（模块级，整页共用一份） ---------------- */
 
-    const settings = { value: null, pending: null }
+    const settings = { value: null, pending: null, resolved: '' }
 
     function loadSettings(force) {
       if (!force && settings.value) return Promise.resolve(settings.value)
@@ -423,6 +453,8 @@ window.__ModuleLoader__.load({
         .then((r) => r.json())
         .then((j) => {
           settings.value = (j && j.ok && j.config) || { auto: false }
+          // 1.3.6：自动 Pro 档时，后端会告诉我们最终落到哪个模型（卡片和弹窗都要显示它）
+          settings.resolved = (j && j.ok && j.resolvedModel) || ''
           return settings.value
         })
         .catch(() => {
@@ -438,7 +470,7 @@ window.__ModuleLoader__.load({
 
     /* ---------------- 副模型主刀（每个会话各存各的，互不覆盖） ---------------- */
 
-    const swap = { bySession: {}, pending: {} }
+    const swap = { bySession: {}, pending: {}, main: {} }
 
     /* 同一会话里所有卡片共用一份"主刀开没开"，不然 A 卡开了 B 卡还显示关 */
     const swapShared = { value: {}, listeners: new Set() }
@@ -469,7 +501,11 @@ window.__ModuleLoader__.load({
       swap.pending[k] = fetch(API + '/swap?sessionId=' + encodeURIComponent(k))
         .then((r) => r.json())
         .then((j) => {
-          if (j && j.ok) swap.bySession[k] = !!j.on
+          if (j && j.ok) {
+            swap.bySession[k] = !!j.on
+            // 1.3.6：顺手把"这个会话现在的主模型"留住 —— 点评审前要拿它比是否重合
+            if (j.current && typeof j.current === 'object') swap.main[k] = { provider: String(j.current.provider || ''), model: String(j.current.model || '') }
+          }
           return !!swap.bySession[k]
         })
         .catch(() => !!swap.bySession[k])
@@ -698,6 +734,22 @@ window.__ModuleLoader__.load({
       // 在一张卡上开了，别的卡上的开关还显示"关"（GPT 4.6 第 4 条）。改成共用一份。
       const [swapOn, setSwapOn] = useSwap(sidKey)
 
+      // 碎碎念：正在评的时候才轮播；停了／到点了就不逗他（他 2026-11-11 要的"轻松一点"）
+      const [quipIdx, setQuipIdx] = useState(0)
+      const quipOn = !!(entry && entry.state === 'loading')
+      useEffect(() => {
+        if (!quipOn) return undefined
+        const t = setInterval(() => {
+          setQuipIdx((i) => {
+            if (THINK_LINES.length < 2) return 0
+            let n = i
+            while (n === i) n = Math.floor(Math.random() * THINK_LINES.length)
+            return n
+          })
+        }, 3200)
+        return () => clearInterval(t)
+      }, [quipOn])
+
       useEffect(() => {
         let alive = true
         loadSwap(sessionId).then((v) => {
@@ -740,6 +792,33 @@ window.__ModuleLoader__.load({
           },
           '副模型主刀' + (swapOn ? '：开' : ''),
         )
+      /* 1.3.6：这张卡这次花了多少 —— 全从日志和返回里算，不为显示数字多调一次模型。
+         复核＝副模型那次（要它真给了用量才显示）；本轮＝主模型这一轮的账（日志里本来就有）。 */
+      const fmtTok = (n) => {
+        const v = Number(n) || 0
+        if (!v) return '0'
+        return v >= 1000 ? (v / 1000).toFixed(v >= 10000 ? 0 : 1).replace(/\.0$/, '') + 'k' : String(v)
+      }
+      const usageChip = (u) => {
+        if (!u || typeof u !== 'object') return null
+        const r = u.review
+        const t = u.turn
+        const parts = []
+        if (r && (r.input || r.output)) parts.push('复核 ' + fmtTok(r.input) + '进/' + fmtTok(r.output) + '出')
+        if (t && (t.input || t.output)) parts.push('本轮 ' + fmtTok(t.input) + '进/' + fmtTok(t.output) + '出')
+        if (!parts.length) return null
+        const cache = []
+        if (r && r.cacheRead) cache.push('复核缓存读 ' + fmtTok(r.cacheRead))
+        if (t && t.cacheRead) cache.push('本轮缓存读 ' + fmtTok(t.cacheRead))
+        return React.createElement(
+          'span',
+          {
+            style: { opacity: 0.5, fontSize: FS.min, whiteSpace: 'nowrap' },
+            title: '这些数字是从会话日志和调用回执里算的，没有为显示它们多调一次模型' + (cache.length ? '；' + cache.join('，') : ''),
+          },
+          parts.join(' · '),
+        )
+      }
       const state = entry && entry.state
       const major = (entry && entry.major) || []
       const minor = (entry && entry.minor) || []
@@ -752,7 +831,7 @@ window.__ModuleLoader__.load({
         let alive = true
         loadSettings().then((v) => {
           if (alive) setAuto(!!(v && v.auto))
-          if (alive) setReviewerName(v && v.model ? String(v.model) : '')
+          if (alive) setReviewerName(v && (v.resolved || v.model) ? String(v.resolved || v.model) : '')
         })
         return () => {
           alive = false
@@ -794,11 +873,22 @@ window.__ModuleLoader__.load({
         fetch(url, {
           method: 'POST',
           headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ sessionId: sessionId || '', seq: seq, job, mock: kind === 'mock' }),
+          body: JSON.stringify({ sessionId: sessionId || '', seq: seq, job, mock: kind === 'mock', auto: kind === 'auto' }),
         })
           .then((r) => r.json())
           .then((json) => {
             if (json && json.ok) {
+              // 1.3.6：闸门跳过 —— 没花钱，也别装成评过了
+              if (json.skipped) {
+                setEntry({
+                  state: 'skipped',
+                  major: [],
+                  minor: [],
+                  note: String(json.reason || '自动评审跳过了这一轮'),
+                  auto: kind === 'auto',
+                })
+                return
+              }
               if (json.verdict === 'error') {
                 setEntry({
                   state: 'error',
@@ -834,6 +924,8 @@ window.__ModuleLoader__.load({
                 timedOut: !!json.timedOut,
                 mock: !!json.mock,
                 steps: Array.isArray(json.steps) ? json.steps : [],
+                // 1.3.6：这一次的账（主模型那轮 + 复核自己），拿不到就是 null
+                usage: json.usage || null,
               })
             } else {
               setEntry({ state: 'error', major: [], minor: [], note: String((json && json.error) || '未知原因') })
@@ -911,10 +1003,233 @@ window.__ModuleLoader__.load({
       // 手动再评：允许一次。上次是假数据就继续用假数据（别让人点一下"重评"就悄悄花了钱）
       const rerun = () => {
         inFlight.add(key)
-        run(entry && entry.mock ? 'mock' : 'manual')
+        startReview(entry && entry.mock ? 'mock' : 'manual')
         inFlight.delete(key)
       }
 
+      /* ---------------- 1.3.6：主副重合 → 点之前拦一下 ----------------
+         重合的判断：这个会话的当前主模型（/swap 顺手带回来的）和副模型是同一个。
+         只拦"用户自己点评审"这一刻；自动评审照旧在卡片上标出来，不弹窗打扰。 */
+      const [fix, setFix] = useState(null)
+      const [fixNoMore, setFixNoMore] = useState(false)
+      const [fixProviders, setFixProviders] = useState([])
+      const [fixModels, setFixModels] = useState([])
+      const fixProvider = fix ? String(fix.provider || '') : ''
+      useEffect(() => {
+        if (!fix) return undefined
+        let alive = true
+        fetch(API + '/models')
+          .then((r) => r.json())
+          .then((j) => {
+            if (alive && j && j.ok) setFixProviders(j.providers || [])
+          })
+          .catch(() => {})
+        return () => {
+          alive = false
+        }
+      }, [!!fix])
+      useEffect(() => {
+        if (!fix || !fixProvider) return undefined
+        let alive = true
+        fetch(API + '/models?provider=' + encodeURIComponent(fixProvider))
+          .then((r) => r.json())
+          .then((j) => {
+            if (alive && j && j.ok) setFixModels(j.models || [])
+          })
+          .catch(() => {})
+        return () => {
+          alive = false
+        }
+      }, [fixProvider])
+
+      const modelIdOf = (m) => String((m && typeof m === 'object' ? m.model || m.id : m) || '').trim().toLowerCase()
+      const sameAsMain = () => {
+        const main = swap.main[sidKey]
+        const s = settings.value
+        if (!main || !s || s.hideSameSourceModal) return false
+        // 自动 Pro 档时，比的是后端最终会用的那个模型（settings.resolved），不是配置里那个旧 id
+        const sub = s.modelAuto ? settings.resolved : s.model
+        return !!modelIdOf(main) && modelIdOf(main) === modelIdOf(sub)
+      }
+      const startReview = (kind) => {
+        const acked = !!(settings.value && settings.value.noticeAck)
+        if (kind !== 'mock' && acked && sameAsMain()) {
+          const s = settings.value
+          setFix({
+            provider: String(s.provider || ''),
+            model: String(s.modelAuto ? settings.resolved || s.model || '' : s.model || ''),
+            kind,
+          })
+          setFixNoMore(false)
+          return
+        }
+        run(kind)
+      }
+      const closeFix = (save) => {
+        const patch = { hideSameSourceModal: !!fixNoMore }
+        if (save && fix) {
+          patch.provider = fix.provider
+          patch.model = fix.model
+          patch.modelAuto = false
+        }
+        fetch(API + '/config', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify(patch),
+        })
+          .then((r) => r.json())
+          .then((j) => {
+            if (j && j.ok) {
+              settings.value = j.config
+              if (j.config && j.config.model) setReviewerName(String(j.config.model))
+            }
+          })
+          .catch(() => {})
+        const kind = fix && fix.kind
+        setFix(null)
+        if (save && kind) run(kind)
+      }
+      const fixOptions = (list, fallbackId) => {
+        const arr = (list && list.length ? list : [{ id: fallbackId || '', name: fallbackId || '' }])
+          .map((p) => (typeof p === 'string' ? { id: p, name: p } : { id: String((p && p.id) || ''), name: String((p && p.name) || (p && p.id) || '') }))
+          .filter((p) => p.id)
+        return arr.map((p) => React.createElement('option', { key: p.id, value: p.id }, p.name === p.id ? p.id : p.name + '（' + p.id + '）'))
+      }
+      const fixModal = () => {
+        if (!fix) return null
+        const dark = isDarkUI()
+        const bg = dark ? '#151515' : '#fdfdfd'
+        const fg = dark ? '#f3f3f3' : '#111'
+        const sub = dark ? 'rgba(243,243,243,0.62)' : 'rgba(17,17,17,0.6)'
+        const line = dark ? 'rgba(255,255,255,0.16)' : 'rgba(0,0,0,0.14)'
+        const inputBg = dark ? '#1f1f1f' : '#fff'
+        const selectStyle = {
+          width: '100%',
+          padding: '7px 8px',
+          borderRadius: 8,
+          border: '1px solid ' + line,
+          background: inputBg,
+          color: fg,
+          fontSize: FS.small,
+          marginTop: 6,
+        }
+        return React.createElement(
+          'div',
+          {
+            // 把整页压暗，只留这一个窗是亮的
+            style: {
+              position: 'fixed',
+              inset: 0,
+              background: 'rgba(0,0,0,0.58)',
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              zIndex: 9999,
+              padding: 16,
+            },
+            onClick: (e) => {
+              if (e && e.target === e.currentTarget) closeFix(false)
+            },
+          },
+          React.createElement(
+            'div',
+            {
+              style: {
+                width: 420,
+                maxWidth: '100%',
+                background: bg,
+                color: fg,
+                border: '1px solid ' + line,
+                borderRadius: 12,
+                padding: '18px 18px 14px',
+                boxShadow: '0 24px 60px rgba(0,0,0,0.45)',
+                fontSize: FS.body,
+                lineHeight: 1.7,
+              },
+            },
+            React.createElement('div', { style: { fontWeight: 600, fontSize: '1.05em', marginBottom: 4 } }, '当前主副模型重合'),
+            React.createElement(
+              'div',
+              { style: { color: sub, fontSize: FS.small, marginBottom: 12 } },
+              '副模型和主模型是同一个（' +
+                String((swap.main[sidKey] && swap.main[sidKey].model) || fix.model || '') +
+                '），等于让同一双眼睛检查自己 —— 复核效果不佳。换一个再评。',
+            ),
+            React.createElement('div', { style: { color: sub, fontSize: FS.min, marginBottom: 2 } }, '服务商'),
+            React.createElement(
+              'select',
+              {
+                value: fix.provider || '',
+                style: selectStyle,
+                onChange: (e) => setFix({ ...fix, provider: e.target.value, model: '' }),
+              },
+              ...fixOptions(fixProviders, fix.provider),
+            ),
+            React.createElement('div', { style: { color: sub, fontSize: FS.min, margin: '10px 0 2px' } }, '副模型'),
+            React.createElement(
+              'select',
+              {
+                value: fix.model || '',
+                style: selectStyle,
+                onChange: (e) => setFix({ ...fix, model: e.target.value }),
+              },
+              fix.model ? null : React.createElement('option', { key: '__none', value: '' }, '（选一个）'),
+              ...fixOptions(fixModels, ''),
+            ),
+            React.createElement(
+              'label',
+              { style: { display: 'flex', alignItems: 'center', gap: 6, marginTop: 12, color: sub, fontSize: FS.min, cursor: 'pointer' } },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: !!fixNoMore,
+                style: { accentColor: ACCENT },
+                onChange: (e) => setFixNoMore(!!e.target.checked),
+              }),
+              '不再提示',
+            ),
+            React.createElement(
+              'div',
+              { style: { display: 'flex', gap: 8, justifyContent: 'flex-end', marginTop: 16 } },
+              React.createElement(
+                'button',
+                {
+                  type: 'button',
+                  onClick: () => closeFix(false),
+                  style: {
+                    padding: '8px 16px',
+                    borderRadius: 8,
+                    background: 'transparent',
+                    color: fg,
+                    border: '1px solid ' + line,
+                    fontSize: FS.small,
+                    cursor: 'pointer',
+                  },
+                },
+                '取消',
+              ),
+              React.createElement(
+                'button',
+                {
+                  type: 'button',
+                  onClick: () => closeFix(true),
+                  style: {
+                    padding: '8px 16px',
+                    borderRadius: 8,
+                    background: ACCENT,
+                    color: '#fff',
+                    border: '1px solid transparent',
+                    fontSize: FS.small,
+                    fontWeight: 600,
+                    cursor: 'pointer',
+                  },
+                },
+                '保存并评审',
+              ),
+            ),
+          ),
+        )
+      }
+
       // 停止这次评审（0.9.0）：不设总时长之后，"能随时喊停"就是新的保险丝。
       // 只给服务端发一个标志，流那边每一块之间看一眼就收手；已经花掉的调用收不回来。
       const stop = () => {
@@ -1087,6 +1402,23 @@ window.__ModuleLoader__.load({
               ? '已等 ' + secs + ' 秒，上限 ' + Math.round(budget / 1000) + ' 秒（真实时间，不是猜的）'
               : '已等 ' + secs + ' 秒，不设上限（这条线只表示它还活着）',
           }),
+          // 碎碎念：一句一行地换，像有人在旁边用大白话垫着（到点／卡住／停止时不出现）
+          !over && !stalling && !stopping
+            ? React.createElement(
+                'div',
+                {
+                  style: {
+                    marginTop: 6,
+                    fontSize: FS.min,
+                    opacity: 0.45,
+                    whiteSpace: 'nowrap',
+                    overflow: 'hidden',
+                    textOverflow: 'ellipsis',
+                  },
+                },
+                '· ' + THINK_LINES[quipIdx % THINK_LINES.length],
+              )
+            : null,
           think
             ? React.createElement(
                 Collapse,
@@ -1115,6 +1447,20 @@ window.__ModuleLoader__.load({
         )
       }
 
+      // 1.3.6：闸门跳过（没花钱，也别装成评过了）
+      if (state === 'skipped') {
+        return React.createElement(
+          'div',
+          {
+            key: 'skipped',
+            ref: grow,
+            style: { marginTop: 10, display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap', fontSize: FS.min, opacity: 0.6 },
+          },
+          React.createElement('span', { style: { opacity: 0.9 } }, '自动评审跳过：' + String((entry && entry.note) || '这一轮没动过手').slice(0, 80)),
+          React.createElement(Btn, { tier: 'lite', onClick: () => run('manual'), title: '这一轮还是评一次（会调用副模型、花钱）' }, '还是评一下'),
+        )
+      }
+
       if (state === 'error') {
         const partial = String((entry && entry.partial) || '')
         return React.createElement(
@@ -1337,9 +1683,25 @@ window.__ModuleLoader__.load({
                   entry && entry.version ? React.createElement('span', null, '· v' + entry.version) : null,
                 )
               : null,
+            usageChip(entry && entry.usage),
+            // 1.3.5：副模型和主模型是同一个 → 这次复核基本等于自评，先说清楚（他 2026-11-11 要的）
+            entry && entry.sameSource
+              ? React.createElement(
+                  'span',
+                  {
+                    title:
+                      '主模型和副模型是同一个模型' +
+                      (entry.main && entry.main.model ? '（' + String(entry.main.model) + '）' : '') +
+                      '，独立视角接近于零。换一个不同来源、或至少不同档位的副模型才有用。',
+                    style: { color: '#f59e0b', fontSize: FS.min, whiteSpace: 'nowrap', opacity: 0.95 },
+                  },
+                  '与主模型相同 · 自评',
+                )
+              : null,
             React.createElement('span', { style: { flex: 1, minWidth: 8 } }),
             swapChip(),
           ),
+          fixModal(),
         )
       }
 
@@ -1349,7 +1711,7 @@ window.__ModuleLoader__.load({
         { style: { marginTop: 10, display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap', fontSize: FS.body } },
         React.createElement(
           Btn,
-          { tier: 'pri', onClick: () => run('manual'), title: '让 ' + (reviewerName || '副模型') + ' 挑一遍这一轮的毛病' },
+          { tier: 'pri', onClick: () => startReview('manual'), title: '让 ' + (reviewerName || '副模型') + ' 挑一遍这一轮的毛病' },
           React.createElement(Mark, { size: 14 }),
           '二次评审',
         ),
@@ -1370,6 +1732,7 @@ window.__ModuleLoader__.load({
               '（设置页没挂上：' + initErrors.join('；') + '）',
             )
           : null,
+        fixModal(),
       )
     }
 
@@ -1440,6 +1803,8 @@ window.__ModuleLoader__.load({
         String(c.provider || ''),
         String(c.model || ''),
         !!c.auto,
+        String(c.autoMode || 'every'),
+        c.modelAuto !== false,
         !!c.mock,
         !!c.allowWrite,
         Number(c.budgetSec) || 0,
@@ -1508,6 +1873,8 @@ window.__ModuleLoader__.load({
               provider: cfg.provider,
               model: cfg.model,
               auto: !!cfg.auto,
+              autoMode: cfg.autoMode === 'actions' ? 'actions' : 'every',
+              modelAuto: cfg.modelAuto !== false,
               mock: !!cfg.mock,
               allowWrite: !!cfg.allowWrite,
               budgetSec: Number(cfg.budgetSec) || 0,
@@ -1547,10 +1914,30 @@ window.__ModuleLoader__.load({
           : note || '改动不会自动保存'
       const hintColor = failedSave ? '#ef4444' : dirty ? '#f59e0b' : 'inherit'
 
+      /* 1.3.6：预设只改开关，绝不偷偷换模型 —— 最终决定权在用户手上（他 2026-11-11 的原话） */
+      const applyPreset = (p) => {
+        if (!cfg) return
+        if (p === 'light') setCfg({ ...cfg, auto: true, autoMode: 'actions', mock: false })
+        else if (p === 'delivery') setCfg({ ...cfg, auto: false, autoMode: 'every', mock: false })
+        else if (p === 'peek') setCfg({ ...cfg, auto: false, autoMode: 'every', mock: true })
+        setNote(p === 'peek' ? '已切到「只看不评」：接下来评的是假数据、不花钱' : '已套用预设 —— 点下面的保存才生效')
+      }
+
       return React.createElement(
         'div',
         { style: { padding: '4px 0', maxWidth: 620 } },
 
+        // 1.3.6：三个预设摆最上面，装完不用读文档也能选
+        React.createElement(
+          'div',
+          { style: { display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap', margin: '0 0 14px' } },
+          React.createElement('span', { style: { opacity: 0.7, minWidth: 88 } }, '预设'),
+          React.createElement(Btn, { tier: 'sec', onClick: () => applyPreset('light'), title: '日常：不每条都评，只有它动过手（写文件、跑命令、发消息）才自动评' }, '日常轻量'),
+          React.createElement(Btn, { tier: 'sec', onClick: () => applyPreset('delivery'), title: '关键交付：不自动评，你点哪一轮评哪一轮' }, '关键交付'),
+          React.createElement(Btn, { tier: 'lite', onClick: () => applyPreset('peek'), title: '先看看卡片长什么样：假数据、不花钱、不留记录' }, '只看不评'),
+          React.createElement('span', { style: { opacity: 0.45, fontSize: FS.min } }, '只改开关，模型还是你自己选'),
+        ),
+
         section(
           '01',
           '模型',
@@ -1566,7 +1953,7 @@ window.__ModuleLoader__.load({
                 Select,
                 {
                   value: cfg.provider || '',
-                  onChange: (e) => setCfg({ ...cfg, provider: e.target.value, model: '' }),
+                  onChange: (e) => setCfg({ ...cfg, provider: e.target.value, model: '', modelAuto: true }),
                 },
                 ...providerOptions.map((p) =>
                   React.createElement('option', { key: p.id, value: p.id }, p.name === p.id ? p.id : p.name + '（' + p.id + '）'),
@@ -1575,10 +1962,16 @@ window.__ModuleLoader__.load({
               React.createElement(
                 Select,
                 {
-                  value: cfg.model || '',
-                  onChange: (e) => setCfg({ ...cfg, model: e.target.value }),
+                  // 1.3.6：默认「自动 Pro 档」—— 不存具体 id，DSH 升了版本它自己跟着走
+                  value: cfg.modelAuto === false ? cfg.model || '' : '__auto__',
+                  onChange: (e) => {
+                    const v = e.target.value
+                    if (v === '__auto__') setCfg({ ...cfg, modelAuto: true })
+                    else setCfg({ ...cfg, model: v, modelAuto: false })
+                  },
                 },
-                cfg.model ? null : React.createElement('option', { key: '__none', value: '' }, '（选一个）'),
+                React.createElement('option', { key: '__auto__', value: '__auto__' }, '自动：Pro 档'),
+                cfg.modelAuto === false && cfg.model ? null : React.createElement('option', { key: '__none', value: '' }, '（手动选一个）'),
                 ...models
                   .map((m) => (typeof m === 'string' ? { id: m, name: m } : { id: String((m && m.id) || ''), name: String((m && m.name) || (m && m.id) || '') }))
                   .filter((m) => m.id)
@@ -1587,6 +1980,14 @@ window.__ModuleLoader__.load({
             ),
           ),
           React.createElement('div', { style: { opacity: 0.55, fontSize: FS.min, marginTop: 6 } }, '评审由这个模型来做；「副模型主刀」打开时，下一轮答复也换成它。'),
+          // 1.3.6：默认 Pro 档、自动跟随；手动选了别的就按你选的来
+          React.createElement(
+            'div',
+            { style: { opacity: 0.5, fontSize: FS.min, marginTop: 2 } },
+            cfg.modelAuto === false
+              ? '当前是手动指定：' + String(cfg.model || '未选') + '。想省事可以切回「自动：Pro 档」，DSH 升级后它自己跟着换。'
+              : '默认走 Pro 档（' + String((models.find((m) => /pro/i.test(String((m && m.id) || m))) || {}).id || '按你的 provider 实际清单') + '），DSH 出了新一代 Pro 会自动跟着换；主模型如果也是它，这次复核等于自评。',
+          ),
         ),
 
         section(
@@ -1595,10 +1996,34 @@ window.__ModuleLoader__.load({
           React.createElement(Check, {
             checked: cfg.auto,
             onChange: (e) => setCfg({ ...cfg, auto: e.target.checked }),
-            title: '每条回复结束后自动评一次',
-            desc: '会调用副模型，产生费用',
+            title: '自动评审',
+            desc: '会调用副模型，产生费用；评到哪一步由下面那行决定',
             style: { marginBottom: 2 },
           }),
+          // 1.3.6：闸门 —— 用户决定"每条都评"还是"只有动过手才评"
+          React.createElement(
+            'div',
+            { style: { display: 'flex', gap: 10, alignItems: 'center', flexWrap: 'wrap', margin: '2px 0 4px' } },
+            React.createElement('span', { style: { opacity: 0.7, minWidth: 88 } }, '自动评审范围'),
+            React.createElement(
+              'span',
+              { style: { marginLeft: 'auto' } },
+              React.createElement(
+                Select,
+                {
+                  value: cfg.autoMode === 'actions' ? 'actions' : 'every',
+                  onChange: (e) => setCfg({ ...cfg, autoMode: e.target.value }),
+                },
+                React.createElement('option', { key: 'every', value: 'every' }, '每条回复都评（默认）'),
+                React.createElement('option', { key: 'actions', value: 'actions' }, '只有动过手的那一轮才评'),
+              ),
+            ),
+          ),
+          React.createElement(
+            'div',
+            { style: { opacity: 0.5, fontSize: FS.min, marginBottom: 6 } },
+            '「动过手」＝写文件、跑命令、发消息，或这一轮工作区有改动；纯聊天、纯只读的问答不评。判断全在本地，不花钱。',
+          ),
           React.createElement(Check, {
             checked: cfg.mock,
             onChange: (e) => setCfg({ ...cfg, mock: e.target.checked }),

package/index.js

@@ -89,14 +89,20 @@ const MAX_CHARS = 60000
 const LEGACY_BUDGET_MS = 45000
 
 /* 版本号（0.7.0 起）：/config 会带出去，设置页「关于」直接显示，不用去翻 package.json */
-const VERSION = '1.3.4'
+const VERSION = '1.3.6'
 
 /* ---------------- 配置（副模型 + 自动评审 + 主刀） ---------------- */
 
 const DEFAULT_CONFIG = {
   provider: 'deepseek-account',
-  model: 'deepseek-flash',
+  /* 1.3.6：副模型默认走 Pro 档，而且"跟着版本走" —— modelAuto 打开时不用存具体 id，
+     每次评审现查这个 provider 的模型清单，挑名字里带 pro 的最新一代。
+     DSH 哪天把 DeepSeek-V4-Pro 换成 V4.1-Pro，装插件的人不用改设置也跟着变。 */
+  model: 'deepseek-v4-pro',
+  modelAuto: true,
   auto: false,
+  // 1.3.6：重合提示弹窗的"不再提示"（只在用户自己勾了才为 true）
+  hideSameSourceModal: false,
   mock: false,
   /* 副模型能不能改文件：默认关（2026-11-09 他选的 B）。
      关着的时候工具表里根本没有 write_file，模型连"想调"都无从下手；
@@ -115,6 +121,10 @@ const DEFAULT_CONFIG = {
      她把一条自己编出来的用户消息当成用户说的，还照着它删了信、改了记忆。
      纯本地字符串比对 —— 不调模型、不花钱、不拖慢评审。 */
   checkQuotes: true,
+  /* 1.3.6：自动评审走到哪一步才触发（用户自己选，插件只负责执行）。
+     'every'   = 每条回复都评（1.3.5 及以前的行为，默认，别偷偷改人家的习惯）
+     'actions' = 只有这一轮真动过手（写文件／跑命令／发消息／工作区有变化）才评 */
+  autoMode: 'every',
 }
 
 const CONFIG_FILE = path.join(os.homedir(), '.dsh', 'dsh-second-review', 'config.json')
@@ -927,6 +937,144 @@ export function verifyUserQuotes(rows) {
   return result
 }
 
+/* 1.3.5：主模型和副模型是不是"同一个"。
+   只判完全相同这一层：同一个 model 换个 provider，还是同一双眼睛；
+   不同 provider 的模型命名各异，硬猜"同源"会误报（小问 2026-11-10 的判断，我认同）。
+   只用来提示，不用来拦截：只有一个 Key 的人照样允许重选。 */
+export function sameModel(a, b) {
+  const pick = (x) => String((x && typeof x === 'object' ? x.model : x) || '').trim().toLowerCase()
+  const am = pick(a)
+  const bm = pick(b)
+  return !!am && am === bm
+}
+
+/* 1.3.6：Pro 档自动跟随 —— 从模型清单里挑名字带 pro 的最新一版。
+   查不到清单／清单里没有 pro，就退回配置里存的 id，绝不乱猜、也不擅自换成便宜档。 */
+export function pickProModel(list) {
+  const ids = (Array.isArray(list) ? list : [])
+    .map((m) => String((m && typeof m === 'object' ? m.id : m) || ''))
+    .filter((id) => id && /pro/i.test(id))
+  if (!ids.length) return ''
+  const ver = (id) => (id.match(/\d+(?:[._]\d+)*/g) || []).join('.').split(/[._]/).filter(Boolean).map(Number)
+  ids.sort((a, b) => {
+    const va = ver(a)
+    const vb = ver(b)
+    for (let i = 0; i < Math.max(va.length, vb.length); i++) {
+      const x = va[i] || 0
+      const y = vb[i] || 0
+      if (x !== y) return y - x
+    }
+    return a.localeCompare(b)
+  })
+  return ids[0]
+}
+
+export async function resolveReviewModel(llm, cfg) {
+  if (!cfg || cfg.modelAuto !== true) return cfg && cfg.model
+  try {
+    const list = await llm.listModels(cfg.provider)
+    const pro = pickProModel(list)
+    if (pro) return pro
+  } catch {}
+  return cfg.model
+}
+
+/* ---------------- 1.3.6：会话说得清的账，都从日志里算，不再问模型 ----------------
+   会话日志里每一轮事件都带 seq / turn，assistant/message 上带 usage：
+   {inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, totalTokens}
+   （2026-11-11 从本机真实会话解出来验过）。所以"用了多少 token"可以纯代码算，
+   不额外调一次模型、不花钱。 */
+
+function logItems(session) {
+  const log = (session && session.log) || {}
+  return Object.entries(log)
+    .map(([k, e]) => ({ seq: Number(e && e.seq) || Number(k), e }))
+    .filter((x) => Number.isFinite(x.seq))
+    .sort((a, b) => a.seq - b.seq)
+}
+
+/* 被评的那条回复属于第几轮（turn） */
+export function turnOf(session, beforeSeq) {
+  const limit = Number(beforeSeq)
+  let turn = null
+  for (const { seq, e } of logItems(session)) {
+    if (Number.isFinite(limit) && seq > limit) break
+    if (e && e.type === 'assistant/message' && e.data && typeof e.data.turn === 'number') turn = e.data.turn
+  }
+  return turn
+}
+
+/* 这一轮主模型花了多少 token（多步／多轮的都按 turn 加总） */
+export function usageOfTurn(session, beforeSeq) {
+  const turn = turnOf(session, beforeSeq)
+  if (turn === null) return null
+  const sum = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, messages: 0 }
+  for (const { e } of logItems(session)) {
+    if (!e || e.type !== 'assistant/message' || !e.data || e.data.turn !== turn) continue
+    const u = e.data.usage
+    if (!u) continue
+    sum.input += Number(u.inputTokens) || 0
+    sum.output += Number(u.outputTokens) || 0
+    sum.cacheRead += Number(u.cacheReadTokens) || 0
+    sum.cacheWrite += Number(u.cacheWriteTokens) || 0
+    sum.total += Number(u.totalTokens) || 0
+    sum.messages += 1
+  }
+  return sum.messages ? sum : null
+}
+
+/* 这一轮到底动没动手：写文件／跑命令／发消息／工作区有变化才算。
+   纯聊天、纯只读的问答不算 —— 这正是"省钱的闸门"的判据。 */
+const ACTION_TOOL_RE = /(write|edit|delete|remove|move|rename|mkdir|patch|shell|bash|pwsh|powershell|exec|spawn|install|upload|send|post|publish|run)/i
+
+export function turnTouched(session, beforeSeq) {
+  const turn = turnOf(session, beforeSeq)
+  if (turn === null) return false
+  let touched = false
+  for (const { e } of logItems(session)) {
+    if (!e || !e.data || e.data.turn !== turn) continue
+    if (e.type === 'workspace/changes') return true
+    if (e.type === 'tool/call' && ACTION_TOOL_RE.test(String(e.data.name || ''))) touched = true
+  }
+  return touched
+}
+
+/* 评审自己那几次调用，finish 里要是带 usage 就取出来；没带就返回 null（不编数字）。 */
+export function usageOfFinish(finish) {
+  if (!finish || typeof finish !== 'object') return null
+  const u =
+    finish.usage ||
+    (finish.message && finish.message.usage) ||
+    (finish.result && finish.result.usage) ||
+    (finish.data && finish.data.usage) ||
+    null
+  if (!u || typeof u !== 'object') return null
+  const n = (x) => Number(x) || 0
+  const input = n(u.inputTokens || u.input_tokens || u.promptTokens)
+  const output = n(u.outputTokens || u.output_tokens || u.completionTokens)
+  const cacheRead = n(u.cacheReadTokens || u.cache_read_tokens)
+  const cacheWrite = n(u.cacheWriteTokens || u.cache_write_tokens)
+  if (!input && !output && !cacheRead && !cacheWrite) return null
+  return { input, output, cacheRead, cacheWrite, total: input + output }
+}
+
+/* 把一次评审里每一步的用量加起来（带工具时会有好几次调用） */
+export function sumUsage(list) {
+  if (!Array.isArray(list) || !list.length) return null
+  const sum = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  let any = false
+  for (const u of list) {
+    if (!u) continue
+    any = true
+    sum.input += Number(u.input) || 0
+    sum.output += Number(u.output) || 0
+    sum.cacheRead += Number(u.cacheRead) || 0
+    sum.cacheWrite += Number(u.cacheWrite) || 0
+    sum.total += Number(u.total) || 0
+  }
+  return any ? sum : null
+}
+
 export function saveReview(rootDir, review, steps, meta) {
   try {
     const dir = path.join(rootDir, '二次评审')
@@ -1249,14 +1397,22 @@ export function apply(ctx) {
           if (body && typeof body.mock === 'boolean') patch.mock = body.mock
           if (body && typeof body.allowWrite === 'boolean') patch.allowWrite = body.allowWrite
           if (body && typeof body.noticeAck === 'boolean') patch.noticeAck = body.noticeAck
+          // 1.3.6：Pro 档自动跟随；重合弹窗的"不再提示"
+          if (body && typeof body.modelAuto === 'boolean') patch.modelAuto = body.modelAuto
+          if (body && typeof body.hideSameSourceModal === 'boolean') patch.hideSameSourceModal = body.hideSameSourceModal
           // 0.9.0：两个闸都能从设置页改，夹到合理区间（0 ＝ 不设）
           if (body && Number.isFinite(Number(body.budgetSec))) patch.budgetSec = Math.max(0, Math.min(1800, Math.round(Number(body.budgetSec))))
           if (body && Number.isFinite(Number(body.idleSec))) patch.idleSec = Math.max(0, Math.min(1800, Math.round(Number(body.idleSec))))
           // 1.1.0：引文核验的开关（默认开，纯本地比对，不花钱）
           if (body && typeof body.checkQuotes === 'boolean') patch.checkQuotes = body.checkQuotes
-          return sendJson(res, 200, { ok: true, config: writeConfig(patch), file: CONFIG_FILE, version: VERSION })
+          // 1.3.6：自动评审范围，只认这两个值（别让乱七八糟的值把闸门关死）
+          if (body && (body.autoMode === 'every' || body.autoMode === 'actions')) patch.autoMode = body.autoMode
+          const saved = writeConfig(patch)
+          // 1.3.6：顺手把"自动跟着走"最终落到哪个模型告诉前端（设置页和卡片都要显示它）
+          return sendJson(res, 200, { ok: true, config: saved, resolvedModel: await resolveReviewModel(scope.get('llm'), saved), file: CONFIG_FILE, version: VERSION })
         }
-        return sendJson(res, 200, { ok: true, config: readConfig(), file: CONFIG_FILE, version: VERSION })
+        const cfg = readConfig()
+        return sendJson(res, 200, { ok: true, config: cfg, resolvedModel: await resolveReviewModel(scope.get('llm'), cfg), file: CONFIG_FILE, version: VERSION })
       } catch (error) {
         return sendErr(res, error)
       }
@@ -1306,6 +1462,29 @@ export function apply(ctx) {
       }
     }
 
+    /* 1.3.5：这个会话"现在的主模型"是谁。
+       走 DSH 自己的 agent.model.current()（副模型主刀也用它）；
+       读不到就返回 null —— 卡片上不显示提示，绝不为了一句提示去猜。 */
+    const currentMain = (sid) => {
+      try {
+        const agents = scope.get('agents')
+        const live = agents && typeof agents.list === 'function' ? agents.list() : []
+        const normId = (v) => String(v || '').replace(/^session-/, '')
+        const hit = (Array.isArray(live) ? live : []).find((a) => {
+          try {
+            return a && (normId(a.id) === normId(sid) || (a.session && normId(a.session.id) === normId(sid)))
+          } catch {
+            return false
+          }
+        })
+        const cur = hit && hit.model && typeof hit.model.current === 'function' ? hit.model.current() : null
+        if (!cur) return null
+        return { provider: String(cur.provider || ''), model: String(cur.model || '') }
+      } catch {
+        return null
+      }
+    }
+
     // 副模型主刀：把这一轮"谁在答"换成副模型（走 DSH 官方的 agent.model.select，不碰消息归属）
     // 状态按会话分开存：A 会话开了主刀，不会把 B 会话的"原来的模型"覆盖掉。
     const swap = async (req, res) => {
@@ -1383,6 +1562,8 @@ export function apply(ctx) {
         if (!llm) return sendJson(res, 503, { ok: false, error: 'llm service missing' })
 
         let rows = []
+        // 1.3.6：闸门和用量都要会话原始日志，先把找到的那份留住（demo 探针没有，就是 null）
+        let sessionObj = null
         const cfg = readConfig()
 
         // 进度：前端带着 job=来的，就边跑边往里写"想什么"（只进内存，不进记录）
@@ -1423,8 +1604,11 @@ export function apply(ctx) {
         const entry = sidKey ? readSwaps(cfg)[sidKey] : null
         const reviewCfg =
           !demo && entry && entry.saved && entry.saved.provider && entry.saved.model
-            ? { ...cfg, provider: entry.saved.provider, model: entry.saved.model }
+            ? { ...cfg, provider: entry.saved.provider, model: entry.saved.model, modelAuto: false }
             : cfg
+        // 1.3.6：Pro 档跟着版本走（只在 modelAuto 打开时生效；主刀互换时用的是原主模型，不动）
+        const runModel = await resolveReviewModel(llm, reviewCfg)
+        const runCfg = runModel && runModel !== reviewCfg.model ? { ...reviewCfg, model: runModel } : reviewCfg
 
         let rootDir = null
         if (demo) {
@@ -1459,6 +1643,7 @@ export function apply(ctx) {
             if (hit && hit.session) {
               rootDir = makeRoot(rootOf(hit.session))
               rows = transcriptOf(hit.session, anchor)
+              sessionObj = hit.session
             } else {
               return sendJson(res, 404, {
                 ok: false,
@@ -1469,9 +1654,21 @@ export function apply(ctx) {
           } else {
             rootDir = makeRoot(rootOf(session))
             rows = transcriptOf(session, anchor)
+            sessionObj = session
           }
         }
 
+        /* 1.3.6：闸门。用户把 autoMode 设成 'actions' 时，纯聊天的轮次不调副模型 —— 直接跳过。
+           判断全在本地（看这轮有没有写文件／跑命令／发消息），不花钱、不猜。 */
+        if (!demo && body.auto === true && String(cfg.autoMode || 'every') === 'actions' && !turnTouched(sessionObj, anchor)) {
+          return sendJson(res, 200, {
+            ok: true,
+            skipped: true,
+            reason: '这一轮没动过手（没写文件、没跑命令、没发消息），自动评审跳过了',
+            gate: 'actions',
+          })
+        }
+
         if (rows.length === 0) return sendJson(res, 200, { ok: true, empty: true, verdict: 'pass', note: '这一轮还没有对话内容', major: [], minor: [], steps: 0 })
 
         // 引文核验（1.1.0）：在动模型之前先把"有没有编出来的用户原话"查一遍 —— 纯本地，零成本
@@ -1493,6 +1690,8 @@ export function apply(ctx) {
         const allowWrite = cfg.allowWrite === true
         const steps = []
         const finishes = []
+        // 1.3.6：评审自己每次调用的用量（finish 里带就收，不带就空着，绝不估算）
+        const usages = []
         let finalText = ''
         let budget = 0
         let timedOut = false
@@ -1523,7 +1722,8 @@ export function apply(ctx) {
             break
           }
           // 工具不设次数上限（他 2026-11-09 明确说过：磨洋工是"看不该看的、说不该说的"，不是限次数）
-          const r = await streamWithRetry(llm, messages, tools, reviewCfg, onDelta, deadlineAt, stopOpts)
+          const r = await streamWithRetry(llm, messages, tools, runCfg, onDelta, deadlineAt, stopOpts)
+          usages.push(usageOfFinish(r.finish))
           finishes.push({
             step: i,
             kind: r.finish && r.finish.kind,
@@ -1551,7 +1751,7 @@ export function apply(ctx) {
           messages.push({
             role: 'assistant',
             id: randomUUID(),
-            source: { kind: 'assistant', provider: reviewCfg.provider, model: reviewCfg.model },
+            source: { kind: 'assistant', provider: runCfg.provider, model: runCfg.model },
             ...(r.replayState ? { replayState: r.replayState } : {}),
             content: blocks,
           })
@@ -1650,12 +1850,16 @@ export function apply(ctx) {
         const swapped = !demo && !!(entry && entry.saved && entry.saved.provider && entry.saved.model)
         const reviewer = {
           provider: String(reviewCfg.provider || ''),
-          model: String(reviewCfg.model || ''),
+          model: String(runCfg.model || ''),
           role: swapped ? '原主模型（副模型主刀时互换）' : '副模型',
         }
+        /* 1.3.5：这一评是"换了个脑子"，还是"同一双眼睛又看了一遍"？
+           主模型从 DSH 的 agent.model.current() 现取；读不到就是 null，卡片上不提示 —— 不猜。 */
+        const main = demo ? null : currentMain(sessionId)
+        const sameSource = !!(main && sameModel(main, reviewer))
         const saved = demo
           ? ''
-          : saveReview(rootDir, parsed, steps, { sessionId, seq: anchor, model: reviewCfg.provider + ' / ' + reviewCfg.model, reviewer, provenance })
+          : saveReview(rootDir, parsed, steps, { sessionId, seq: anchor, model: runCfg.provider + ' / ' + runCfg.model, reviewer, provenance })
         const payload = {
           ok: true,
           topic: parsed.topic,
@@ -1670,12 +1874,20 @@ export function apply(ctx) {
           items: [...parsed.major, ...parsed.minor],
           saved,
           reviewer,
+          // 1.3.5：主模型是谁、和副模型是不是同一个（同一个＝这次复核基本是自评）
+          main,
+          sameSource,
           // 1.1.0：引文核验结果（机器查的，不靠模型）。checked=0 就是这一轮它没引你的话
           provenance,
           // 这张卡是哪个版本画出来的（0.9.0 加）—— 他遇到过一次"改了没生效"
           version: VERSION,
           // 这一轮到底花了多久（0.9.1）：5 分钟那种，卡上得看得见
           elapsedMs: Date.now() - startedAt,
+          // 1.3.6：这一轮主模型的用量（从会话日志算，零成本）＋ 复核自己的用量（finish 带才算）
+          usage: {
+            turn: demo ? null : usageOfTurn(sessionObj, anchor),
+            review: sumUsage(usages),
+          },
           parseFailed: parsed.parseFailed,
           truncated,
           timedOut,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-second-review",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "二次评审：每条回复下面挂一张独立的副模型评审卡。让一个模型干活、另一个模型检查，结果挂在原回复下面，不重复回答、不抢占主模型。",
   "type": "module",
   "main": "index.js",

package/test/client.smoke.mjs

@@ -102,6 +102,11 @@ function barOf(el) {
   const bar = walk(el).find((n) => n.props && n.props.style && n.props.style.height === 2)
   return bar && bar.kids && bar.kids[0]
 }
+function tiersOf(el) {
+  return walk(el)
+    .filter((n) => typeof n.type === 'function' && n.type.name === 'Btn')
+    .map((n) => n.props.tier)
+}
 function assert(cond, msg) {
   if (!cond) throw new Error(msg)
 }
@@ -132,11 +137,27 @@ const cases = [
       // 1.1.0：引文核验（机器查的，不靠模型）
       provenance: { checked: 2, found: 1, missing: ['我什么时候说让你回信了'], userCount: 6 },
       reviewer: { provider: 'deepseek-account', model: 'deepseek-flash', role: '副模型' },
+      // 1.3.6：这一次的账（复核＋本轮）
+      usage: { review: { input: 1234, output: 567, cacheRead: 0 }, turn: { input: 1534, output: 443, cacheRead: 14720 } },
     },
   ],
   ['完成 通过', { state: 'done', verdict: 'pass', note: '没发现必须改的地方。', major: [], minor: [] }],
+  [
+    '完成 与主模型相同',
+    {
+      state: 'done',
+      verdict: 'pass',
+      note: '',
+      major: [],
+      minor: [],
+      reviewer: { provider: 'deepseek-account', model: 'deepseek-flash', role: '副模型' },
+      main: { provider: 'deepseek-account', model: 'deepseek-flash' },
+      sameSource: true,
+    },
+  ],
   ['完成 说不清', { state: 'done', verdict: 'unclear', note: '它说不清这一轮在评什么', major: [], minor: [] }],
   ['失败', { state: 'error', note: 'provider 断流' }],
+  ['闸门跳过', { state: 'skipped', note: '这一轮没动过手（没写文件、没跑命令、没发消息），自动评审跳过了' }],
   ['首次告知', { state: 'notice', pendingKind: 'manual' }],
 ]
 
@@ -154,6 +175,7 @@ for (const [label, value] of cases) {
     assert(fill.props.style.width === '51.11%', '细线宽度不对：' + fill.props.style.width + '（应为 23000/45000）')
     assert(fill.props.style.background !== '#f59e0b', '还没到点就变琥珀了')
     assert(text.indexOf('字幕最后一行在这里') >= 0, '字幕没露出来')
+    assert(text.indexOf('帮你理一理') >= 0, '碎碎念（思考中的那句）没画出来')
   }
   if (label === '评审中 到点') {
     const fill = barOf(el)
@@ -178,7 +200,17 @@ for (const [label, value] of cases) {
     assert(tiers.filter((t) => t === 'pri').length === 1, '未评这排应该正好一个主按钮，实际 ' + JSON.stringify(tiers))
     assert(tiers.filter((t) => t === 'sec').length >= 1, '次按钮没画出来：' + JSON.stringify(tiers))
   }
+  if (label === '完成 与主模型相同') {
+    assert(text.indexOf('与主模型相同') >= 0, '副模型和主模型是同一个时，卡片上没提示')
+  }
+  if (label === '闸门跳过') {
+    assert(text.indexOf('自动评审跳过') >= 0, '跳过了却没写出来')
+    assert(tiersOf(el).indexOf('pri') < 0, '跳过以后不该再摆一个主按钮（还没花钱，别催他）')
+  }
   if (label === '完成 一剑封喉') {
+    assert(text.indexOf('复核 1.2k进') >= 0, '卡片末尾没显示复核的 token')
+    assert(text.indexOf('本轮 1.5k进') >= 0, '卡片末尾没显示这一轮的 token')
+    assert(text.indexOf('与主模型相同') < 0, '两模型不同却报了"与主模型相同"')
     assert(text.indexOf('deepseek-flash') >= 0, '卡片上没有署名（模型名）')
     assert(text.indexOf('署名') >= 0, '卡片上没写"署名"两个字')
     assert(text.indexOf('引文核验') >= 0, '卡片上没有引文核验那一行')

package/test/core.test.mjs

@@ -25,7 +25,7 @@ fs.writeFileSync(path.join(ROOT, '记忆卡', '00-核心记忆卡.md'), '私人
 fs.writeFileSync(path.join(ROOT, '普通文档.md'), '公开的')
 
 const mod = await import(new URL('../index.js', import.meta.url).href)
-const { parseReview, sanitizeReview, blockedPath, clipTranscript, transcriptOf, toolsFor, runTool, saveReview, shouldNudge, streamWithRetry, verifyUserQuotes, READ_TOOLS, WRITE_TOOL } = mod
+const { parseReview, sanitizeReview, blockedPath, clipTranscript, transcriptOf, toolsFor, runTool, saveReview, shouldNudge, streamWithRetry, verifyUserQuotes, sameModel, turnOf, usageOfTurn, turnTouched, usageOfFinish, sumUsage, pickProModel, resolveReviewModel, READ_TOOLS, WRITE_TOOL } = mod
 
 test.after(() => {
   try {
@@ -764,3 +764,120 @@ test('落盘 md 带引文核验一节', () => {
     fs.rmSync(dir, { recursive: true, force: true })
   }
 })
+
+/* ---------------- 1.3.5：主副模型是不是同一个 ---------------- */
+
+test('同一个模型：忽略大小写和首尾空格', () => {
+  assert.equal(sameModel({ provider: 'deepseek-account', model: 'deepseek-flash' }, { provider: 'deepseek-account', model: ' DeepSeek-Flash ' }), true)
+})
+
+test('同一个模型名、provider 不同也算同一个（还是同一双眼睛）', () => {
+  assert.equal(sameModel({ provider: 'a', model: 'deepseek-flash' }, { provider: 'b', model: 'deepseek-flash' }), true)
+})
+
+test('不同模型不算；缺模型也不算（宁可不说，不许瞎说）', () => {
+  assert.equal(sameModel({ provider: 'a', model: 'deepseek-flash' }, { provider: 'a', model: 'deepseek-pro' }), false)
+  assert.equal(sameModel({ provider: 'a', model: '' }, { provider: 'a', model: '' }), false)
+  assert.equal(sameModel(null, { provider: 'a', model: 'deepseek-flash' }), false)
+  assert.equal(sameModel(undefined, undefined), false)
+})
+
+test('也吃字符串（别的地方可能只传模型名）', () => {
+  assert.equal(sameModel('deepseek-flash', { model: 'deepseek-flash' }), true)
+  assert.equal(sameModel('deepseek-flash', 'deepseek-pro'), false)
+})
+
+/* ---------------- 1.3.6：账从日志里算（不调模型）＋自动评审闸门 ---------------- */
+
+function fakeSession(extra = {}) {
+  return {
+    log: {
+      1: { type: 'user/message', seq: 1, data: { turn: 1 } },
+      2: { type: 'assistant/message', seq: 2, data: { turn: 1, usage: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 3, totalTokens: 15 } } },
+      3: { type: 'tool/call', seq: 3, data: { turn: 1, name: 'read_file', arguments: '{}' } },
+      4: { type: 'assistant/message', seq: 4, data: { turn: 1, usage: { inputTokens: 20, outputTokens: 7, cacheReadTokens: 1, totalTokens: 27 } } },
+      ...extra,
+    },
+  }
+}
+
+test('轮次：按被评的那条消息往前找 turn', () => {
+  assert.equal(turnOf(fakeSession(), 4), 1)
+  assert.equal(turnOf(fakeSession(), 2), 1)
+  assert.equal(turnOf({ log: {} }, 4), null)
+})
+
+test('这一轮主模型用了多少 token：按 turn 加总，不调模型', () => {
+  const u = usageOfTurn(fakeSession(), 4)
+  assert.equal(u.input, 30)
+  assert.equal(u.output, 12)
+  assert.equal(u.cacheRead, 4)
+  assert.equal(u.messages, 2)
+  assert.equal(usageOfTurn({ log: {} }, 4), null)
+})
+
+test('闸门：只读工具不算动手', () => {
+  assert.equal(turnTouched(fakeSession(), 4), false)
+})
+
+test('闸门：写文件／跑命令／工作区变动都算动手', () => {
+  assert.equal(turnTouched(fakeSession({ 3: { type: 'tool/call', seq: 3, data: { turn: 1, name: 'write_file' } } }), 4), true)
+  assert.equal(turnTouched(fakeSession({ 3: { type: 'tool/call', seq: 3, data: { turn: 1, name: 'pwsh' } } }), 4), true)
+  assert.equal(turnTouched(fakeSession({ 5: { type: 'workspace/changes', seq: 5, data: { turn: 1 } } }), 4), true)
+})
+
+test('评审自己的用量：finish 里带就取，几种形状都认，没有就 null（不许估）', () => {
+  assert.deepEqual(usageOfFinish({ usage: { inputTokens: 100, outputTokens: 20, cacheReadTokens: 900 } }), {
+    input: 100,
+    output: 20,
+    cacheRead: 900,
+    cacheWrite: 0,
+    total: 120,
+  })
+  assert.equal(usageOfFinish({ message: { usage: { input_tokens: 5, output_tokens: 6 } } }).total, 11)
+  assert.equal(usageOfFinish({ kind: 'completed' }), null)
+  assert.equal(usageOfFinish(null), null)
+})
+
+test('多步评审的用量按次相加', () => {
+  const sum = sumUsage([
+    { input: 100, output: 20, cacheRead: 0, cacheWrite: 0, total: 120 },
+    null,
+    { input: 50, output: 5, cacheRead: 30, cacheWrite: 0, total: 55 },
+  ])
+  assert.equal(sum.input, 150)
+  assert.equal(sum.output, 25)
+  assert.equal(sum.cacheRead, 30)
+  assert.equal(sumUsage([null, undefined]), null)
+  assert.equal(sumUsage([]), null)
+})
+
+/* ---------------- 1.3.6：默认副模型＝自动 Pro 档 ---------------- */
+
+test('从模型清单里挑 Pro 档', () => {
+  const list = [{ id: 'deepseek-flash' }, { id: 'deepseek-v4-pro', name: 'V4-Pro' }]
+  assert.equal(pickProModel(list), 'deepseek-v4-pro')
+})
+
+test('出了新一代 Pro，自动选新的（DSH 升级不用改设置）', () => {
+  assert.equal(pickProModel(['deepseek-v4-pro', 'deepseek-v4.1-pro']), 'deepseek-v4.1-pro')
+  assert.equal(pickProModel([{ id: 'deepseek-v5-pro' }, { id: 'deepseek-v4.1-pro' }]), 'deepseek-v5-pro')
+})
+
+test('清单里没有 Pro：不乱选一个便宜的充数', () => {
+  assert.equal(pickProModel(['deepseek-flash']), '')
+  assert.equal(pickProModel([]), '')
+  assert.equal(pickProModel(null), '')
+})
+
+test('手动指定模型时不去查清单、也不改人家的选择', async () => {
+  let called = 0
+  const llm = { listModels: async () => (called++, []) }
+  assert.equal(await resolveReviewModel(llm, { provider: 'x', model: 'my-model', modelAuto: false }), 'my-model')
+  assert.equal(called, 0)
+})
+
+test('自动档但查不到清单：退回配置里的 id，不报错', async () => {
+  const llm = { listModels: async () => { throw new Error('offline') } }
+  assert.equal(await resolveReviewModel(llm, { provider: 'x', model: 'deepseek-v4-pro', modelAuto: true }), 'deepseek-v4-pro')
+})