@sidady/dsh-steward 0.9.14 → 0.9.16

package/lib/report.js

@@ -416,10 +416,99 @@ function versionDirection(a, b) {
   return verCmp(a, b);
 }
 
-export function collectUpdates(paths, io, errors) {
+function shortHash(text) {
+  let h = 5381;
+  for (let i = 0; i < text.length; i += 1) h = ((h * 33) ^ text.charCodeAt(i)) >>> 0;
+  return h.toString(16).padStart(8, '0');
+}
+
+function hostVersionFromCrashes(crashes) {
+  for (const c of crashes || []) {
+    const app = c && c.meta && c.meta.app;
+    if (typeof app !== 'string') continue;
+    const m = /\s(\d+\.\d+\.\d+[^\s]*)/.exec(app);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+export function collectFreeLaneHealth(paths, io) {
+  const NL2 = String.fromCharCode(10);
+  const file = path.join(paths.dshHome, 'our-free-model', 'availability.json');
+  const raw = io.readText(file);
+  const skipped = { available: false, reason: '没有读到 our-free-model 的运行台账', checked: 0, staleCount: 0, newestAt: null, failing: [], contradictory: [], allStale: false };
+  if (!raw || raw.__error || !String(raw).trim()) return skipped;
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch (e) { return { ...skipped, reason: '运行台账无法解析' }; }
+  const results = (parsed && parsed.results) || {};
+  const entries = Object.entries(results).filter(([, v]) => v && typeof v === 'object');
+  let staleCount = 0;
+  let newestAt = null;
+  const failing = [];
+  const contradictory = [];
+  for (const [name, v] of entries) {
+    if (v.stale === true) staleCount += 1;
+    const at = typeof v.at === 'string' || typeof v.at === 'number' ? String(v.at) : '';
+    if (at && (!newestAt || at > newestAt)) newestAt = at;
+    const detail = typeof v.detail === 'string' ? v.detail.trim() : '';
+    if (!detail) continue;
+    failing.push({ name, state: String(v.state || ''), detail: detail.slice(0, 160) });
+    if (String(v.state) === 'available') contradictory.push({ name, detail: detail.slice(0, 160) });
+  }
+  return {
+    available: true, reason: null, checked: entries.length, staleCount, newestAt,
+    failing, contradictory, allStale: entries.length > 0 && staleCount === entries.length,
+  };
+}
+
+export function analyzeUpgrades(outdated, packages, hostVersion) {
+  const NL = String.fromCharCode(10);
+  const rows = (outdated || []).map((u) => {
+    const meta = (packages && packages[u.name]) || {};
+    const versions = Array.isArray(meta.versions) ? meta.versions : [];
+    let skipped = 0;
+    for (const v of versions) {
+      if (versionDirection(v, u.installed) > 0 && versionDirection(v, u.latest) < 0) skipped += 1;
+    }
+    const enginesDsh = meta.engines && typeof meta.engines.dsh === 'string' ? meta.engines.dsh : null;
+    const hostFit = enginesDsh && hostVersion ? satisfiesRange(enginesDsh, hostVersion) : null;
+    let risk = 'low';
+    const reasons = [];
+    if (hostFit === false) { risk = 'high'; reasons.push('新版本声明的宿主版本门槛与当前宿主不符，升了可能直接起不来'); }
+    if (String(u.latest).indexOf('-') >= 0) { if (risk === 'low') risk = 'medium'; reasons.push('目标版本带预览/预发布后缀，稳定性未经充分验证'); }
+    if (skipped >= 5) { if (risk === 'low') risk = 'medium'; reasons.push('中间跨过 ' + skipped + ' 个已发布版本，变更面较大'); }
+    if (!reasons.length) reasons.push('未发现宿主门槛/预览版/跨版本信号，属常规小步更新');
+    return { name: u.name, installed: u.installed, latest: u.latest, skipped, enginesDsh, hostFit, risk, reasons };
+  });
+  const fingerprint = shortHash(rows.map((r) => r.name + '@' + r.installed + '->' + r.latest).sort().join('|'));
+  const high = rows.filter((r) => r.risk === 'high');
+  const medium = rows.filter((r) => r.risk === 'medium');
+  const low = rows.filter((r) => r.risk === 'low');
+  const riskLines = [
+    high.length ? '· 高风险（先别升）：' + high.map((r) => r.name + '（' + r.reasons[0] + '）').join('、') : null,
+    medium.length ? '· 需留意：' + medium.map((r) => r.name + '（' + r.reasons[0] + '）').join('、') : null,
+    low.length ? '· 可照常安排：' + low.map((r) => r.name).join('、') : null,
+  ].filter(Boolean);
+  const text = [
+    '优点：跟随上游维护、与依赖/宿主版本对齐、减少长期停留在旧版带来的碎片；只读版本清单，没有 changelog，不编造具体修复内容。',
+    '风险：升级是「插件变更 → boot 风险」的上游；一次装错会让整个 Web UI 起不来。',
+    '分级：' + (riskLines.length ? riskLines.join(' ') : '无'),
+  ].join(NL);
+  const recommendation = [
+    '按风险从低到高逐个升、一次只升一个，升完看「启动诊断」；高风险项先确认宿主版本或等后续修复，不要在要赶活的时候动它们。',
+    '升级前确认真能备份到当前可用状态。管家只读分析、不代升级。',
+  ].join(NL);
+  return {
+    outdatedCount: rows.length, rows, fingerprint, text, recommendation,
+    toastTitle: rows.length + ' 个插件有新版本：附风险与处理建议',
+    toastBody: text + NL + recommendation,
+  };
+}
+
+export function collectUpdates(paths, io, errors, hostVersion) {
   const file = path.join(paths.dshHome, 'plugin-update-cache.json');
   const raw = io.readText(file);
-  const empty = { available: false, reason: '没有找到市场更新缓存', outdated: [], checked: 0, cacheAgeHours: null };
+  const empty = { available: false, reason: '没有找到市场更新缓存', outdated: [], checked: 0, cacheAgeHours: null, advice: null };
   // Optional source, same rule as the workspace index: absence is information
   // (and gets surfaced by the confidence layer), not a degraded report.
   if (!raw || raw.__error || !String(raw).trim()) return empty;
@@ -479,7 +568,8 @@ export function collectUpdates(paths, io, errors) {
   }
   outdated.sort((a, b) => a.name.localeCompare(b.name));
   aheadOfCache.sort((a, b) => a.name.localeCompare(b.name));
-  return { available: true, reason: null, outdated, aheadOfCache, checked, undetermined, cacheAgeHours };
+  const advice = analyzeUpgrades(outdated, packages, hostVersion);
+  return { available: true, reason: null, outdated, aheadOfCache, checked, undetermined, cacheAgeHours, advice };
 }
 
 /**
@@ -575,7 +665,7 @@ function scoreFindings(findings, ctx) {
     // A stale crash does NOT count: its disable action is blocked by the
     // attribution gate, so promising a shortcut there would be dishonest.
     const gateBlocked = f.id === 'boot-crash-latest' && f.data && f.data.stale === true;
-    if (ACTIONABLE_IDS.has(f.id) && !f.muted && !gateBlocked) {
+    if (ACTIONABLE_IDS.has(f.id) && !f.muted && !f.falsePositive && !gateBlocked) {
       score += 15; reasons.push('有直达处置动作 +15');
     } else if (gateBlocked) {
       reasons.push('处置被归因门封锁，不计可直达');
@@ -606,6 +696,7 @@ function scoreFindings(findings, ctx) {
       if (kinds > 0) mag += Math.min(10, kinds * 4);
     }
     if (mag) { score += mag; reasons.push('体量/条数 +' + mag); }
+    if (f.falsePositive) { score -= 40; reasons.push('用户标记判错 -40'); }
 
     score = Math.max(0, Math.min(100, Math.round(score)));
     f.score = score;
@@ -857,6 +948,93 @@ function collectClientIdentity(paths, io, errors) {
   return { entries, sameReal, drifted, collisions, unreadable, withoutId, scanned };
 }
 
+/**
+ * v0.9.15: turn 'better / worse / flat' into one Chinese sentence on the
+ * server. The client only renders it (USER.md: GUI is for humans, the host
+ * computes the words). previous is last run's persisted report; current is
+ * this run's { level, counts }. worseningStreak rides along in the report so
+ * consecutive declines can be counted without a second data store.
+ */
+/**
+ * v0.9.16 · L0 当班台账的「判断 + 回报」纯函数。
+ *
+ * 这一版的管家会自己按时醒来体检（不带人、不带面板），但**只观察、不动手**：
+ * 任何写动作都不做。为了不把「没做事」写成一片空白，每班都留一条能被人
+ * 读懂的记录：看了什么、判断是什么、做了没做、为什么没做。
+ *
+ * 纯函数，不碰文件、不碰时钟（at 由调用方传），便于 smoke 直接喂夹具断言。
+ * 服务端算好人话、客户端只渲染（USER.md）：这里产出的就是那句人话。
+ */
+export function dutyBriefing(report, options = {}) {
+  const at = typeof options.at === 'string' ? options.at : new Date().toISOString();
+  const trigger = String(options.trigger || 'scheduled');
+  const findings = report && Array.isArray(report.findings) ? report.findings : [];
+  const counts = report && report.summary && report.summary.counts ? report.summary.counts : null;
+  const level = report && report.summary ? String(report.summary.level || 'unknown') : 'unknown';
+  const trend = report && report.trendVerdict ? report.trendVerdict : null;
+
+  // 看了什么：按级别数一遍，明确区分「静音/判错」与「还在报的」。
+  const live = findings.filter((f) => !f.muted && !f.falsePositive);
+  const seen = '看了 ' + findings.length + ' 条发现'
+    + (counts ? '(严重 ' + (counts.critical || 0) + ' · 留意 ' + (counts.warning || 0) + ' · 提示 ' + (counts.info || 0) + ')' : '')
+    + '，其中 ' + live.length + ' 条仍在报。';
+
+  // 判断：趋势结论服务端已经算成人话，直接引用；没有就给当前级别。
+  const verdict = trend && trend.text
+    ? trend.text
+    : (level === 'warning' ? '这一班有需要留意的项目，但没有严重问题。'
+      : level === 'critical' ? '这一班出现了严重问题，已留待你处置。'
+        : '这一班没有需要留意的问题。');
+
+  // 预备建议：把仍在报、且给了 recommendation 的 finding 提炼成清单（零副作用）。
+  // 只取非静音、非判错的，且最多 6 条——避免把整份报告复述一遍。
+  const suggestions = live
+    .filter((f) => typeof f.recommendation === 'string' && f.recommendation.trim())
+    .slice(0, 6)
+    .map((f) => ({ id: f.id, severity: f.severity, text: f.recommendation.trim() }));
+
+  // 做了没做 / 为什么没做：L0 的硬边界，写死且说清，别让「没做事」显得像漏了。
+  const action = '未执行任何动作：L0 是观察档，管家只体检、只把建议备好，不代替你按确认。'
+    + (suggestions.length
+      ? '已把 ' + suggestions.length + ' 条处置建议预备好，等你来动作中心确认。'
+      : '这一班没有需要预备的处置建议。');
+
+  return {
+    at,
+    trigger,
+    level,
+    counts: counts || null,
+    seen,
+    verdict,
+    action,
+    suggestions,
+    state: 'observe-only',
+    executed: 0,
+  };
+}
+
+export function summarizeTrend(previous, current) {
+  const cur = current || {};
+  const rank = (lv) => (lv === 'critical' ? 3 : lv === 'warning' ? 2 : 0);
+  const bad = (c) => (Number(c && c.critical) || 0) * 3 + (Number(c && c.warning) || 0) + rank(cur.level) * 2;
+  const curBad = bad(cur.counts);
+  const prev = previous && previous.summary ? previous.summary : null;
+  if (!prev) return { state: 'stable', worseningStreak: 0, text: '这是第一次体检，还没有可比的上一轮结论。' };
+  const prevBad = (Number(prev.counts && prev.counts.critical) || 0) * 3 + (Number(prev.counts && prev.counts.warning) || 0) + rank(prev.level) * 2;
+  const prevStreak = Number(previous.trendVerdict && previous.trendVerdict.worseningStreak) || 0;
+  if (curBad < prevBad) {
+    return { state: 'recovered', worseningStreak: 0, text: '比上一次体检好转了：风险项减少或严重项已消除。' };
+  }
+  if (curBad > prevBad) {
+    const streak = prevStreak + 1;
+    return { state: 'worsening', worseningStreak: streak,
+      text: streak >= 2
+        ? '连续 ' + streak + ' 次体检都在变差，值得回头看审计趋势里这几次改了什么。'
+        : '比上一次体检多了风险项，先看看新出现的是哪一条。' };
+  }
+  return { state: 'stable', worseningStreak: 0, text: '与上一次体检相比没有明显变化。' };
+}
+
 export function collectReport(options = {}) {
   const now = options.now || new Date();
   const env = options.env || process.env;
@@ -874,6 +1052,7 @@ export function collectReport(options = {}) {
 
   const bootedAt = options.bootedAt || new Date(Date.now() - Math.floor(process.uptime()) * 1000);
   const crashes = collectCrashLogs(paths, io, errors, limits);
+  const resolvedHostVersion = options.hostVersion || hostVersionFromCrashes(crashes);
   const patchBackups = collectPatchBackups(paths, io, errors);
   const pluginChanges = Array.isArray(options.pluginChanges) ? options.pluginChanges.slice(0, 50) : [];
 
@@ -1060,7 +1239,7 @@ export function collectReport(options = {}) {
   // this stays an information item with a pointer, not a button.
   let updateInfo = { available: false, outdated: [], checked: 0, cacheAgeHours: null };
   try {
-    updateInfo = collectUpdates(paths, io, errors);
+    updateInfo = collectUpdates(paths, io, errors, resolvedHostVersion);
     if (!updateInfo.available) {
       findings.push({
         id: 'plugin-updates', severity: 'info', category: '版本适配',
@@ -1075,6 +1254,7 @@ export function collectReport(options = {}) {
       // Those are not updates — they mean the cache is older than the disk, which is
       // worth saying out loud exactly once instead of silently hiding them.
       const ahead = updateInfo.aheadOfCache || [];
+      const advice = updateInfo.advice || null;
       const aheadNote = ahead.length > 0
         ? '\n另有 ' + ahead.length + ' 个包的已装版本比缓存里的 latest 还新（'
           + ahead.slice(0, 3).map((u) => u.name + ' ' + u.installed + ' > ' + u.latest).join('、')
@@ -1092,10 +1272,10 @@ export function collectReport(options = {}) {
         detail: updateInfo.outdated.slice(0, 10).map((u) => '· ' + u.name + '：' + u.installed + ' → ' + u.latest).join('\n')
           + (updateInfo.outdated.length > 10 ? '\n（共 ' + updateInfo.outdated.length + ' 个）' : '')
           + aheadNote + unknownNote
-          + '\n\n升级是「插件变更 → boot 风险」的上游；升级前先确认真能备份到当前可用状态。',
+          + (advice ? '\n\n' + advice.text : '\n\n升级是「插件变更 → boot 风险」的上游；升级前先确认真能备份到当前可用状态。'),
         evidence: '来源：$DSH_HOME/plugin-update-cache.json（' + (updateInfo.cacheAgeHours != null ? updateInfo.cacheAgeHours + ' 小时前刷新' : '刷新时间未知') + '）；对比 ' + updateInfo.checked + ' 个已装包；版本方向按 semver 比，只把「更新」算作可用',
-        recommendation: '逐个升而不是批量升，升完看「启动诊断」；不要在要赶活的时候动它们。管家不代升级。',
-        data: { outdated: updateInfo.outdated.slice(0, 20), aheadOfCache: ahead.slice(0, 20), undetermined: updateInfo.undetermined || 0, checked: updateInfo.checked, cacheAgeHours: updateInfo.cacheAgeHours },
+        recommendation: advice ? advice.recommendation : '逐个升而不是批量升，升完看「启动诊断」；不要在要赶活的时候动它们。管家不代升级。',
+        data: { outdated: updateInfo.outdated.slice(0, 20), aheadOfCache: ahead.slice(0, 20), undetermined: updateInfo.undetermined || 0, checked: updateInfo.checked, cacheAgeHours: updateInfo.cacheAgeHours, advice },
       });
     } else if (updateInfo.checked > 0) {
       findings.push({
@@ -1115,6 +1295,48 @@ export function collectReport(options = {}) {
     errors.push({ step: 'plugin-updates', error: String((e && e.message) || e) });
   }
 
+  // ①b v0.9.16（未发布）：只读一家第三方插件的运行台账。没装这个插件是正常状态，
+  // 不是体检退化——所以不加 coverage 键、不 push error。只在真读到、且出现
+  // 「标着可用却失败」或「最近一次探测失败」时给一条 info，零副作用。
+  let freeLane = { available: false, reason: 'not checked' };
+  try {
+    freeLane = collectFreeLaneHealth(paths, io);
+    if (freeLane.available && (freeLane.contradictory.length > 0 || freeLane.failing.length > 0)) {
+      const contra = freeLane.contradictory;
+      const NLf = String.fromCharCode(10);
+      const staleNote = freeLane.allStale
+        ? NLf + '台账里 ' + freeLane.checked + ' 个模型的探测结果全部标着 stale，说明这份结果本身可能已过期。'
+        : '';
+      const contraNote = contra.length
+        ? NLf + '其中 ' + contra.length + ' 条自相矛盾：' + contra.slice(0, 3).map((x) => x.name).join('、')
+          + (contra.length > 3 ? ' 等' : '') + ' 标着 available，却同时记着最近一次上游失败。'
+        : '';
+      findings.push({
+        id: 'free-lane-health',
+        severity: 'info',
+        category: '运行期健康',
+        title: contra.length
+          ? contra.length + ' 个免费模型标着「可用」、最近一次探测却失败'
+          : freeLane.failing.length + ' 个免费模型最近一次探测失败',
+        detail: '这是 our-free-model 插件自己的运行台账（availability.json），不是 boot 崩溃、也不是宿主 LLM 实时探活能看到的信号。'
+          + NLf + '· 共检查 ' + freeLane.checked + ' 个模型，' + freeLane.failing.length + ' 个记着上游失败 detail。'
+          + contraNote + staleNote
+          + NLf + '典型 detail：' + (freeLane.failing[0] ? freeLane.failing[0].detail : '（无）'),
+        evidence: '只读 $DSH_HOME/our-free-model/availability.json（最新探测 ' + (freeLane.newestAt || '未知') + '）；'
+          + 'staleCount ' + freeLane.staleCount + '/' + freeLane.checked + '；未改任何插件文件',
+        recommendation: '先别把这些模型设成默认/首选；上游失败常见原因是缺本地 Bun 或免费通道被限流。'
+          + '这是插件私有台账，管家只读、不碰它、不代修；中期应等宿主把插件级上游失败写进 diagnostics 再统一接一层。',
+        data: {
+          checked: freeLane.checked, staleCount: freeLane.staleCount, allStale: freeLane.allStale,
+          newestAt: freeLane.newestAt, failing: freeLane.failing.slice(0, 10),
+          contradictory: contra.slice(0, 10),
+        },
+      });
+    }
+  } catch (e) {
+    // best-effort only — never degrade the report for an optional signal
+  }
+
   // ② v0.7.7 workspace / session inventory. The report previously mentioned
   // sessions only inside a prose string; this measures them.
   //
@@ -1644,9 +1866,16 @@ export function collectReport(options = {}) {
       .map((a) => (a && typeof a === 'object' ? a.id : a))
       .filter((x) => typeof x === 'string'),
   );
+  const feedbackRaw = Array.isArray(options.feedback) ? options.feedback : [];
+  const feedbackIds = new Set(
+    feedbackRaw
+      .filter((a) => a && typeof a === 'object' && typeof a.id === 'string')
+      .map((a) => a.id),
+  );
   let mutedCount = 0;
   for (const f of findings) {
     f.muted = ackedIds.has(f.id);
+    f.falsePositive = feedbackIds.has(f.id);
     if (f.muted) mutedCount += 1;
   }
 
@@ -1669,6 +1898,7 @@ export function collectReport(options = {}) {
     : counts.warning > 0
       ? '有需要留意的风险项'
       : '当前未发现异常，以下为常备建议';
+  const trendVerdict = summarizeTrend(options.previous, { level, counts });
 
   return {
     generatedAt: now.toISOString ? now.toISOString() : String(now),
@@ -1678,16 +1908,19 @@ export function collectReport(options = {}) {
     config: configNow,
     workspace: workspaceInfo,
     updates: updateInfo,
+    freeLane,
     coverage,
     status: errors.length > 0 ? 'degraded' : 'ok',
-    summary: { level, headline, counts },
     findings,
+    summary: { level, headline, counts },
+    trendVerdict,
     limitations: [
       '只读：不删文件、不代跑提权命令、不自动拉起/重启、不改启动流程。',
       '不重复实现磁盘扫描 / 备份 / 归档 / 记忆，只指向现成能力。',
       '不 import 任何其它 DSH 包内部模块，避免版本漂移。',
       '崩溃检测是「启动后读日志」，不是实时守护；本进程内事件随宿主 fatal 消失。',
       '采集限流：日志 ≤ ' + limits.maxLogs + ' 份、单份 ≤ ' + limits.maxBytesPerLog + ' B（可在面板「设置」里调）。',
+      '运行期插件健康只接了一家：只读 $DSH_HOME/our-free-model/availability.json，没装该插件属正常、不算体检退化；DSH 宿主自身的新版本没有可读信号源，本版只分析市场缓存里的插件新版本。',
     ],
     errors,
   };

package/lib/settings.js

@@ -91,9 +91,9 @@ const SPEC = [
 
   // ── 界面 ──────────────────────────────────────────────────────
   {
-    key: 'ui.autoScanMinutes', group: '界面', label: '面板缓存的自动刷新间隔',
+    key: 'ui.autoScanMinutes', group: '界面', label: '自动体检 / 后台当班周期',
     unit: '分钟', min: 1, max: 240, def: 10,
-    why: '切回面板时，缓存超过这个时间就在后台重新体检一次（不会打断你）。设为 1 分钟 = 几乎每次都刷；设大 = 更省，但看到的可能是几分钟前的样子。',
+    why: '一个数字管两处：切回面板时缓存超过这个时间就后台重体检一次；管家不开面板时也按这个周期自己醒来体检一遍（v0.9.16 L0 当班）。设为 1 分钟 = 几乎每次都刷；设大 = 更省，但看到的可能是几分钟前的样子。改完下一班就按新周期走，不用重启。',
   },
   {
     key: 'ui.entry', group: '界面', label: '面板入口', type: 'choice', def: 'both',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sidady/dsh-steward",
-  "version": "0.9.14",
+  "version": "0.9.16",
   "type": "module",
   "description": "Guardian for DeepSeek Harness: a read-only health check (boot crashes, backup freshness, config drift, workspace growth, plugin updates, host-version compat, model availability) plus an explicitly authorized action layer (plan → single-use fingerprint → confirm → audit) covering cache cleaning, encrypted volatile-data backups, plugin enable/disable, knowledge capture, finding mute, and switching the default model.",
   "keywords": [