dsh-standards 1.3.0 → 1.4.1

package/40-checker/src/semver.mjs

@@ -1,17 +1,23 @@
 /**
  * Minimal SemVer range matcher for the checker.
  *
- * It is intentionally small: the host evaluates plugin requirements with
+ * The host evaluates plugin requirements with
  * `semver.satisfies(runtime, range, { includePrerelease: true })`
- * (deepseek-harness/packages/boot/app-boot/src/plugin-compatibility.ts:52).
- * This module implements the subset that appears in package manifests:
- * exact versions, `>= > <= <`, `^`, `~`, `*`/`x`, space-separated AND,
- * and `||` alternatives. It does NOT implement hyphen ranges, `!=`,
- * or npm's "prerelease only matches same tuple" exclusion; the host uses
- * includePrerelease, so we include prereleases everywhere.
+ * (deepseek-harness/packages/boot/app-boot/src/plugin-compatibility.ts).
+ * This module implements the subset that appears in package manifests and in
+ * npm documentation: exact versions, `>= > <= < =`, `^`, `~`, `*`/`x`,
+ * space-separated AND (including `>= 0.2.2-rc.1`, where npm allows whitespace
+ * between an operator and its version), `||` alternatives, hyphen ranges and
+ * partial/x-ranges. Prereleases participate in ranges everywhere, matching the
+ * host's `includePrerelease: true`.
+ *
+ * It does NOT implement `!=` or npm's "prerelease only matches the same
+ * [major,minor,patch] tuple" exclusion: the host explicitly includes
+ * prereleases, so the checker must use the same rule.
  */
 
 const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/
+const OPERATORS = new Set(['>=', '<=', '>', '<', '=', '^', '~'])
 
 export function parseVersion(value) {
   if (typeof value !== 'string') return null
@@ -53,18 +59,26 @@ export function compareVersions(left, right) {
   return 0
 }
 
+// npm encodes an exclusive upper bound as `X.Y.Z-0`, which also excludes
+// prereleases of the boundary version. This matters for `^0.2.2-alpha.2`:
+// 0.3.0-0 must NOT satisfy it, while `<0.3.0` (an explicit user range) does.
+function sentinel(version) {
+  return { ...version, prerelease: ['0'] }
+}
+
 function upperForCaret(version) {
-  if (version.major > 0) return { ...version, major: version.major + 1, minor: 0, patch: 0, prerelease: [] }
-  if (version.minor > 0) return { ...version, minor: version.minor + 1, patch: 0, prerelease: [] }
-  return { ...version, patch: version.patch + 1, prerelease: [] }
+  if (version.major > 0) return sentinel({ ...version, major: version.major + 1, minor: 0, patch: 0 })
+  if (version.minor > 0) return sentinel({ ...version, minor: version.minor + 1, patch: 0 })
+  return sentinel({ ...version, patch: version.patch + 1 })
 }
 
 function upperForTilde(version) {
-  return { ...version, minor: version.minor + 1, patch: 0, prerelease: [] }
+  return sentinel({ ...version, minor: version.minor + 1, patch: 0 })
 }
 
+/** A version with optional missing minor/patch and optional prerelease. */
 function parsePartial(text) {
-  const match = /^v?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?$/.exec(text.trim())
+  const match = /^v?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(text.trim())
   if (!match) return null
   return {
     major: Number(match[1]),
@@ -77,76 +91,112 @@ function parsePartial(text) {
 function fullVersion(partial) {
   return { major: partial.major, minor: partial.minor ?? 0, patch: partial.patch ?? 0, prerelease: partial.prerelease }
 }
-function nextMinor(partial) { return { major: partial.major, minor: (partial.minor ?? 0) + 1, patch: 0, prerelease: [] } }
-function nextMajor(partial) { return { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } }
+function nextMinor(partial) { return { major: partial.major, minor: (partial.minor ?? 0) + 1, patch: 0, prerelease: ['0'] } }
+function nextMajor(partial) { return { major: partial.major + 1, minor: 0, patch: 0, prerelease: ['0'] } }
 function fmt(version) {
   const base = `${version.major}.${version.minor}.${version.patch}`
   return version.prerelease && version.prerelease.length ? `${base}-${version.prerelease.join('.')}` : base
 }
 
-function expandToken(raw) {
-  if (raw === '*' || raw === 'x' || raw === 'X') return '*'
-  const match = /^(>=|<=|>|<|=|\^|~)?\s*v?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?$/.exec(raw)
-  if (!match) return null
-  const op = match[1] ?? '='
-  const partial = {
-    major: Number(match[2]),
-    minor: match[3] === undefined || /[xX*]/.test(match[3]) ? null : Number(match[3]),
-    patch: match[4] === undefined || /[xX*]/.test(match[4]) ? null : Number(match[4]),
-    prerelease: match[5] ? match[5].split('.') : [],
+/**
+ * Expand one npm comparator (`^1.2`, `>= 0.2.2-rc.1`, `1.x`, ...) into the
+ * primitive {@link satisfiesToken} comparators. Returns null when the token is
+ * not a range this checker can evaluate.
+ */
+function comparatorsForToken(op, versionText) {
+  if (versionText === '*' || versionText === 'x' || versionText === 'X') {
+    return op === '=' || op === undefined ? [] : null
   }
+  const partial = parsePartial(versionText)
+  if (!partial) return null
+  const normalized = op ?? '='
+  if (!OPERATORS.has(normalized)) return null
   const low = fullVersion(partial)
   const noMinor = partial.minor === null
   const noPatch = partial.patch === null
-  if (!noMinor && !noPatch) return `${op}${fmt(low)}`
-  switch (op) {
+
+  if (!noMinor && !noPatch) {
+    const exact = parseVersion(fmt(low))
+    if (!exact) return null
+    if (normalized === '^') return [{ op: '>=', version: exact }, { op: '<', version: upperForCaret(low) }]
+    if (normalized === '~') return [{ op: '>=', version: exact }, { op: '<', version: upperForTilde(low) }]
+    return [{ op: normalized, version: exact }]
+  }
+
+  // Partial / x-range. Under includePrerelease npm gives the *lower* bound a
+  // `-0` sentinel too, so `^1.2` matches 1.2.0-0 while `>=1.2.3` does not.
+  const lowSentinel = sentinel(low)
+  switch (normalized) {
     case '^':
+      // ^1.2 -> <2.0.0-0, ^0.2 -> <0.3.0-0, ^0.0 -> <0.1.0-0
+      return noMinor || partial.major > 0
+        ? [{ op: '>=', version: lowSentinel }, { op: '<', version: nextMajor(partial) }]
+        : [{ op: '>=', version: lowSentinel }, { op: '<', version: nextMinor(partial) }]
     case '~':
+      return noMinor
+        ? [{ op: '>=', version: lowSentinel }, { op: '<', version: nextMajor(partial) }]
+        : [{ op: '>=', version: lowSentinel }, { op: '<', version: nextMinor(partial) }]
     case '=':
-      return noMinor ? `>=${fmt(low)} <${fmt(nextMajor(partial))}` : `>=${fmt(low)} <${fmt(nextMinor(partial))}`
-    case '>=': return `>=${fmt(low)}`
-    case '>': return noMinor ? `>=${fmt(nextMajor(partial))}` : `>=${fmt(nextMinor(partial))}`
-    case '<': return `<${fmt(low)}`
-    case '<=': return noMinor ? `<${fmt(nextMajor(partial))}` : `<${fmt(nextMinor(partial))}`
+      return noMinor
+        ? [{ op: '>=', version: lowSentinel }, { op: '<', version: nextMajor(partial) }]
+        : [{ op: '>=', version: lowSentinel }, { op: '<', version: nextMinor(partial) }]
+    case '>=': return [{ op: '>=', version: lowSentinel }]
+    case '>': return noMinor ? [{ op: '>=', version: nextMajor(partial) }] : [{ op: '>=', version: nextMinor(partial) }]
+    case '<': return [{ op: '<', version: lowSentinel }]
+    case '<=': return noMinor ? [{ op: '<', version: nextMajor(partial) }] : [{ op: '<', version: nextMinor(partial) }]
     default: return null
   }
 }
 
-/** Hyphen ranges and x-ranges are normalized before tokenizing. */
+/** Split a `||` alternative into comparator chunks, allowing `>= 1.2.3`. */
+function tokenizeComparators(text) {
+  const chunks = []
+  let rest = text
+  while (rest.trim() !== '') {
+    rest = rest.replace(/^\s+/, '')
+    const match = /^(>=|<=|>|<|=|\^|~)?\s*([^\s,]+)\s*/.exec(rest)
+    if (!match) return null
+    const op = match[1]
+    const versionText = match[2]
+    // An operator with no following version (`>=` alone) is malformed; the
+    // regex above would otherwise read the next operator as a version.
+    if (!op && OPERATORS.has(versionText)) return null
+    chunks.push({ op, versionText })
+    rest = rest.slice(match[0].length)
+  }
+  return chunks.length > 0 ? chunks : null
+}
+
 function expandAlternative(alternative) {
   const text = alternative.trim()
-  if (text === '' || text === '*' || text === 'x' || text === 'X') return '*'
-  const hyphen = /^(.+?)\s+-\s+(.+)$/.exec(text)
+  // An empty alternative is npm's `*` (node-semver treats `1.2.3 ||` as
+  // `*`). The wholly-empty range is rejected by the callers below.
+  if (text === '' || text === '*' || text === 'x' || text === 'X') return []
+  const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(text)
   if (hyphen) {
     const left = parsePartial(hyphen[1])
     const right = parsePartial(hyphen[2])
     if (!left || !right) return null
-    const low = `>=${fmt(fullVersion(left))}`
-    if (right.minor === null) return `${low} <${fmt(nextMajor(right))}`
-    if (right.patch === null) return `${low} <${fmt(nextMinor(right))}`
-    return `${low} <=${fmt(fullVersion(right))}`
-  }
-  const parts = []
-  for (const raw of text.split(/\s+/)) {
-    const expanded = expandToken(raw)
-    if (expanded === null) return null
-    parts.push(expanded)
+    const low = fullVersion(left)
+    // The left side is a floor: a concrete version keeps its exact prerelease,
+    // while a partial version gets the same -0 sentinel npm uses.
+    const lowToken = left.prerelease.length > 0
+      ? { op: '>=', version: low }
+      : { op: '>=', version: sentinel(low) }
+    if (right.minor === null) return [lowToken, { op: '<', version: nextMajor(right) }]
+    if (right.patch === null) return [lowToken, { op: '<', version: nextMinor(right) }]
+    if (right.prerelease.length === 0) {
+      return [lowToken, { op: '<', version: sentinel({ ...fullVersion(right), patch: fullVersion(right).patch + 1 }) }]
+    }
+    return [lowToken, { op: '<=', version: fullVersion(right) }]
   }
-  return parts.join(' ')
-}
-
-function tokenizeAlternative(alternative) {
-  const expanded = expandAlternative(alternative)
-  if (expanded === null) return null
-  if (expanded === '*') return [{ op: '*', version: null }]
+  const chunks = tokenizeComparators(text)
+  if (!chunks) return null
   const tokens = []
-  for (const raw of expanded.split(/\s+/)) {
-    const match = /^(>=|<=|>|<|=|\^|~)?\s*v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/.exec(raw)
-    if (!match) return null
-    const op = match[1] ?? '='
-    const version = parseVersion(match[2])
-    if (!version) return null
-    tokens.push({ op, version })
+  for (const chunk of chunks) {
+    const expanded = comparatorsForToken(chunk.op, chunk.versionText)
+    if (expanded === null) return null
+    tokens.push(...expanded)
   }
   return tokens
 }
@@ -160,8 +210,6 @@ function satisfiesToken(version, token) {
     case '>=': return cmp >= 0
     case '<': return cmp < 0
     case '<=': return cmp <= 0
-    case '^': return cmp >= 0 && compareVersions(version, upperForCaret(token.version)) < 0
-    case '~': return cmp >= 0 && compareVersions(version, upperForTilde(token.version)) < 0
     default: return false
   }
 }
@@ -175,10 +223,9 @@ export function satisfies(version, range) {
   const parsed = parseVersion(version)
   if (!parsed || typeof range !== 'string') return false
   if (range.trim() === '') return false
-  const alternatives = range.split('||')
-  for (const alternative of alternatives) {
-    const tokens = tokenizeAlternative(alternative)
-    if (!tokens || tokens.length === 0) continue
+  for (const alternative of range.split('||')) {
+    const tokens = expandAlternative(alternative)
+    if (!tokens) continue
     if (tokens.every(token => satisfiesToken(parsed, token))) return true
   }
   return false
@@ -188,7 +235,7 @@ export function satisfies(version, range) {
 export function validRange(range) {
   if (typeof range !== 'string' || range.trim() === '') return false
   for (const alternative of range.split('||')) {
-    if (!tokenizeAlternative(alternative)) return false
+    if (!expandAlternative(alternative)) return false
   }
   return true
 }

package/40-checker/src/util.mjs

@@ -56,21 +56,31 @@ const BUILD_FILE = /(?:^|\/)(?:build|esbuild|vite|rollup|webpack)\.config\.[cm]?
 
 /**
  * Collect source files without following symlinks. Deterministic order, bounded.
+ * Returns the files plus scan metadata so callers can report truncation instead
+ * of pretending the bounded scan saw the whole package.
  * @param {string} root
  * @param {{maxFiles?: number, maxBytes?: number}} [options]
  */
-export function listSourceFiles(root, options = {}) {
+export function scanSourceFiles(root, options = {}) {
   const maxFiles = options.maxFiles ?? 400
   const maxBytes = options.maxBytes ?? 2_000_000
-  const files = []
+  const paths = []
   let bytes = 0
+  let truncated = false
+  let skippedForBytes = 0
   const walk = (directory) => {
-    if (files.length >= maxFiles || bytes >= maxBytes) return
+    if (paths.length >= maxFiles || bytes >= maxBytes) {
+      truncated = true
+      return
+    }
     let entries
     try { entries = fs.readdirSync(directory, { withFileTypes: true }) } catch { return }
     entries.sort((a, b) => a.name.localeCompare(b.name))
     for (const entry of entries) {
-      if (files.length >= maxFiles || bytes >= maxBytes) return
+      if (paths.length >= maxFiles || bytes >= maxBytes) {
+        truncated = true
+        return
+      }
       const absolute = path.join(directory, entry.name)
       if (entry.isDirectory()) {
         if (SKIP_DIRECTORIES.has(entry.name)) continue
@@ -84,24 +94,57 @@ export function listSourceFiles(root, options = {}) {
       if (BUILD_FILE.test(relative)) continue
       let size = 0
       try { size = fs.statSync(absolute).size } catch { continue }
-      if (bytes + size > maxBytes) continue
+      if (bytes + size > maxBytes) {
+        // A file that does not fit is skipped; later smaller files may still
+        // fit, but the scan as a whole is no longer exhaustive.
+        truncated = true
+        skippedForBytes += 1
+        continue
+      }
       bytes += size
-      files.push(absolute)
+      paths.push(absolute)
     }
   }
   walk(root)
-  return files
+  return {
+    paths,
+    stats: {
+      files: paths.length,
+      bytes,
+      maxFiles,
+      maxBytes,
+      truncated,
+      skippedForBytes,
+    },
+  }
+}
+
+export function listSourceFiles(root, options = {}) {
+  return scanSourceFiles(root, options).paths
 }
 
 /** Read all source files once, returning {file, relative, text} records. */
 export function readSources(root, options) {
-  return listSourceFiles(root, options).map(file => ({
+  return scanSourceFiles(root, options).paths.map(file => ({
     file,
     relative: posixRelative(root, file),
     text: readText(file),
   }))
 }
 
+/** Like readSources(), but also returns the bounded-scan metadata. */
+export function readSourcesWithStats(root, options) {
+  const { paths, stats } = scanSourceFiles(root, options)
+  return {
+    sources: paths.map(file => ({
+      file,
+      relative: posixRelative(root, file),
+      text: readText(file),
+    })),
+    scan: stats,
+  }
+}
+
 export function regexHits(sources, pattern) {
   const hits = []
   for (const source of sources) {

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 1.4.1 — 2026-11-06
+
+- 建议的 `docsUrl` 基址跟到 `dsh-plugin-guide@v0.4.6`（FLOW 示例修正版），不再指向 0.4.4。
+
+## 1.4.0 — 2026-11-06
+
+### Added
+
+- 契约文件：`spec/schemas/conformance.schema.json`（dsh-conformance/1）、`spec/dsc-clauses.json`（14 父 + 60 子）、`spec/schemas/boost-card.schema.json` + 示例、`spec/examples/flow-evidence.example.json`、`spec/coverage-contract.md`。
+- `notChecked[]`：NA/ERROR/partial 项带 `reason` + `howToEnable`，报告能回答“为什么没查、怎么才能查”。
+- bundle/client 的 DSC-04–09 静态子集（PASS/WARN + partial），不再 8 项全 NA。
+- sidecar 加 `title/repo/license/scope/checks/checkedBy/notChecked`，种 20 条真实插件。
+- `check` 默认 `--entry-claim static --no-exec`，报告标注“未执行插件代码”；host 版本三态（显式/环境/受控探测），默认不执行 PATH 的 dsh。
+
+### Fixed
+
+- C-2 range 解析：支持 `>= 0.2.2-rc.1`、hyphen/x-range、`||`，prerelease 语义对齐 node-semver；合法范围不再误报 C-2.1，覆盖判断归 C-2.2。
+- DSC-01 检查全部 `exports` 子路径与 `main` 的真实文件存在性，坏入口 FAIL。
+- DSC-10 文件截断改为 `NA + coverage=partial` 并明示截断位置，不再假报 ERROR。
+- advice：54 条规则 docsUrl 改到具体小节；C-11.4/C-12.4 同证据合并；`package.json#field` 补 `file:line`。
+- 文档纠偏：删除 BOOST 的 -17%/-33%/-25%、「保证更省」、「token 直接计价」，明确「BOOST 与 FLOW 不可比、性能未证实」。
+- README/SUPPORTED 对齐 1.4.0，补 Windows 行与 14 项默认检查说明。
+
+### Verified
+
+- `npm test` 232/232。
+
 ## 1.3.0 — 2026-11-06
 
 ### Added

package/README.md

@@ -23,7 +23,7 @@
 
 ```sh
 npm i -g dsh-standards                                        # 全局：dsh-standards + dsh-levels
-npx dsh-standards <plugin-dir> --scope entry --entry-claim static   # 或不装，直接用 npx
+npx dsh-standards check <plugin-dir>                          # 安全默认：静态检查，不执行插件代码
 ```
 
 </div>
@@ -44,9 +44,9 @@ DSH 插件的采用深度分三层，每层一个问题、一套证据状态，*
 
 仓里就三样东西：`40-checker/`（DS-C 一致性检查器与全部证据脚本）、`bin/`（两个公开入口 `dsh-standards` 与 `dsh-levels`），以及 `spec/` 与 `31`–`35` 号规范正文。工具只读目标包，不改被检对象；结论只认证据，`not-run`、`NA`、`static` 都不会被写成 PASS。
 
-npm 上的旧占位 `dsh-standards@0.0.3` 只是名字预留，这条 1.x 线取代了它（当前 `1.1.2`）；两个 bin 分别叫 `dsh-standards` 与 `dsh-levels`。
+npm 上的旧占位 `dsh-standards@0.0.3` 只是名字预留，这条 1.x 线取代了它（当前 `1.3.0`）；两个 bin 分别叫 `dsh-standards` 与 `dsh-levels`。
 
-固定锚点（写在 `spec/levels.json` 与报告里）：`repo=deepseek-ai/deepseek-harness`、`commit=ce7073d51254`、`dsh=0.2.2-alpha.2`、`cordis=4.0.6-alpha.1`。换运行时版本要显式传参，报告会记下你量的是哪一版。
+锚点不是硬编码的通行证：`repo` / `commit` / `cordis` 记在报告里，`dsh` 由 `--host-version`、`DSH_HOST_VERSION` 或显式 `--allow-host-probe` 解析；都没有时报告写「host 版本未知」，并标 `source=default, suspect=true`。换一次版本就是另一把尺子，旧报告不能直接当新版本的证据。
 
 ### 当前硬数据
 
@@ -55,7 +55,7 @@ npm 上的旧占位 `dsh-standards@0.0.3` 只是名字预留，这条 1.x 线取
 - 18 包 base-only runtime：**18/18 有原始 JSON；10/18 G3 verified，8 partial，0 error**；host gate 后 **8 clean + 2 reject + 8 partial**；
 - client runtime：**15/15 `client-module-loaded`**（真实 Chromium）；web-app **4/4 loaded**；
 - 不可用：**0 plugin code FAIL；2 host-gate reject（telemetry/verification）**；
-- 检查器自测：**128/128 tests**（本地 `node --test 40-checker/test/*.test.mjs`；含治理、DCO、评价记录、声明、验真、链、漂移测试）；
+- 检查器自测：**`npm test` 全绿**（本地 Node 24；含安全默认、host 三态、治理、DCO、评价记录、声明、验真、链、漂移测试）；
 - J1：**6 PASS + 1 WARN**；LEV-3：volatile **0/20** vs control **20/20** remount；LEV-6：稳定 prefix **100%** vs 易变 **0%**；LEV-7：**8.24×**（合成，非生产基线）。
 
 这些数字是自评与仓内证据链的输出，不是第三方复核结论——报告里的 `notClaimed` 字段会把「官方标准、认证、安全审计、排名、生产基线」逐条列出来。
@@ -72,6 +72,7 @@ npm 上的旧占位 `dsh-standards@0.0.3` 只是名字预留，这条 1.x 线取
 - [33-DSH-BOOST 加速实践](33-DSH-BOOST加速实践.md) — 8 条 LEV
 - [34-三层分级模型（GB/GB-T/GB-Z 类比）](34-三层分级模型-GB-GBT-GBZ类比.md) — 为什么是三层、怎么读
 - [35-三层开发建议与验收清单](35-三层开发建议与验收清单.md) — 作者最短路径 / 评审清单
+- [docs/coverage.md](docs/coverage.md) — 14 项检查：默认查什么、不查什么、怎么开启
 - [36-插件全生命周期与工具链](36-插件全生命周期与工具链.md) — 从脚手架到退役
 - [37-PerryLink 插件生态三层对照](37-PerryLink插件生态-三层对照与升级清单.md) — 我的仓怎么升级
 - [38-三层标准 RFC](38-RFC-三层标准-待商议问题.md) — 内测群商议的 8 个问题
@@ -116,6 +117,9 @@ npx -p dsh-standards dsh-levels --help
 **2. 跑一次检查**（目标是一个含 `package.json` 的包目录）：
 
 ```sh
+# 作者入口（推荐）：默认 --entry-claim static --no-exec，不执行插件代码
+dsh-standards check ./my-plugin
+
 # 入门兼容性：静态识别，不声明运行时证据
 dsh-standards ./my-plugin --scope entry --entry-claim static
 
@@ -127,6 +131,8 @@ dsh-standards ./my-plugin --format sarif --out report.sarif
 dsh-levels ./my-plugin --format json --out audit.json
 ```
 
+`check` 是面向作者的安全入口：**默认 `--entry-claim static --no-exec`，不执行插件代码**；Markdown 报告顶部会写明「本次未执行插件代码」。要跑 L1–L3，必须显式给 `--runtime <cordis lib/index.js>`（bundle 用 `--host`）或 `--entry-claim runtime`，否则运行时项一律记 `not-run`，绝不写成 PASS。它也不会无条件执行 PATH 里的 `dsh`：anchor 依次取 `--host-version`、`$DSH_HOST_VERSION`，再次才是显式 `--allow-host-probe`；三者都没有时报告写「host 版本未知」，并标 `source=default, suspect=true`。
+
 **3. 看结论**——先看 exit code，再看 `status`：
 
 ```text
@@ -191,19 +197,21 @@ coverage: mandatory=5 pass=5 warn=0 fail=0 na=0 notRun=0
 
 ## 配置
 
-没有配置文件——全部可调项就是命令行参数。两个命令各一套：`dsh-standards <package-dir>` 转发给 DS-C 检查器（`--help` 打印完整用法），`dsh-levels <package-dir>` 转发给三层审计。
+没有配置文件——全部可调项就是命令行参数。三个入口各一套：`dsh-standards check <package-dir>` 是作者安全入口（默认静态、不执行插件代码），`dsh-standards <package-dir>` 是向后兼容的裸检查器（不附加安全默认，`--help` 打印完整用法），`dsh-levels <package-dir>` 转发给三层审计。下表默认值指 `check`；裸检查器的 `--entry-claim` / `--no-exec` 默认仍是 `runtime` / `false`。
 
-最常用的 8 个：
+最常用的 10 个：
 
 | 参数 | 默认值 | 含义 |
 |---|---|---|
 | `<package-dir>` | `.` | 目标包目录，必须含 `package.json`；tarball 不在支持范围 |
 | `--scope` | `ds-c` | `mvp` = 8 个 MVP ID；`ds-c` = 全量声明；`entry` = 兼容性门 |
 | `--format` | `text` | `text` / `json` / `sarif`（SARIF 2.1.0） |
-| `--entry-claim` | `runtime` | `runtime` 需 DSC-14 运行时证据；`static` 只声明结构识别 |
-| `--host` | — | app-boot 的 `lib/index.js`；bundle 的 G0–G3 冒烟必需 |
+| `--entry-claim` | `static`（`check`；裸检查器 `runtime`） | `runtime` 需 DSC-14 运行时证据；`static` 只声明结构识别 |
+| `--host` | — | app-boot 的 `lib/index.js`；bundle 的 G0–G3 冒烟必需，也视为执行 opt-in |
 | `--profile` | `package` | `package` / `listing` / `both`；给了 `--market-index` 时默认 `listing` |
-| `--no-exec` | `false` | 跳过 L1–L3，记 `not-run`（绝不记 PASS） |
+| `--no-exec` | `true`（`check`；裸检查器 `false`） | 跳过 L1–L3，记 `not-run`（绝不记 PASS） |
+| `--host-version` | `$DSH_HOST_VERSION` | `check` 专用的宿主 dsh 版本；不执行任何 `dsh` |
+| `--allow-host-probe` | `false` | 显式允许 `check` 解析 `dsh` 的 JS 入口并 `node ... --version` 探测 |
 | `--out` | — | 报告写入文件；不给就打 stdout |
 
 <details>
@@ -215,19 +223,21 @@ coverage: mandatory=5 pass=5 warn=0 fail=0 na=0 notRun=0
 | `--scope` | `ds-c` | 检查范围：`mvp` / `ds-c` / `entry` |
 | `--profile` | `package` | 评估 profile：`package` / `listing` / `both` |
 | `--runtime` | — | 指向构建好的 `@deepseek-ai/cordis` `lib/index.js`，开启 L1–L3 |
-| `--runtime-version` | `0.2.2-alpha.2` | 写进 anchor 的 dsh 运行时版本，供 C-2 判定 |
+| `--runtime-version` | 宿主版本（`check`）；否则内置常量 | 写进 anchor 的 dsh 运行时版本，供 C-2 判定；报告用 `anchor.runtimeSource` 说明来源 |
 | `--cordis-version` | `4.0.6-alpha.1` | 写进 anchor 的 cordis 版本 |
 | `--commit` | `ce7073d51254` | 写进 anchor 的 harness commit |
 | `--install-spec` | — | 给 C-3 用的推荐安装 spec |
 | `--market-index` | — | 格式 1 的市场索引 JSON，开启 listing 模式 |
 | `--plugin-name` | — | 市场索引里的插件名 |
 | `--timeout` | `10000` | L1–L3 超时毫秒（100–120000） |
-| `--no-exec` | `false` | 完全跳过 L1–L3，记 `not-run` / `NA` |
+| `--no-exec` | `false`（裸检查器；`check` 默认 `true`） | 完全跳过 L1–L3，记 `not-run` / `NA` |
 | `--static-only` | `false` | M1 模式：只留 C-1/C-2/C-3/C-11/C-12/C-13，C-4–C-9 直接出界 |
 | `--treat-as-plugin` | `false` | 对 bundle 的 server 入口跑 L1–L3 |
 | `--entry-runtime` | `require` | entry 门要完整 G0–G3，还是接受 `server-entry` 代理 |
-| `--entry-claim` | `runtime` | entry 门要运行时证据（DSC-14），还是只做静态识别 |
-| `--host` | — | app-boot `lib/index.js`，开启 bundle 的 G0–G3 冒烟 |
+| `--entry-claim` | `runtime`（裸检查器；`check` 默认 `static`） | entry 门要运行时证据（DSC-14），还是只做静态识别 |
+| `--host` | — | app-boot `lib/index.js`，开启 bundle 的 G0–G3 冒烟（`check` 中视为执行 opt-in） |
+| `--host-version` | `$DSH_HOST_VERSION` | `check` 专用：直接声明宿主版本，不执行 `dsh` |
+| `--allow-host-probe` | `false` | `check` 专用：显式允许探测宿主版本 |
 | `--base` | — | bundle 冒烟用的 base `cordis.patch.yml` |
 | `--web` | — | bundle 冒烟用的 web-app `cordis.patch.yml` |
 | `--bare` | — | host farm 的 bare-module 基线目录 |
@@ -297,7 +307,8 @@ coverage: mandatory=5 pass=5 warn=0 fail=0 na=0 notRun=0
 - **不声称官方推荐或采纳；不声称认证 / 认可 / 安全审计。**
 - **MVP 覆盖缺口**：`--scope mvp` 只落 8 个 ID，`DSC-03/10/11/12/13` 不在其中；它的结论是 `subset: "MVP-13"`、`level: null`，不得当 DS-C 徽章用。
 - **只吃包目录**：目标必须是含 `package.json` 的目录；tarball 支持不在 MVP 里。
-- **运行时结论有前置条件**：没有 `--runtime` 或 `--host` 时 L1–L3 只能记 `not-run`；`--entry-claim static` 永远给不出运行时结论。
+- **运行时结论有前置条件**：没有 `--runtime` 或 `--host` 时 L1–L3 只能记 `not-run`；`--entry-claim static` 永远给不出运行时结论。`check` 默认就是不执行（`--no-exec`），这是刻意的安全默认，不是缺陷。
+- **host 版本可能未知**：`check` 不无条件执行 PATH 里的 `dsh`；没有 `--host-version` / `DSH_HOST_VERSION` / `--allow-host-probe` 时，anchor 写默认常量并标 `source=default, suspect=true`，报告顶部写「host 版本未知」。
 - **结论带版本锚点**：`commit` / `dsh` / `cordis` 变了就是另一把尺子，旧报告不能直接当新版本的证据。
 - **BOOST 数据不是生产基线**：LEV 的 8/8 measured 来自 loader / context / provider-capture / synthetic timer 的合成环境，LEV-7 的 8.24× 同理。
 - **文本改动必须说明**：复制或修改本仓文本时，必须在显著位置给出 Change Notice（来源 commit、改了哪个章节、改了什么、为什么、日期），见 [`MODIFICATION-POLICY.md`](MODIFICATION-POLICY.md)；标志与 badge 不随许可证授权，规则见 `governance/mark-policy.md`。
@@ -308,9 +319,10 @@ coverage: mandatory=5 pass=5 warn=0 fail=0 na=0 notRun=0
 git clone https://github.com/PerryLink/dsh-standards.git
 cd dsh-standards
 
-node --test 40-checker/test/*.test.mjs                      # 128/128
+node --test 40-checker/test/*.test.mjs                      # 全绿（含安全默认与 host 三态）
+node bin/dsh-standards.mjs check 40-checker/fixtures/good   # 安全默认：静态、不执行
 node bin/dsh-standards.mjs 40-checker/fixtures/good \
-  --scope entry --entry-claim static --format text          # 本仓 fixture 冒烟
+  --scope entry --entry-claim static --format text          # 裸检查器 fixture 冒烟
 node bin/dsh-levels.mjs 40-checker/fixtures/good --format json
 
 # 从源码直连检查器：结构识别 / 声明运行（bundle 需要 host）

package/docs/coverage.md

@@ -0,0 +1,82 @@
+# 覆盖说明（14 项）— `dsh-standards check` 默认查什么
+
+`dsh-standards check <package-dir>` 是作者入口。**默认 `--entry-claim static --no-exec`：不执行插件代码**。本文只描述这套默认，不把 `not-run` / `NA` 写成 PASS。
+
+默认命令等价于：
+
+```sh
+dsh-standards check <package-dir> \
+  --entry-claim static --no-exec --scope ds-c --profile package
+```
+
+## 一眼看总数
+
+| 口径 | 数量 | 说明 |
+|---|---|---|
+| 报告固定携带 | **14** | `DSC-01` … `DSC-14` |
+| 默认实际评估 | **6** | `DSC-01`、`DSC-02`、`DSC-10`、`DSC-11`、`DSC-12`、`DSC-13` |
+| 默认未检查 | **8** | `DSC-03`（NA）+ `DSC-04`–`DSC-09`（not-run）+ `DSC-14`（NA） |
+
+`not checked` 桶把 NA / not-run / ERROR 都列出来；**没检查不等于通过**。`DSC-10` 是 advisory，只提供信号，不改变结论。
+
+## 14 项逐条
+
+| ID | 层 | 默认状态 | 默认为什么 | 怎么开启 |
+|---|---|---|---|---|
+| `DSC-01` | L0 | **检查** | manifest / name / version / license / 入口 / 导出形态 | 默认即查 |
+| `DSC-02` | L0 | **检查** | `engines.dsh` / peer 是否被 anchor 的宿主版本满足 | 默认即查；版本源见下 |
+| `DSC-03` | L0 | **NA** | 没有安装 spec / 市场索引可查 | `--install-spec <spec>`，或 `--market-index <file> --plugin-name <name>`（listing） |
+| `DSC-04` | L1 | **not-run** | `--no-exec`，不导入插件 | `--runtime <cordis lib/index.js>`；bundle 用 `--host <app-boot lib/index.js>` |
+| `DSC-05` | L1 | **not-run** | 同上 | 同上 |
+| `DSC-06` | L1+L2 | **not-run** | 同上 | 同上 |
+| `DSC-07` | L2 | **not-run** | 同上 | 同上 |
+| `DSC-08` | L3 | **not-run** | 同上 | 同上 |
+| `DSC-09` | L1 | **not-run** | 同上 | 同上 |
+| `DSC-10` | L0 | **检查（advisory）** | import 期副作用静态信号 | 默认即查；不单独 FAIL |
+| `DSC-11` | L0 | **检查** | `dsh.capabilities` 与高信号触发 | 默认即查 |
+| `DSC-12` | L0 | **检查** | 凭据 backing file、`listRecords`、seam、commitments/disclosure 形状 | 默认即查 |
+| `DSC-13` | L0 | **检查** | `dsh.labels` / `upstream` / 禁用语标签 | 默认即查 |
+| `DSC-14` | L1 | **NA** | 默认 `entry-claim=static`，不声明运行时证据 | `--scope entry --entry-claim runtime --runtime <...>`（bundle 加 `--host`） |
+
+## 执行 opt-in
+
+默认不执行插件代码。以下任一参数出现，才算显式允许运行时检查：
+
+- `--runtime <path>`：Cordis 运行时的 `lib/index.js`，开启 L1–L3；
+- `--host <file>`：app-boot 入口，开启 bundle 的 G0–G3 冒烟；
+- `--entry-claim runtime`：entry 门声明运行时证据（通常还要配 `--runtime` / `--host`）。
+
+想保留运行时声明但只看静态结果，显式加 `--no-exec`。`--runtime-version` 只是 anchor，**不是**执行开关。
+
+## host 版本从哪里来
+
+`check` 不会无条件执行 PATH 里的 `dsh`。anchor 按以下顺序取：
+
+1. `--host-version <v>`；
+2. `DSH_HOST_VERSION` 环境变量；
+3. `--allow-host-probe`：解析 `dsh` 的 JS 入口，执行 `node <entry> --version`（仅此一种情况会探测）；
+4. 都没有：报告写「host 版本未知」，`anchor.runtimeSource=default`、`anchor.suspect=true`。
+
+三态在 JSON 里可直接核对：`anchor.hostVersionKnown`、`anchor.hostVersionSource`（`flag` / `env` / `probe` / `none`）、`anchor.runtimeSource`（`host` / `default`；显式 `--runtime-version` 时保留 `cli`）。
+
+## 跨平台
+
+- **Windows：** `unshare -Urn` / `prlimit` 不可用 → sandbox degraded；本仓**不声称** Windows 上的 runtime 结论，矩阵里的 Windows / Node 22 行固定 `not-run`。静态检查（上表 6 项）仍可跑。
+- **WSL2（Ubuntu 24.04）：** Linux 沙箱可用，能提供 `unshare` / `prlimit`；这是本仓做 runtime 采集的环境。WSL2 可用不等于某个 host × Node × checker 组合已经跑过，具体以 [SUPPORTED.md](../SUPPORTED.md) 的格子为准。
+- **Node：** 包声明 `engines.node >=24.9.0`；Node 22 只在自测 / 静态矩阵中有记录（见 SUPPORTED.md）。
+
+## 复核命令
+
+```sh
+# 默认：6/14 评估，8 项 not-run/NA
+dsh-standards check <package-dir> --json | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{const r=JSON.parse(s);console.log(r.coverage.checked+"/"+r.coverage.total);console.log(r.anchor);console.log(r.safety)})'
+
+# 显式声明宿主版本，仍不执行插件
+dsh-standards check <package-dir> --host-version 0.2.2-rc.1
+
+# 显式允许宿主版本探测（只跑 dsh --version，不跑插件）
+dsh-standards check <package-dir> --allow-host-probe
+
+# 显式开启 L1–L3（会执行插件代码）
+dsh-standards check <package-dir> --runtime /path/to/cordis/lib/index.js
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-standards",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "DSH plugin standards and conformance checks: ENTRY/FLOW checks plus BOOST guidance. Non-official; no certification or ranking.",
   "type": "module",
   "main": "40-checker/src/index.mjs",