@noob-stupid/dsh-plugin-console 0.5.50 → 0.5.51

package/lib/server/infra/exec.js

@@ -445,27 +445,23 @@ function execFileWithKillTree(bin, argv, opts = {}, deps = {}) {
  *   仍然照需求注入这三个 env（CI 与非交互确实有用、registry 镜像照旧、fetch_* 是 npm 系标准写法，
  *   对 npm/后续 pnpm 版本仍可能生效），但**不把健壮性只押在 env 上**。
  *
- * ★ 2026-10-14（0.5.50 之后回校，实测更正 0.5.48 此处的判断）：
- *   0.5.48 在这里写的是「pnpm 判交互用它自己的 ci 配置项（opts3.ci，env 形态即 npm_config_ci），
- *   **不是** process.env.CI」。**这句只对了一半，而且是最关键的一半错了**：
- *     · `npm_config_ci=true` 对 pnpm **自己的**配置项是**空操作** —— pnpm 只认 `pnpm_config_*`
- *       前缀（含 argv 的 `--config.*`）。实测：设了它，`pnpm config list --json` 里 `ci` 仍为空，
- *       且 `pnpm install` 面对过时 lock 时**不会**被 frozen 拒绝。⇒ env 这一行是安慰剂。
- *     · 反过来，`CI=true` **确实**点亮 ci 位：pnpm 自己的配置默认值就是 `ci: isCI`
- *       （dist/pnpm.mjs L145865），而 `isCI` 判的是 `env.CI`（L143262）⇒ `opts3.ci` 随之变真。
- *       实测：只设 `CI=true`，`pnpm install` 面对过时 lock **会**被 frozen 拒绝（证伪组：
- *       再加 `--no-frozen-lockfile` 就恢复照常）。这一位在 v0.5.30 就已注入，不是 0.5.48 新增。
- *   ⇒ 真正管用的两位：`CI=true`（env，早就有）与 `--config.ci=true`（argv，只加在 pnpmAddArgs）。
- *     `npm_config_ci=true` 留着无害（对 npm 兼容项仍可能生效），但**别再把它当成非交互的保证**。
- *   ⚠️ 另有一处更重要的更正：0.5.48 说"命中供应链闸 ⇒ pnpm 弹提问 ⇒ 管道永不关闭 ⇒ 永久挂住"，
- *     这条因果链**实测不成立**。pnpm 的 `canPrompt = !inCi && Boolean(process.stdin.isTTY)`
- *     （L194277-278）—— 管道下 `isTTY` 恒为假 ⇒ pnpm **从来**不走 prompt 分支，五种配置
- *     （无 ci / CI=true / npm_config_ci / --config.ci / 两者齐上）实测全部快速失败，无一挂住。
- *     真正读 stdin 等人的是 **corepack 的下载提问**（corepack.cjs L22083：
- *     `if (process.stdin.isTTY && !process.env.CI)` ⇒ `stdin.resume()` + `once(stdin,'data')`）
- *     —— 它的判据恰恰是 `process.env.CI`，也就是 0.5.48 说"不是 pnpm 读的那一位"的那个变量。
- *     所以"无 TTY 挂住"的真凶是 corepack（且需 isTTY 为真才挂），不是 pnpm 的供应链闸。
- *     本段只更正文档，**未改动任何行为代码**（三个 env 与 argv 的注入原样保留）。 */
+ * ★ 2026-10-14（回校 0.5.48 此处的判断，**行为未动、只更正说明**。完整取证与五组实验见
+ *   CHANGELOG「v0.5.51」那节；这里只留结论，因为本文件贴着架构守卫的 600 行硬顶）：
+ *   ① `npm_config_ci=true` 对 pnpm **自己的**配置项是**空操作**（只认 `pnpm_config_*` 前缀，
+ *      含 argv 的 `--config.*`）⇒ 这一行是安慰剂，别再当成非交互的保证。
+ *   ② `CI=true` **确实**点亮 ci 位（pnpm 配置默认值 `ci: isCI`，`isCI` 判 `env.CI`）⇒
+ *      `pnpm install` 面对过时 lock **会**被 frozen 拒绝（加 `--no-frozen-lockfile` 即恢复）。
+ *      这一位 **v0.5.30 就已注入**，不是 0.5.48 新增。
+ *   ③ 「pnpm 弹提问 ⇒ 读 stdin 到 EOF ⇒ 永久挂住」**不成立**：`canPrompt` 需要
+ *      `process.stdin.isTTY`，管道下恒为假 ⇒ pnpm 从不 prompt；五种 ci 配置实测**全部快速失败**。
+ *   ④ 那"挂到 90s / 180s"**是我们自己的超时常量**（`runPnpmAdd` timeout=90000、
+ *      `installTargetDependencies` timeoutMs=180000），与当时观察逐一吻合 ⇒ 是"超过我们的
+ *      超时被杀"，不是"等输入"。**那次为什么慢至今没有证据**（最可能是网络）。
+ *   ⑤ corepack 的下载提问也**默认是关的**（入口 shim `COREPACK_ENABLE_DOWNLOAD_PROMPT ??= '0'`），
+ *      只有显式设成 1 才会问 ⇒ 也不是默认真凶。
+ *   ⇒ 0.5.48 那条「永久挂住」的**根因至今未查明**，能确定的只有"不是 pnpm 的交互提问"。
+ *     `--config.ci=true` 仍保留独立价值：钉死 ci 位 + 让 install 在 lock 过时走 frozen 拒绝
+ *     而非静默改写；`pnpm add` 不受 frozen 影响（实测带/不带此旗结局相同）。 */
 function pnpmEnvOverrides(registry) {
   const overrides = {
     npm_config_fetch_timeout: '60000',

package/lib/server/infra/pnpm-release-gate.js

@@ -9,20 +9,22 @@
 //   桌面壳/服务进程给的是**永不关闭的 stdin 管道** ⇒ 不抛错、不超时，**永久挂住**
 //   （实测两次分别挂到 90s / 180s 被杀）。
 //
-// ★ 2026-10-14（实测更正上面这段"现场描述"，**本模块行为未动**）：
-//   上述因果链里"pnpm 弹提问 ⇒ 读 stdin 到 EOF ⇒ 挂住"这一段**实测不成立**：
+// ★ 2026-10-14（回校上面这段"现场描述"，**本模块行为未动**）：
+//   上述因果链里"pnpm 弹提问 ⇒ 读 stdin 到 EOF ⇒ 永久挂住"这一段**实测不成立**：
 //     · pnpm 的 canPrompt = `!inCi && Boolean(process.stdin.isTTY)`（L194277-278）；
 //       管道下 isTTY 恒假 ⇒ pnpm **从不**走 prompt 分支，直接 `throw failOnImmature`。
 //     · 实测（pnpm 11.7.0，minimumReleaseAge 设成天文数字 + 管道 stdin）：无 ci 位 / CI=true /
 //       npm_config_ci=true / --config.ci=true / 两者齐上 —— **五种配置全部快速失败，无一挂住**。
-//     · 真正读 stdin 等人的是 **corepack 的下载提问**（corepack.cjs L22083：
-//       `if (process.stdin.isTTY && !process.env.CI) { stderr.write('? Do you want to continue?');
-//        stdin.resume(); await once(stdin,'data') }`）—— 判据恰恰是 `process.env.CI`。
+//     · 那"挂到 90s / 180s"其实是**我们自己的超时常量**：`runPnpmAdd` 默认 timeout=90000、
+//       `link-self-sufficiency#installTargetDependencies` 默认 timeoutMs=180000 —— 与当时观察
+//       逐一吻合 ⇒ 当时是"某次操作超过我们设的超时被我们杀掉"，**不是**"等输入等到天荒地老"。
+//       那次为什么慢**至今没有证据**（最可能是网络）；corepack 的下载提问也**默认是关的**
+//       （入口 shim 第一行 `COREPACK_ENABLE_DOWNLOAD_PROMPT ??= '0'`）。
 //   ⇒ 本模块的定位不变（**识别 + 翻译成可操作错误**，绝不绕过闸门），仍然有价值；
-//     只是"为什么会挂住"要记在 corepack 头上，不是 pnpm 的供应链闸。
-//     顺带更正另两处（详见 infra/exec.js#pnpmEnvOverrides 上方的完整说明）：
+//     只是「为什么会挂住」**至今未查明**，不要再照 0.5.48 那段因果链去找。
+//     另两处一并更正（详见 infra/exec.js#pnpmEnvOverrides 上方的完整说明）：
 //       · `npm_config_ci=true` 对 pnpm 自己的配置项是**空操作**（只认 `pnpm_config_*`）；
-//       · `CI=true` **确实**点亮 ci 位（pnpm 配置默认值 `ci: isCI`，L145865）。
+//       · `CI=true` **确实**点亮 ci 位（pnpm 配置默认值 `ci: isCI`，L145865），且 v0.5.30 就有。
 //
 // 闸门实现（本机 pnpm 11.7.0 `dist/pnpm.mjs`，只读反编译取证）：
 //   L194277  const inCi = opts3.ci ?? isCI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.5.50",
+  "version": "0.5.51",
   "description": "DSH 框架升级安全与插件升级门控：一键升级、失败自动回滚、升级后回滚上版、旧插件不适配自动禁用；内置多源插件市场为发现层，插件源全部可自定义，可指向公司内网私有源 / 私有索引 / 本地 Git 仓库，纯内网离线可用 | Framework upgrade safety & plugin version gating for DSH, with a customizable multi-source plugin market: point every source at internal mirrors or a local file:// repo for intranet-only, offline installs.",
   "repository": {
     "type": "git",
@@ -51,8 +51,7 @@
     "cordis.patch.yml",
     "SECURITY.md",
     "icon.svg",
-    "scripts/safe-boot.mjs",
-    "scripts/fw-preflight.mjs"
+    "scripts"
   ],
   "license": "MIT",
   "scripts": {

package/scripts/apply-framework-patch.cjs

@@ -0,0 +1,134 @@
+/**
+ * 框架层补丁：dsh-app-boot 的 cordis.patch.yml 解析容错（议题 #5）。
+ *
+ * 问题：cordis.patch.yml 若含顶格 `[]` 占位符 + 后续条目（两个 YAML 根节点），
+ * DSH 启动时 parsePatchList 解析崩溃（"end of the stream or a document separator is expected"）。
+ *
+ * 修复：parsePatchList 解析失败时，自动移除顶格空数组占位行（视为 no-op）后重试。
+ *
+ * 用法：node scripts/apply-framework-patch.cjs
+ * 说明：DSH 升级（npx 重新拉取）后框架文件会被覆盖，重新运行本脚本即可。
+ */
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+
+/** npm 缓存下的 npx 缓存目录候选（**不写死盘符/用户名**）。
+ *  npm 的 cache 位置是用户配置（把 cache 指到别的盘很常见）→ 按 npm 自己的来源读：
+ *  环境变量 npm_config_cache / NPM_CONFIG_CACHE + 用户级 ~/.npmrc 的 `cache=`。
+ *  （原实现第一条写死开发机上的缓存绝对路径：某个盘符下的 node_cache\_npx。） */
+function npmNpxCacheRoots() {
+  const roots = []
+  const push = (value) => {
+    if (typeof value !== 'string') return
+    const dir = value.trim().replace(/^["']|["']$/g, '').replace(/^~(?=[\\/]|$)/, os.homedir())
+    if (dir !== '') roots.push(path.join(dir, '_npx'))
+  }
+  for (const key of ['npm_config_cache', 'NPM_CONFIG_CACHE']) push(process.env[key])
+  try {
+    for (const line of fs.readFileSync(path.join(os.homedir(), '.npmrc'), 'utf8').split(/\r?\n/)) {
+      const hit = /^\s*cache\s*=\s*(.*?)\s*$/i.exec(line)
+      if (hit) push(hit[1])
+    }
+  } catch {}
+  return roots
+}
+
+// 定位 @deepseek-ai/dsh-app-boot（与 @deepseek-ai/dsh 同级）
+function locateAppBoot() {
+  try {
+    const dshPkg = require.resolve('@deepseek-ai/dsh/package.json')
+    const aiDir = path.dirname(dshPkg) // .../node_modules/@deepseek-ai
+    const candidate = path.join(aiDir, 'dsh-app-boot', 'lib', 'index.js')
+    if (fs.existsSync(candidate)) return candidate
+  } catch {}
+  const cacheRoots = [
+    process.env.NODE_CACHE || '',
+    ...npmNpxCacheRoots(),
+    path.join(os.homedir(), '.npm', '_npx'),
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'node_cache', '_npx') : '',
+  ].filter(Boolean)
+  for (const root of cacheRoots) {
+    if (!fs.existsSync(root)) continue
+    let entries = []
+    try { entries = fs.readdirSync(root, { withFileTypes: true }) } catch { continue }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const candidate = path.join(root, entry.name, 'node_modules', '@deepseek-ai', 'dsh-app-boot', 'lib', 'index.js')
+      if (fs.existsSync(candidate)) return candidate
+    }
+  }
+  return null
+}
+
+const MARKER = 'tryDropEmptyArrayPlaceholder'
+const OLD = `function parsePatchList(binName, file, content, label) {
+	let parsed;
+	try {
+		parsed = yaml.load(content, { schema: userPatchesSchema });
+	} catch (error) {
+		throw new Error(\`${'${binName}'}: failed to parse ${'${label}'} ${'${file}'}: ${'${String(error)}'}\`);
+	}`
+const NEW = `function parsePatchList(binName, file, content, label) {
+	let parsed;
+	try {
+		parsed = yaml.load(content, { schema: userPatchesSchema });
+	} catch (error) {
+		// 容错（issue #5）：文件可能是「[] 空数组占位符 + 后续条目」两个根节点，
+		// YAML 解析必然失败。移除顶层空数组占位行（视为 no-op）后重试。
+		const retried = tryDropEmptyArrayPlaceholder(content);
+		if (retried !== null) {
+			try {
+				parsed = yaml.load(retried, { schema: userPatchesSchema });
+			} catch {
+				throw new Error(\`${'${binName}'}: failed to parse ${'${label}'} ${'${file}'}: ${'${String(error)}'}\`);
+			}
+		} else {
+			throw new Error(\`${'${binName}'}: failed to parse ${'${label}'} ${'${file}'}: ${'${String(error)}'}\`);
+		}
+	}`
+
+const HELPER = `
+/**
+ * 容错辅助（issue #5）：若文件含顶格空数组占位行（\`[]\` / \`[ ]\`，可带行尾注释），
+ * 视为 no-op 全部移除；无此模式返回 null。
+ */
+function tryDropEmptyArrayPlaceholder(content) {
+	const lines = String(content).split("\\n");
+	const kept = [];
+	let dropped = false;
+	for (const line of lines) {
+		if (/^\\[\\s*\\]\\s*(?:#.*)?$/u.test(line)) {
+			dropped = true;
+			continue;
+		}
+		kept.push(line);
+	}
+	if (!dropped) return null;
+	return kept.join("\\n");
+}
+`
+
+function main() {
+  const target = locateAppBoot()
+  if (!target) {
+    console.error('未找到 @deepseek-ai/dsh-app-boot/lib/index.js，请确认 DSH 已安装（或手动指定路径）')
+    process.exit(1)
+  }
+  const source = fs.readFileSync(target, 'utf8')
+  if (source.includes(MARKER)) {
+    console.log('已打过补丁，跳过：' + target)
+    return
+  }
+  if (!source.includes('function parsePatchList')) {
+    console.error('未找到 parsePatchList（框架版本可能已变更），跳过。' + target)
+    process.exit(1)
+  }
+  fs.copyFileSync(target, target + '.bak-issue5')
+  const next = source.replace(OLD, NEW) + HELPER
+  fs.writeFileSync(target, next, 'utf8')
+  console.log('补丁已应用：' + target)
+  console.log('备份：' + target + '.bak-issue5')
+}
+
+main()

package/scripts/apply-npm-names.cjs

@@ -0,0 +1,36 @@
+/**
+ * 给已提交的 marketplace/index.json 就地补 npmName（批次 C-⑪）。
+ *
+ * 为什么单独有这个脚本：build-index.cjs 需要 gh CLI + 网络（本机 github 不可达时跑不了），
+ * 而"补 npmName"这件事**完全离线** —— 映射来自 marketplace/npm-name-hints.json（人工核对）。
+ * 用法：
+ *   node scripts/apply-npm-names.cjs                     # 就地更新 marketplace/index.json
+ *   node scripts/apply-npm-names.cjs --dry-run           # 只报告会改哪几条
+ *   node scripts/apply-npm-names.cjs --file=<index.json> # 指定索引文件
+ * 幂等：已经带 npmName 的条目内容不变；映射里没有的仓库保持原样（老索引兼容）。
+ */
+const fs = require('node:fs')
+const path = require('node:path')
+const { readNpmNameHints, withNpmNames } = require('./build-index.cjs')
+
+const args = process.argv.slice(2)
+const dryRun = args.includes('--dry-run')
+const fileArg = args.find((a) => a.startsWith('--file='))
+const hintsArg = args.find((a) => a.startsWith('--hints='))
+const indexFile = fileArg ? fileArg.split('=')[1] : path.join(__dirname, '..', 'marketplace', 'index.json')
+const hints = readNpmNameHints(hintsArg ? hintsArg.split('=')[1] : undefined)
+
+const raw = JSON.parse(fs.readFileSync(indexFile, 'utf8'))
+const before = Array.isArray(raw.items) ? raw.items : []
+const after = withNpmNames(before, hints)
+const changed = after.filter((it, i) => typeof it.npmName === 'string' && before[i]?.npmName !== it.npmName)
+
+console.log(`映射条目 ${Object.keys(hints).length} 条；索引 ${before.length} 条命中 ${changed.length} 条`)
+for (const it of changed) console.log(`  ${it.fullName} → ${it.npmName}`)
+
+if (dryRun) {
+  console.log('（dry-run：未写入）')
+  process.exit(0)
+}
+fs.writeFileSync(indexFile, JSON.stringify({ ...raw, items: after }, null, 2) + '\n', 'utf8')
+console.log(`已写入 ${indexFile}`)

package/scripts/build-index.cjs

@@ -0,0 +1,190 @@
+/**
+ * 构建静态插件/技能索引：嗅探 GitHub topic 仓库 → marketplace/index.json。
+ *
+ * 插件模式（默认）：topic:dsh-plugin，按 star 排序，限制 --limit（默认 500）
+ * 技能模式：--skills，合并 topic:agent-skills + topic:claude-skills + topic:dsh-skill，
+ *   写入 index.json 的 skills 段（保留已有 items 段），限制 --limit（默认 300）
+ *
+ * 数据拉取（本机沙箱禁止 node spawn gh 时的推荐方式）：
+ *   gh api --paginate "search/repositories?q=topic:dsh-plugin&sort=stars&order=desc&per_page=100" > raw.json
+ *   node scripts/build-index.cjs --input raw.json [--limit 500]
+ * 无 --input 时尝试直接用 gh CLI 拉取（GitHub Actions 中预装 gh 且已认证）。
+ *
+ * 产物：marketplace/index.json（提交到仓库，经 jsDelivr CDN 分发，终端零 GitHub API 调用）
+ */
+const { execFile } = require('node:child_process')
+const { promisify } = require('node:util')
+const fs = require('node:fs')
+const path = require('node:path')
+
+const execFileAsync = promisify(execFile)
+
+const SKILL_TOPICS = ['agent-skills', 'claude-skills', 'dsh-skill']
+
+// gh api search 单对象响应，--paginate 拼接后不是合法 JSON，改手动分页循环
+async function ghSearchRepos(query, limit) {
+  const all = []
+  let page = 1
+  const perPage = Math.min(100, limit)
+  while (all.length < limit) {
+    const { stdout } = await execFileAsync('gh', [
+      'api',
+      'search/repositories',
+      '--method', 'GET',
+      '-f', 'q=' + query,
+      '-f', 'sort=stars',
+      '-f', 'order=desc',
+      '-f', `per_page=${perPage}`,
+      '-f', `page=${page}`,
+      '--jq', '.items',
+    ], {
+      timeout: 120000,
+      windowsHide: true,
+      maxBuffer: 64 * 1024 * 1024,
+    })
+    const batch = JSON.parse(stdout)
+    if (!Array.isArray(batch) || batch.length === 0) break
+    all.push(...batch)
+    page += 1
+  }
+  return all
+}
+
+function normalizeRepo(item) {
+  const fullName = String(item.full_name ?? '').trim()
+  if (!fullName) return null
+  return {
+    fullName,
+    description: item.description ?? '',
+    htmlUrl: item.html_url ?? `https://github.com/${fullName}`,
+    stars: item.stargazers_count ?? 0,
+    updatedAt: item.updated_at ?? '',
+    defaultBranch: item.default_branch ?? 'main',
+    topics: Array.isArray(item.topics) ? item.topics : [],
+  }
+}
+
+function readExisting(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * 仓库 → npm 包名（批次 C-⑪）：市场索引的 npmName 字段。
+ * 为什么需要：有些仓库的根包没有发布到 npm（private），真正该装的产物是某个子包/聚合包
+ * （真机：zhu1090093659/dsh-web → @linxin666/dsh-web-all，5.97 MB，而仓库本体 429 MB、
+ * git 协议 0 B/s）。把这个映射写进索引后，hub 侧可以**直接按包名走 registry 安装**，
+ * 省掉"先探测根 package.json、再展开子包"的一整轮（本机 github 不可达时那条路根本走不通）。
+ * 只收录**能确定**的（人工核对过的映射文件）；不能确定就省略 —— 老索引没有这个字段，
+ * hub 侧行为与改动前完全一致。
+ */
+function readNpmNameHints(explicitFile) {
+  const file = explicitFile ?? path.join(__dirname, '..', 'marketplace', 'npm-name-hints.json')
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, 'utf8'))
+    const hints = raw && typeof raw.hints === 'object' && raw.hints !== null ? raw.hints : {}
+    const out = {}
+    for (const [repo, npmName] of Object.entries(hints)) {
+      if (typeof repo !== 'string' || repo.trim() === '') continue
+      if (typeof npmName !== 'string' || !/^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/u.test(npmName.trim())) continue
+      out[repo.trim().toLowerCase()] = npmName.trim()
+    }
+    return out
+  } catch {
+    return {}
+  }
+}
+
+/** 给归一化后的条目补 npmName（能确定时）。纯函数，便于单测。 */
+function withNpmNames(items, hints) {
+  return items.map((item) => {
+    const hit = hints[String(item.fullName).toLowerCase()]
+    return hit === undefined ? item : { ...item, npmName: hit }
+  })
+}
+
+async function main() {
+  const skillsMode = process.argv.includes('--skills')
+  const limitArg = process.argv.find((a) => a.startsWith('--limit='))
+  const limit = limitArg ? Number(limitArg.split('=')[1]) || (skillsMode ? 300 : 500) : (skillsMode ? 300 : 500)
+  const inputArg = process.argv.find((a) => a.startsWith('--input='))
+  const inputFile = inputArg ? inputArg.split('=')[1] : null
+
+  const dir = path.join(__dirname, '..', 'marketplace')
+  fs.mkdirSync(dir, { recursive: true })
+  const file = path.join(dir, 'index.json')
+
+  let items = []
+  if (skillsMode) {
+    console.log(`拉取技能 topic 仓库（${SKILL_TOPICS.join(' + ')}，gh CLI，自动分页）…`)
+    try {
+      const raw = inputFile ? JSON.parse(fs.readFileSync(inputFile, 'utf8')) : null
+      if (raw) {
+        items = Array.isArray(raw) ? raw : (raw.items ?? [])
+      } else {
+        for (const topic of SKILL_TOPICS) {
+          const batch = await ghSearchRepos(`topic:${topic} in:name,description,topics`, limit)
+          items.push(...batch)
+        }
+      }
+    } catch (error) {
+      console.error('技能搜索失败：' + error.message)
+      process.exit(1)
+    }
+  } else if (inputFile) {
+    // 外部已拉取的数据文件（gh api --paginate 输出：JSON 数组）
+    console.log(`读取数据文件 ${inputFile}…`)
+    const raw = JSON.parse(fs.readFileSync(inputFile, 'utf8'))
+    items = Array.isArray(raw) ? raw : (raw.items ?? [])
+  } else {
+    console.log('拉取 dsh-plugin topic 仓库（gh CLI，自动分页）…')
+    try {
+      items = await ghSearchRepos('topic:dsh-plugin in:name,description,topics', limit)
+    } catch (error) {
+      console.error('搜索失败：' + error.message)
+      process.exit(1)
+    }
+  }
+
+  const seen = new Set()
+  const normalized = []
+  for (const item of items) {
+    const norm = normalizeRepo(item)
+    if (!norm || seen.has(norm.fullName)) continue
+    seen.add(norm.fullName)
+    if (skillsMode) {
+      norm.skillTopics = SKILL_TOPICS.filter((t) => norm.topics.includes(t))
+    }
+    normalized.push(norm)
+    if (normalized.length >= limit) break
+  }
+
+  const existing = readExisting(file)
+  // 批次 C-⑪：给能确定的条目补 npmName（--hints=<file> 可覆盖映射文件）
+  const hintsArg = process.argv.find((a) => a.startsWith('--hints='))
+  const hints = readNpmNameHints(hintsArg ? hintsArg.split('=')[1] : undefined)
+  const named = withNpmNames(normalized, hints)
+  const out = {
+    generatedAt: new Date().toISOString(),
+    count: existing.count ?? 0,
+    items: existing.items ?? [],
+    skills: existing.skills ?? [],
+  }
+  if (skillsMode) {
+    out.skills = named
+    out.skillCount = named.length
+  } else {
+    out.items = named
+    out.count = named.length
+  }
+  fs.writeFileSync(file, JSON.stringify(out, null, 2) + '\n', 'utf8')
+  const hinted = named.filter((it) => typeof it.npmName === 'string').length
+  console.log(`已更新 ${file}：${skillsMode ? '技能 ' + named.length : '插件 ' + named.length}（限制 ${limit}${hinted > 0 ? `；其中 ${hinted} 条带 npmName` : ''}）`)
+}
+
+if (require.main === module) main().catch((error) => { console.error(error); process.exit(1) })
+
+module.exports = { normalizeRepo, readNpmNameHints, withNpmNames }

package/scripts/diag-blocks.mjs

@@ -0,0 +1,60 @@
+// 诊断工具（**不是测试**，不进 tests/ 目录、不进 CI 门禁）：打印升级/回滚脚本块的实际切分结果。
+//
+// 来历：原先它在 tests/ 下叫 diag-blocks.mjs，读 `lib/server/domain/framework-install-script.js`
+// ——那是**从未入库**的路径（生成器现在在 lib/server/infra/fw-integrity-check.js），
+// 于是它每次运行都抛 ENOENT，把全量测试拖成 35/36。诊断脚本没有断言，本就不该占测试名额；
+// 正确的位置是 scripts/，而且**读不到文件时必须明说"跳过 + 原因"**，不能假装成功、也不能崩。
+//
+// 用法：node scripts/diag-blocks.mjs
+import { readFileSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..')
+const readSrc = (rel) => readFileSync(join(REPO, rel), 'utf8').replace(/\r\n/gu, '\n')
+
+const SOURCES = [
+  ['RFU', 'lib/server/routes/framework-upgrade.js'],
+  ['FR', 'lib/server/routes/framework.js'],
+  ['IDX', 'lib/index.js'],
+  ['FWIS', 'lib/server/infra/fw-integrity-check.js'],
+]
+const endMarker = ".filter((l) => l !== '').join('\\r\\n')"
+const startMarker = 'const lines = ['
+let blocks = 0
+
+for (const [name, rel] of SOURCES) {
+  if (!existsSync(join(REPO, rel))) {
+    // 明确跳过：打印原因（不许静默）
+    console.log(`SKIP ${name} ${rel} —— 文件不在仓库里（该来源无法诊断）`)
+    continue
+  }
+  const source = readSrc(rel)
+  let at = source.indexOf(endMarker)
+  while (at !== -1) {
+    const from = source.lastIndexOf(startMarker, at)
+    if (from === -1) {
+      console.log(`WARN ${name} ${rel}@${at} —— 结束标记前找不到 'const lines = ['（该块会被抽取器静默丢弃）`)
+    } else {
+      const block = source.slice(from + startMarker.length - 1, at) + endMarker
+      blocks += 1
+      const flags = [
+        `Install-Framework=${block.includes('function Install-Framework')}`,
+        `Invoke-Quarantine=${block.includes('Invoke-Quarantine')}`,
+        `一键回滚=${block.includes('一键回滚脚本启动')}`,
+      ].join(' ')
+      console.log(`#${blocks} [${name}] 长度=${block.length} ${flags}`)
+      console.log(`    首行: ${JSON.stringify(block.split('\n')[0].slice(0, 90))}`)
+      console.log(`    末行: ${JSON.stringify(block.split('\n').slice(-1)[0].slice(0, 90))}`)
+    }
+    at = source.indexOf(endMarker, at + endMarker.length)
+  }
+  // FWIS 用的是 `return [ … ].join('\r\n')`（没有 .filter 结束标记），单独报一次
+  if (name === 'FWIS') {
+    const fwStart = source.indexOf('function fwIntegrityCheck')
+    console.log(fwStart === -1
+      ? `WARN FWIS ${rel} —— 找不到 function fwIntegrityCheck`
+      : `OK   FWIS ${rel} —— fwIntegrityCheck 在（生成"安装后结构校验"那段脚本）`)
+  }
+}
+console.log(`共 ${blocks} 块（抽取标记：${JSON.stringify(startMarker)} → ${JSON.stringify(endMarker)}）`)

package/scripts/fw-watchdog-task.ps1

@@ -0,0 +1,112 @@
+# fw-watchdog-task.ps1 —— 注册/卸载 DSH 框架闭包看门狗的计划任务（Windows）
+#
+# 为什么用计划任务而不是改官方代码：官方启动链没有"启动前执行外部命令"的钩子
+#   （取证见 scripts/fw-watchdog.mjs 头注释）。计划任务是**不改任何官方文件**、
+#   且 DSH 升级也不会被覆盖的唯一位置。
+#
+# 用法（在 scripts 目录下）：
+#   powershell -ExecutionPolicy Bypass -File fw-watchdog-task.ps1            # 安装（幂等）
+#   powershell -ExecutionPolicy Bypass -File fw-watchdog-task.ps1 -Status    # 看状态
+#   powershell -ExecutionPolicy Bypass -File fw-watchdog-task.ps1 -Uninstall # 卸载
+#   powershell -ExecutionPolicy Bypass -File fw-watchdog-task.ps1 -RunNow    # 立刻跑一轮
+#
+# 任务形态：登录时启动 → 常驻（脚本内部每 20s 一轮）→ 失败自动重启（3 次 / 间隔 1 分钟）。
+#   · 为什么常驻而不是"每 1 分钟触发一次"：任务计划程序的最小重复间隔是 1 分钟，
+#     而我们要 20s；常驻 + 内部定时更精确，也避免每分钟拉起一个进程。
+#   · 只读判据 + 只修框架闭包：不杀进程、不抢端口、不 spawn dsh、不改官方文件。
+Param(
+  [switch]$Uninstall,
+  [switch]$Status,
+  [switch]$RunNow
+)
+
+$ErrorActionPreference = 'Stop'
+$TaskName = 'DSH-FwWatchdog'
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$Watchdog = Join-Path $ScriptDir 'fw-watchdog.mjs'
+
+if ($Status) {
+  $t = Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue
+  if ($null -eq $t) { Write-Host "任务 $TaskName ：未安装"; exit 0 }
+  $info = Get-ScheduledTaskInfo -TaskName $TaskName -ErrorAction SilentlyContinue
+  Write-Host "任务     : $($t.TaskName)"
+  Write-Host "状态     : $($t.State)"
+  Write-Host "上次运行 : $($info.LastRunTime)   结果码: $($info.LastTaskResult)"
+  Write-Host "下次运行 : $($info.NextRunTime)"
+  Write-Host "动作     : $($t.Actions | ForEach-Object { "$($_.Execute) $($_.Arguments)" })"
+  exit 0
+}
+
+if ($Uninstall) {
+  $t = Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue
+  if ($null -eq $t) { Write-Host "任务 $TaskName 本来就不存在，无需卸载"; exit 0 }
+  Stop-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue
+  Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false
+  Write-Host "已卸载任务 $TaskName"
+  exit 0
+}
+
+if ($RunNow) {
+  Start-ScheduledTask -TaskName $TaskName
+  Write-Host "已触发一轮（看日志：~/.dsh/plugin-console/fw-watchdog.log）"
+  exit 0
+}
+
+# ── 解析 node（钉绝对路径：计划任务里的 PATH 不可靠）────────────────────────
+$node = $null
+$candidates = @()
+if ($env:DSH_DESKTOP_NODE_EXECUTABLE) { $candidates += $env:DSH_DESKTOP_NODE_EXECUTABLE }
+foreach ($root in @('D:\dsh-desktop', "$env:ProgramFiles\DeepSeek Harness", "$env:LOCALAPPDATA\Programs\DeepSeek Harness")) {
+  if ($root) { $candidates += (Join-Path $root 'resources\runtime\primary-runtime\dependencies\node\bin\node.exe') }
+}
+$onPath = (Get-Command node -ErrorAction SilentlyContinue).Source
+if ($onPath) { $candidates += $onPath }
+foreach ($c in $candidates) { if (-not $node -and $c -and (Test-Path -LiteralPath $c)) { $node = $c } }
+if (-not $node) { throw "找不到可用的 node —— 请安装 Node.js 后重试" }
+
+if (-not (Test-Path -LiteralPath $Watchdog)) { throw "找不到看门狗脚本：$Watchdog" }
+
+# ── 为什么要 `--daemon` 而不是直接跑 node（★ 2026-10-14 两次实测踩坑后定案）：
+#    ① 任务直接跑 node.exe ⇒ Windows 弹出**可见的控制台窗口**（本机实测桌面出现一个
+#       Windows Terminal，标题就是 node 的绝对路径），后台看门狗不该占用户桌面；
+#    ② 改用 .vbs 启动器（window style 0）⇒ wscript 挂住、拉不起子进程（实测两次都没起来）。
+#    最终做法：任务跑 `node … --daemon`，脚本**自己以 detached + stdio:'ignore' +
+#    windowsHide 再拉起一份**并立刻返回 ⇒ 任务那条命令秒退、真正干活的那份无窗口在后台跑，
+#    重复启动由 pid 锁挡住（幂等）。
+Write-Host "node     : $node"
+Write-Host "看门狗   : $Watchdog （--daemon：自己脱离，无控制台窗口）"
+
+# ── 注册（幂等：先卸旧的）──────────────────────────────────────────────────
+$existing = Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue
+if ($existing) {
+  Stop-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue
+  Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false
+  Write-Host "已移除旧任务，准备重建"
+}
+
+$action = New-ScheduledTaskAction -Execute $node -Argument "`"$Watchdog`" --daemon" -WorkingDirectory $ScriptDir
+$trigger = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
+$settings = New-ScheduledTaskSettingsSet `
+  -AllowStartIfOnBatteries `
+  -DontStopIfGoingOnBatteries `
+  -StartWhenAvailable `
+  -MultipleInstances IgnoreNew `
+  -RestartCount 3 `
+  -RestartInterval (New-TimeSpan -Minutes 1) `
+  -ExecutionTimeLimit ([TimeSpan]::Zero)      # 零 = 不限制运行时长（常驻）
+
+Register-ScheduledTask -TaskName $TaskName -Action $action -Trigger $trigger -Settings $settings `
+  -Description 'DSH 框架闭包看门狗：外壳在跑但服务进程不在时，检查并修复被掏空的框架包（只修闭包，不杀进程/不抢端口/不改官方文件）。日志：~/.dsh/plugin-console/fw-watchdog.log' | Out-Null
+
+Write-Host ""
+Write-Host "✅ 已注册计划任务 $TaskName（登录时启动，常驻，20s 一轮）"
+Write-Host "   看状态 : powershell -ExecutionPolicy Bypass -File `"$($MyInvocation.MyCommand.Path)`" -Status"
+Write-Host "   跑一轮 : powershell -ExecutionPolicy Bypass -File `"$($MyInvocation.MyCommand.Path)`" -RunNow"
+Write-Host "   卸载   : powershell -ExecutionPolicy Bypass -File `"$($MyInvocation.MyCommand.Path)`" -Uninstall"
+Write-Host "   日志   : $env:USERPROFILE\.dsh\plugin-console\fw-watchdog.log"
+Write-Host ""
+Write-Host "现在就启动它（不用等下次登录）："
+Start-ScheduledTask -TaskName $TaskName
+Start-Sleep -Seconds 3
+$info = Get-ScheduledTaskInfo -TaskName $TaskName
+Write-Host "   当前状态: $((Get-ScheduledTask -TaskName $TaskName).State)   上次结果码: $($info.LastTaskResult)"

package/scripts/fw-watchdog.cmd

@@ -0,0 +1,30 @@
+@echo off
+rem fw-watchdog.cmd -- manual entry point for the framework-closure watchdog.
+rem   usage: fw-watchdog.cmd --status | --once | --tick | (no args = resident)
+rem NOTE: this file must keep CRLF line endings and ASCII-only comments --
+rem   cmd.exe chokes on LF-only .cmd files and on multi-byte comments read in
+rem   the OEM code page (measured: the comment text got executed as commands).
+setlocal
+set "WD=%~dp0fw-watchdog.mjs"
+set "NODE="
+
+rem (1) the node the desktop host passes down
+if defined DSH_DESKTOP_NODE_EXECUTABLE if exist "%DSH_DESKTOP_NODE_EXECUTABLE%" set "NODE=%DSH_DESKTOP_NODE_EXECUTABLE%"
+
+rem (2) the node bundled with the desktop runtime (most stable)
+if not defined NODE (
+  for %%D in ("D:\dsh-desktop" "%ProgramFiles%\DeepSeek Harness" "%LOCALAPPDATA%\Programs\DeepSeek Harness") do (
+    if not defined NODE if exist "%%~D\resources\runtime\primary-runtime\dependencies\node\bin\node.exe" set "NODE=%%~D\resources\runtime\primary-runtime\dependencies\node\bin\node.exe"
+  )
+)
+
+rem (3) whatever node is on PATH (last resort)
+if not defined NODE for /f "delims=" %%N in ('where node 2^>nul') do if not defined NODE set "NODE=%%N"
+
+if not defined NODE (
+  echo [fw-watchdog] no usable node found -- install Node.js, or run this from the desktop install.
+  exit /b 2
+)
+
+"%NODE%" "%WD%" %*
+exit /b %ERRORLEVEL%

package/scripts/fw-watchdog.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+// fw-watchdog.mjs —— DSH 框架闭包看门狗（不改官方代码的"崩溃自愈"）
+//
+// ── 为什么需要它 ────────────────────────────────────────────────────────────
+//   真机事故（2026-10-14）：框架树里 `@deepseek-ai/cordis` 的 junction 还在、但 `.pnpm`
+//   实体被掏空；`dsh-llm`/`dsh-tools`/`dsh-web` 成了空目录 ⇒ dsh 启动即 54 个插件
+//   failed to import ⇒ 服务进程 exit code=1 ⇒ 桌面端弹「应用无法启动或已意外停止」。
+//
+//   官方启动链（已只读取证）**没有**"启动前执行外部命令"的钩子：
+//     DeepSeek Harness.exe → dsh-desktop-host/lib/cli.js → runCli()（dsh/lib/bin.js:207）
+//       → case "profile": runProfile() → 失败 → reportStartupFailure() → process.exit(1)
+//     · bin.js 全文 254 行，读的环境变量：零；
+//     · dsh-app-boot 只有 DSH_SNAPSHOT=replay（换配置）与 loadEnv()（读 .env），
+//       而 .env 能设的名字有黑名单（PATH/HOME/NODE_OPTIONS/…）——只能设配置，不能"启动前跑脚本"；
+//     · 失败路径不 spawn 任何外部命令。
+//   ⇒ 想在"每次 dsh 启动前自动修"必须改官方外壳（且一升级就被覆盖）。
+//     所以本脚本走另一条路：**观测一个合法事实** —— 外壳进程还在，而它的 **HOST 服务进程没了**。
+//     官方自己的崩溃恢复只知道"重启"，不知道"修包"；看门狗补的正是这一段：
+//     它把地面修平，官方下一次重启自然成功 —— 用户观感就是"崩了自己又起来了"。
+//
+// ── 判据（★ 2026-10-14 修正：一开始用"端口无监听"，那是错的）────────────────
+//   为什么不能用端口：桌面实例监听 19387，3080 是 web profile 的端口；用固定端口探针
+//   会在正常运行时恒判"服务没起来" ⇒ 每轮白跑一次全量闭包检查、日志刷屏。
+//   现在的判据（进程树事实，与端口无关）：
+//     ① 外壳进程在跑（`DeepSeek Harness.exe` 且命令行**不含** `--type=`）；
+//     ② 它的 HOST 服务子进程**不在**（命令行含 `dsh-desktop-host/lib/index.js` 的那个）；
+//     ③ 连续 N 轮（默认 2 轮 ≈ 40s）都如此 ⇒ 才动手（避开"正在启动/正在重启"的窗口）。
+//   动作：`fw-preflight --check` → 闭包坏 ⇒ `--repair` → `--check` 复验。
+//   修完**不自己拉起服务**：官方崩溃恢复/relaunch 会自己重试，我们只把地面修平。
+//   红线：不杀进程、不抢端口、不 spawn dsh、不改官方任何文件。
+//
+// ── 用法 ──────────────────────────────────────────────────────────────────
+//   node fw-watchdog.mjs --daemon    后台守护（**计划任务用这个**）：自己脱离、无控制台窗口、幂等
+//   node fw-watchdog.mjs --status     只打印当前判据事实，不动作
+//   node fw-watchdog.mjs --tick       跑一次完整逻辑（演练 / 手动触发）
+//   node fw-watchdog.mjs --once       诊断：判据 + 跑一次 --check 并打印结论
+//   node fw-watchdog.mjs              前台常驻（Ctrl-C 退出；排查时用）
+// 日志：`<DSH_HOME>/plugin-console/fw-watchdog.log`（追加式，只在有事时写）
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const ARGV = process.argv.slice(2)
+const HAS = (f) => ARGV.includes(f)
+const HOME = homedir()
+const DSH_HOME = process.env.DSH_HOME?.trim() || join(HOME, '.dsh')
+const LOG_DIR = join(DSH_HOME, 'plugin-console')
+const LOG = join(LOG_DIR, 'fw-watchdog.log')
+const INTERVAL_MS = Number(process.env.DSH_WATCHDOG_INTERVAL_MS ?? 20000)
+const STRIKES = Number(process.env.DSH_WATCHDOG_STRIKES ?? 2)
+const EXE = process.platform === 'win32' ? 'DeepSeek Harness.exe' : null
+
+/** 找到本机已装的 fw-preflight.mjs。
+ *  扫描各个 profile 的 node_modules/<包>/scripts/（不写死 desktop —— 用户可能只装 web profile，
+ *  或 profile 名不同）。★ 注意：本注释里**不能**出现星号后跟斜杠那种通配写法，
+ *  那会提前闭合块注释（2026-10-14 实测踩到：脚本因此整份 SyntaxError、看门狗从未真正运行过）。 */
+function findPreflight() {
+  if (typeof process.env.DSH_WATCHDOG_CONSOLE === 'string' && process.env.DSH_WATCHDOG_CONSOLE !== '') {
+    return join(process.env.DSH_WATCHDOG_CONSOLE, 'scripts', 'fw-preflight.mjs')
+  }
+  // 本脚本自己就在 <包>/scripts/ 下时，优先用同包那份（最不容易错配）
+  try {
+    const self = fileURLToPath(import.meta.url)
+    const samePkg = join(self, '..', 'fw-preflight.mjs')
+    if (existsSync(samePkg)) return samePkg
+  } catch {}
+  const profilesDir = join(DSH_HOME, 'profiles')
+  let names = []
+  try { names = readdirSync(profilesDir) } catch { return join(profilesDir, 'desktop', 'node_modules', '@noob-stupid', 'dsh-plugin-console', 'scripts', 'fw-preflight.mjs') }
+  for (const name of names) {
+    const p = join(profilesDir, name, 'node_modules', '@noob-stupid', 'dsh-plugin-console', 'scripts', 'fw-preflight.mjs')
+    if (existsSync(p)) return p
+  }
+  return join(profilesDir, 'desktop', 'node_modules', '@noob-stupid', 'dsh-plugin-console', 'scripts', 'fw-preflight.mjs')
+}
+const PREFLIGHT = findPreflight()
+
+const log = (line) => {
+  const stamp = new Date().toISOString().replace('T', ' ').slice(0, 19)
+  const text = `[${stamp}] ${line}\n`
+  try { mkdirSync(LOG_DIR, { recursive: true }); appendFileSync(LOG, text, 'utf8') } catch {}
+  process.stdout.write(text)
+}
+
+/** 进程树事实（一次 PowerShell 调用取全，避免每条判据各 spawn 一次）。
+ *  ★ 坑（2026-10-14 实测踩到）：PowerShell 里 `$host` 是**只读自动变量**，赋值直接报
+ *    "Cannot overwrite variable Host because it is read-only or constant" ⇒ 探针恒返回 0
+ *    ⇒ 看门狗永远以为"外壳没在跑"、静默失效。所以变量名一律用 `$hostN`/`$shellN`。
+ *    同族坑：$HOME / $PID / $PSHOME 等一律不许赋值。 */
+function probeProcesses() {
+  // 测试注入缝（只为离线演练；生产不设这个变量）
+  const fake = process.env.DSH_WATCHDOG_FAKE_PROCS
+  if (typeof fake === 'string' && /^\d+\|\d+$/u.test(fake)) {
+    const [s, h] = fake.split('|').map(Number)
+    return { shell: s, host: h, raw: `${s}|${h} (injected)` }
+  }
+  if (EXE === null) return { shell: 0, host: 0, raw: 'non-win32' }
+  const ps = [
+    `$all = @(Get-CimInstance Win32_Process -Filter "Name='${EXE}'" -ErrorAction SilentlyContinue)`,
+    `$shellN = @($all | Where-Object { $_.CommandLine -notmatch '--type=' }).Count`,
+    `$hostN = @($all | Where-Object { $_.CommandLine -match 'dsh-desktop-host[\\\\/]lib[\\\\/]index\\.js' }).Count`,
+    `Write-Output ($shellN.ToString() + '|' + $hostN.ToString())`,
+  ].join('; ')
+  const r = spawnSync('powershell', ['-NoProfile', '-Command', ps], { encoding: 'utf8', timeout: 20000, windowsHide: true })
+  const m = /(\d+)\|(\d+)/u.exec(String(r.stdout ?? ''))
+  return { shell: m ? Number(m[1]) : 0, host: m ? Number(m[2]) : 0, raw: String(r.stdout ?? '').trim() }
+}
+
+const preflight = (mode) => {
+  if (!existsSync(PREFLIGHT)) {
+    log(`找不到 fw-preflight：${PREFLIGHT}（控制台未安装或路径变了）—— 本轮跳过`)
+    return { ok: false, stdout: '', missing: true }
+  }
+  const r = spawnSync(process.execPath, [PREFLIGHT, mode], { encoding: 'utf8', timeout: 180000, windowsHide: true })
+  return { ok: r.status === 0, stdout: String(r.stdout ?? '') + String(r.stderr ?? ''), missing: false }
+}
+
+/** 闭包是否坏。判据取自 fw-preflight 自己那行结论：「走了 N 个包，M 个解析不了」，M>0 即坏。
+ *  认不出格式时按"坏"处理 —— 宁可多查一次，也不放过真事故。 */
+function closureBroken(out) {
+  const m = /走了\s*(\d+)\s*个包[，,]\s*(\d+)\s*个解析不了/u.exec(out)
+  if (m) return Number(m[2]) > 0
+  if (/闭包完整/u.test(out)) return false
+  return true
+}
+
+let strikes = 0
+let repairing = false
+
+async function tick() {
+  if (repairing) return
+  try {
+    const p = probeProcesses()
+    if (p.shell === 0) { strikes = 0; return }      // 外壳没开 = 用户没在用，不管
+    if (p.host > 0) {                                // HOST 在 = 服务活着 = 正常
+      if (strikes !== 0) log('HOST 服务进程已回来 —— 恢复正常，看门狗回待命')
+      strikes = 0
+      return
+    }
+    strikes += 1
+    if (strikes < STRIKES) return
+    log(`外壳在跑(${p.shell}) 但 HOST 服务进程不在（连续 ${strikes} 轮）⇒ 开始检查框架闭包`)
+    const check = preflight('--check')
+    if (check.missing) { strikes = 0; return }
+    if (!closureBroken(check.stdout)) {
+      log('闭包本身是好的 ⇒ 起不来另有原因（不是包被掏空），本轮不动作，等官方自己的恢复逻辑')
+      strikes = 0
+      return
+    }
+    log('闭包确实坏了 ⇒ 执行 --repair（从本地 npm 缓存按 integrity 离线装回，不联网）')
+    repairing = true
+    try {
+      const fix = preflight('--repair')
+      log(`--repair 退出码=${fix.ok ? 0 : '非0'}`)
+      const re = preflight('--check')
+      const good = re.ok && !closureBroken(re.stdout)
+      log(good
+        ? '✅ 修复成功：闭包复验通过。服务交由官方自己的恢复/relaunch 拉起（本脚本不抢端口、不 spawn dsh）。'
+        : '❌ 修复后复验仍未通过 —— 需人工介入（手动跑 --repair 看详细输出；日志在 ~/.dsh/plugin-console/）')
+    } finally { repairing = false; strikes = 0 }
+  } catch (error) {
+    log(`本轮异常（不影响下一轮）：${String(error?.message ?? error)}`)
+  }
+}
+
+// ── 后台守护（计划任务用）：自己脱离，不留控制台窗口 ──────────────────────────
+// ★ 为什么要这一模式（2026-10-14 实测）：计划任务直接跑 node.exe 会让 Windows 弹出**可见的
+//   控制台窗口**（本机实测桌面出现一个 Windows Terminal）；改用 .vbs 启动器（window style 0）
+//   又踩到 wscript 挂住、拉不起子进程。最稳的是让脚本**自己以 detached 方式再拉起一份**，
+//   并让它 `stdio: 'ignore' + windowsHide: true`（子进程没有控制台可挂）⇒ 任务那条命令立刻返回，
+//   真正干活的那份在后台无窗口运行。重复启动由 pid 锁挡住。
+if (HAS('--daemon')) {
+  const PID_FILE = join(LOG_DIR, 'fw-watchdog.pid')
+  const alive = (pid) => {
+    if (!Number.isInteger(pid) || pid <= 0) return false
+    try { process.kill(pid, 0); return true } catch { return false }
+  }
+  let already = null
+  try { already = Number(String(readFileSync(PID_FILE, 'utf8')).trim()) } catch {}
+  if (alive(already)) {
+    log(`后台看门狗已在运行（pid ${already}）—— 本次不重复启动`)
+    process.exit(0)
+  }
+  const { spawn } = await import('node:child_process')
+  const child = spawn(process.execPath, [fileURLToPath(import.meta.url)], {
+    detached: true, stdio: 'ignore', windowsHide: true,
+    env: { ...process.env },
+  })
+  child.unref()
+  try { mkdirSync(LOG_DIR, { recursive: true }); writeFileSync(PID_FILE, String(child.pid), 'utf8') } catch {}
+  log(`已用后台守护模式拉起看门狗（pid ${child.pid}，无窗口）`)
+  process.exit(0)
+}
+
+// ── 单轮完整逻辑（演练 / 计划任务手动触发）──
+if (HAS('--tick')) {
+  log('── 单轮完整逻辑（--tick）──')
+  await tick()
+  log('── 本轮结束 ──')
+  process.exit(0)
+}
+
+// ── 状态 / 诊断 ──
+if (HAS('--status') || HAS('--once')) {
+  const p = probeProcesses()
+  log(HAS('--once') ? '── 诊断（--once）──' : '── 状态（--status）──')
+  log(`外壳进程: ${p.shell} 个   HOST 服务进程: ${p.host} 个`)
+  log(`判定：${p.shell === 0 ? '外壳没在跑（不管）' : p.host > 0 ? '服务活着（正常）' : '★ 外壳在跑但服务不在（事故形态）'}`)
+  log(`预检脚本：${PREFLIGHT}`)
+  if (HAS('--once')) {
+    const check = preflight('--check')
+    log(`fw-preflight --check 退出码=${check.ok ? 0 : '非0'}${check.missing ? '（脚本缺失）' : ''}`)
+    if (!check.missing) {
+      log(check.stdout.trim().split('\n').map((l) => '    ' + l).join('\n'))
+      log(`闭包判定：${closureBroken(check.stdout) ? '★ 坏' : '好'}`)
+    }
+  }
+  process.exit(0)
+}
+
+// ── 常驻 ──
+// ★ 主入口守卫（2026-10-14 补）：没有它时，任何人 `import()` 本文件都会**意外启动常驻看门狗**
+//   （验证语法时就踩到过：一个 import 把看门狗跑起来了）。只在真正作为脚本执行时才启动。
+if (import.meta.main !== true) {
+  process.exit(0)
+}
+
+log(`看门狗启动：间隔=${INTERVAL_MS}ms 连续${STRIKES}轮 预检=${PREFLIGHT}`)
+log('判据：外壳在跑 + HOST 服务进程不在；只修框架闭包，不杀进程、不抢端口、不改官方文件')
+// 记下自己的 pid（`--daemon` 靠它防重复启动；退出时清掉）
+try { mkdirSync(LOG_DIR, { recursive: true }); writeFileSync(join(LOG_DIR, 'fw-watchdog.pid'), String(process.pid), 'utf8') } catch {}
+await tick()
+const timer = setInterval(tick, INTERVAL_MS)
+const stop = () => {
+  clearInterval(timer)
+  try {
+    const f = join(LOG_DIR, 'fw-watchdog.pid')
+    if (String(readFileSync(f, 'utf8')).trim() === String(process.pid)) rmSync(f, { force: true })
+  } catch {}
+  log('看门狗停止')
+  process.exit(0)
+}
+process.on('SIGINT', stop)
+process.on('SIGTERM', stop)