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

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-preflight.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+// scripts/fw-preflight.mjs —— **服务起不来时的预检与治包**（0.5.50 加法）
+//
+// 为什么要在**服务之外**再来一条命令（真机停机事故 2026-10-14）：
+//   那次的坏法是「框架包被掏空」—— `cordis` 顶层 junction 还在、它指向的 `.pnpm` 实体被清空；
+//   `dsh-llm` / `dsh-tools` / `dsh-web` 直接成了空目录。后果是 dsh 启动即
+//   `54 个插件 failed to import`、web 服务 exit code=1。
+//
+//   而既有的 safe-boot 快照恢复的是 **`cordis.patch.yml` 的文本**（配置层）—— 那次补丁好端端的，
+//   恢复它等于"把一份没坏的配置换成另一份没坏的配置"，四个空目录纹丝不动；
+//   指纹数的是 `.pnpm` 里的**目录个数** —— "壳还在、里面被掏空"⇒ 计数不变 ⇒ 不触发。
+//   最根本的是：**控制台插件是跑在 dsh 里的**，dsh 起不来它就从未加载（事故日志里出现 0 次）。
+//   ⇒ 这类事故必须在**服务之外**有一条出路。这就是本脚本。
+//
+// 三条硬约束（与 scripts/safe-boot.mjs 同族）：
+//   · **零依赖**：只用 Node 内置模块 + 本插件自己的 infra/domain 纯函数（不装包、**不联网**）；
+//   · **服务未运行也能跑**：不读端口、不连 webServer、不需要 profile 正被使用；
+//   · **绝不 kill / spawn / 抢端口 / 建计划任务**：只做文件级修复。
+//     （2026-10-10 的教训：那套"按端口 kill 再拉起"会与宿主争端口 ⇒ `listen EADDRINUSE`，
+//      或让桌面端外壳弹出「应用无法启动或已意外停止」。跑完要不要重启，由你自己决定。）
+//
+// 用法（在插件目录下，或 `node <插件目录>/scripts/fw-preflight.mjs`）：
+//   node scripts/fw-preflight.mjs --check              只诊断，列出坏掉的包（**一个字节都不写**）
+//   node scripts/fw-preflight.mjs --repair             从本地 npm 缓存把缺的包装回来，再复验
+//   node scripts/fw-preflight.mjs --check --json       机器可读输出
+//   可选：--fw-root <dir>  指定框架树（默认自动探测：从本插件解析 @deepseek-ai/dsh 反推）
+//         --cache <dir>   指定 npm 缓存根（默认自动找 npm_config_cache / %LOCALAPPDATA%\npm-cache / 常见位置）
+//         --help          显示本帮助
+
+import { isAbsolute, resolve } from 'node:path'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { detectFrameworkRoot } from '../lib/server/infra/fw-root-detect.js'
+import { runFwPreflight } from '../lib/server/domain/fw-preflight.js'
+
+const PLUGIN_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+
+const HELP = `框架闭包预检与治包（fw-preflight）—— 服务起不来时用这个，不需要服务在跑。
+
+用法：
+  node scripts/fw-preflight.mjs --check
+      只诊断：从 dsh 的 lib/bin.js 出发走一遍 @deepseek-ai/* 依赖闭包，
+      列出**解析不了**的包（= 真正的损坏面）。一个字节都不写。
+
+  node scripts/fw-preflight.mjs --repair
+      把解析不了的包装回来：按 package-lock.json 的 integrity 从**本地 npm 缓存**取 tarball 解开。
+      改前若目标已有内容，先改名成 <name>.preflight-bak-<时间戳>（绝不直接删）。
+      装完**重新走一遍闭包复验**，不靠"我装完了"自证。
+
+可选参数：
+  --fw-root <dir>   框架树根（含 @deepseek-ai/ 与 .pnpm/）。默认自动探测。
+  --cache <dir>     npm 缓存根（含 content-v2/）。默认自动探测，可重复。
+  --json            机器可读输出（面板/子代理可直接解析）。
+  --help            显示本帮助。
+
+判据为什么是"能不能解析"而不是"目录空不空"：
+  这次事故的形态是「目录壳还在、里面被掏空」—— 数目录个数完全看不见
+  （2026-10-14 实测：按"目录空不空"粗扫本机会误报 237 个；换成闭包判据后 287 个包精准通过，
+   清空一个立刻只点名那一个）。
+
+它不做什么：
+  不 kill 进程、不 spawn 服务、不抢端口、不建计划任务、不联网。
+  修完请自己重启服务（桌面端：完全退出再打开；独立 dsh web：终端里 Ctrl+C 后重跑）。
+`
+
+/** 解析命令行（只认本脚本声明的这几个开关；未知参数如实报错，不静默忽略）。 */
+function parseArgv(argv) {
+  const out = { mode: null, fwRoot: null, caches: [], json: false, help: false, bad: [] }
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i]
+    if (a === '--check') out.mode = 'check'
+    else if (a === '--repair') out.mode = 'repair'
+    else if (a === '--json') out.json = true
+    else if (a === '--help' || a === '-h') out.help = true
+    else if (a === '--fw-root') { out.fwRoot = argv[i + 1] ?? null; i += 1 }
+    else if (a === '--cache') { const v = argv[i + 1]; if (v) out.caches.push(v); i += 1 }
+    else out.bad.push(a)
+  }
+  return out
+}
+
+/**
+ * 探测框架树根：多基准（见 lib/server/infra/fw-root-detect.js 的头注释）。
+ * 这里只做转发，判据收在 infra 一处 —— 脚本与（日后的）路由不会分叉。
+ */
+function detectFwRoot() {
+  return detectFrameworkRoot({ pluginDir: PLUGIN_ROOT })
+}
+
+/** 把探测结果 + 修复结果渲染成人读报告。 */
+function renderReport(report, { attempted }) {
+  const lines = []
+  const bad = report.before?.broken ?? []
+  lines.push(`框架树 : ${report.fwRoot ?? '(未探测到)'}`)
+  lines.push(`解析入口: ${report.entry ?? '(无)'}${report.entryVia === null || report.entryVia === undefined ? '' : `  [${report.entryVia}]`}`)
+  lines.push(`npm 缓存: ${(report.cacheRoots ?? []).join(' ; ') || '(未找到 —— 只能诊断，不能修复)'}`)
+  lines.push('')
+  if (report.error !== undefined && report.error !== null) {
+    lines.push(`✗ ${report.error}`)
+    return lines.join('\n')
+  }
+  const walked = report.before?.walked?.length ?? 0
+  lines.push(attempted ? `① 修复前：走了 ${walked} 个包，${bad.length} 个解析不了` : `走了 ${walked} 个包，${bad.length} 个解析不了`)
+  for (const b of bad) lines.push(`   ✗ ${b.name}   ← ${b.from}  (${b.reason})`)
+  if (bad.length === 0) lines.push('   ✓ 依赖闭包完整 —— 框架树是好的，起不来的原因不在这里')
+
+  if (!attempted) {
+    if (bad.length > 0) lines.push('\n用 --repair 试着把它们装回来（只动文件，不碰任何进程）。')
+    return lines.join('\n')
+  }
+
+  lines.push('')
+  lines.push(`② 本次修复：成功 ${report.repaired.length} 个，失败 ${report.failed.length} 个，不可修 ${report.skipped.length} 个`)
+  for (const r of report.repaired) lines.push(`   ✓ ${r.name}@${r.version}  → ${r.via}  ${r.note}`)
+  for (const f of report.failed) lines.push(`   ✗ ${f.name}  (${f.action})  ${f.note}`)
+  for (const s of report.skipped) {
+    const why = { 'no-lock-entry': 'package-lock.json 里没有它的记录 —— 不猜版本', 'no-integrity': '记录里没有 integrity 校验和', 'no-target': '定不出该装到哪个目录' }[s.reason] ?? s.reason
+    lines.push(`   · ${s.name}  ${why}`)
+  }
+
+  lines.push('')
+  const after = report.after?.broken ?? []
+  lines.push(`③ 复验：走了 ${report.after?.walked?.length ?? 0} 个包，${after.length} 个仍解析不了`)
+  for (const b of after) lines.push(`   ✗ ${b.name}   ← ${b.from}`)
+  if (report.okAfter === true) {
+    lines.push('   ✓ 闭包已完整')
+    lines.push('')
+    lines.push('接下来：重启服务让修复生效（本脚本**不会**替你 kill / 拉起进程）。')
+    lines.push('  · 桌面端：完全退出 DeepSeek Harness，再重新打开')
+    lines.push('  · 独立 dsh web：在启动它的终端里 Ctrl+C，然后重新运行 dsh web')
+  } else {
+    lines.push('')
+    lines.push('仍有包解析不了。可能原因：本地 npm 缓存里也没有那些 tarball（本脚本不联网）。')
+    lines.push('可对该包单独装一次（会联网）：dsh plugin --profile <名> add <包名>')
+  }
+  return lines.join('\n')
+}
+
+async function main() {
+  const args = parseArgv(process.argv.slice(2))
+  if (args.help) { process.stdout.write(HELP); return 0 }
+  if (args.bad.length > 0) {
+    process.stderr.write(`未知参数：${args.bad.join(' ')}\n\n${HELP}`)
+    return 2
+  }
+  if (args.mode === null) {
+    process.stderr.write(`请指定 --check 或 --repair（或 --help）。\n\n${HELP}`)
+    return 2
+  }
+
+  let fwRoot = args.fwRoot
+  let via = 'explicit'
+  let tried = []
+  if (typeof fwRoot !== 'string' || fwRoot === '') {
+    const d = detectFwRoot()
+    fwRoot = d.fwRoot
+    via = d.via
+    tried = d.tried ?? []
+  } else {
+    fwRoot = isAbsolute(fwRoot) ? fwRoot : resolve(process.cwd(), fwRoot)
+  }
+
+  if (fwRoot === null || fwRoot === undefined || fwRoot === '') {
+    const msg = '探测不到框架树根 —— 请用 --fw-root <dir> 显式指定（该目录下应有 @deepseek-ai/ 与 .pnpm/）。'
+    const detail = tried.map((t) => `  · 试过 ${t.via}: ${t.base}`).join('\n')
+    if (args.json) process.stdout.write(`${JSON.stringify({ ok: false, error: msg, tried }, null, 2)}\n`)
+    else process.stderr.write(`✗ ${msg}\n${detail}\n`)
+    return 1
+  }
+
+  const cacheRoots = args.caches.length > 0 ? args.caches.map((c) => (isAbsolute(c) ? c : resolve(process.cwd(), c))) : null
+  const report = runFwPreflight({ fwRoot, repair: args.mode === 'repair', cacheRoots })
+  const payload = { ...report, fwRootVia: via, mode: args.mode }
+
+  if (args.json) process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`)
+  else process.stdout.write(`${renderReport(payload, { attempted: args.mode === 'repair' })}\n`)
+
+  // 退出码：诊断模式 = 闭包是否完整；修复模式 = 修复后是否完整（供脚本/CI 判断）
+  const good = args.mode === 'repair' ? report.okAfter === true : report.ok === true
+  return good ? 0 : 1
+}
+
+main().then((code) => { process.exitCode = code }, (error) => {
+  process.stderr.write(`fw-preflight 异常：${error?.stack ?? error}\n`)
+  process.exitCode = 1
+})

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%