@mycf711/dsh-gate 0.1.0 → 0.1.2

package/README.md

@@ -62,6 +62,25 @@ if (!result.ok) return
 `extends` 循环、目标不存在、嵌套超过 8 层：**记录到 `errors`，按本层规则继续**（fail-open）。
 一个坏配置文件不应该让整个门禁不可用。
 
+**写盘侧是 fail closed 的**：`writeGateConfig()`（以及面板的 `POST /gates`）是**整层重写**，
+只写 `version` / `name` / `extends` / `rules` / `semantic`（`extends` 只保留 `false` / `"none"`），
+不会解析也不会重放基文件。所以：
+
+| 写盘时的 `extends` | 行为 |
+|---|---|
+| 不写，文件里也没有 | 正常整层重写 |
+| `false` / `"none"`（入参或文件里已有） | 允许，原样写回 —— 写回后仍是「替换」语义 |
+| 入参是 `true` / `"default"` / 路径 / 内联对象 | 报错，错误里点名**配置路径**与解决方式 |
+| 文件里已有上面这些共享形式 | 同样报错：整层重写会把共享基和它带来的规则一起冲掉 |
+
+错误码 `extends_not_preservable`，`error.path` 是那份配置的绝对路径。想改写这种层，
+要么直接手工编辑文件，要么先把基规则合并进本层规则、删掉 `extends` 后再从面板保存。
+坏 JSON 的层例外：原文会先写进 `.bak`，再写入新配置（可恢复，不算静默丢失）。
+`validateConfig()` 会原样保留 `extends`（只做形状校验），写不写由 `writeGateConfig()` 按路径判定 ——
+否则「面板 → POST /gates → 写盘」这条链上就没人知道调用方传过 `extends` 了。
+
+`--config` 传入的配置**不做 `extends` 解析**（调试 / CI 用，只按该文件本层规则跑）。
+
 ### 语义复审只能由用户层打开
 
 项目层 / 本地层**只能关闭**语义复审：
@@ -105,6 +124,26 @@ if (!result.ok) return
 | `destructive` | 禁止破坏性操作建议 | regex | 强推、`rm -rf /`、删分支、关他人 PR |
 | `empty` | 不能是空回复 | nonEmpty | 空串 / 纯空白（仅回复类触发器） |
 
+### 规则启停（`enabled`）
+
+每条规则可选 `enabled`，**缺省 `true`**：
+
+| 写法 | 行为 |
+|---|---|
+| 不写 / `true` | 规则生效 |
+| `false` | **本层明确停用**同 id 规则：不参与判定，连 `warn` 都不出 |
+
+```json
+{ "id": "secret", "type": "regex", "pattern": "ghp_[A-Za-z0-9]{20,}", "enabled": false }
+```
+
+- 同 id 后层**完整覆盖**前层（含 `enabled`）：停用不会被更前层复活；后层写 `enabled: true` 即恢复。
+- 复启必须写**同 id 完整规则**：只写 `{ "id": "secret", "enabled": true }` 缺 `type` 判非法，
+  `validateConfig` 返回「规则缺少 type」，面板保存会报错 —— 不会静默变回停用。
+- 写盘保留 `enabled: false`（JSON 往返仍是 `false`）；没写 `enabled` 的旧配置写回不凭空加字段。
+- 非布尔 `enabled`（例如字符串 `"false"`）判非法；读配置时按「规则仍生效」处理（fail-closed）。
+- 默认配置 `gates/default.json` 不写 `enabled`，10 条规则全开。
+
 ## API
 
 ### 确定性门禁
@@ -114,11 +153,11 @@ if (!result.ok) return
 | `createGate(options?)` | `GateProvider` | 稳定接口；`options.repo` / `options.config` / `options.semantic` / `options.semanticOptions` |
 | `loadGateConfig(options?)` | `{ config, sources, errors }` | 四层合并；`repo` / `home` / `env` / `defaultPath` 可注入 |
 | `mergeConfig(base, override)` | `config` | 同 id 覆盖、不同 id 追加 |
-| `normalizeConfig(input)` | `config` | 非法规则静默丢弃（写盘前请用 `validateConfig`） |
-| `lintText(text, config, options?)` | `{ ok, hits }` | `options.trigger` / `options.current` |
-| `validateConfig(input)` | `{ ok: true, config }` 或 `{ ok: false, error }` | 写盘 / 面板保存前校验 |
+| `normalizeConfig(input)` | `config` | 非法规则静默丢弃（写盘前请用 `validateConfig`）；保留规则的 `enabled` |
+| `lintText(text, config, options?)` | `{ ok, hits }` | `options.trigger` / `options.current`；跳过 `enabled: false` 的规则 |
+| `validateConfig(input)` | `{ ok: true, config }` 或 `{ ok: false, error }` | 写盘 / 面板保存前校验；`enabled` 必须是布尔、复启必须写完整规则；`extends` 只校验形状并原样带回 |
 | `readGateScope(scope, options?)` | `{ path, config, error? }` | `scope` = `default` / `user` / `project` / `local` |
-| `writeGateConfig(scope, config, options?)` | `{ path, config }` | 只允许 `user` / `project` / `local`；先 `.bak` 再原子替换 |
+| `writeGateConfig(scope, config, options?)` | `{ path, config }` | 只允许 `user` / `project` / `local`；先 `.bak` 再原子替换；共享 `extends` 抛错（`code: 'extends_not_preservable'`） |
 | `userGatePath` / `projectGatePath` / `localGatePath` | `string` | 路径派生 |
 | `DEFAULT_GATE_PATH` / `TRIGGERS` / `RULE_TYPES` | 常量 | 默认规则路径与枚举 |
 
@@ -151,7 +190,8 @@ interface GateProvider {
 ```
 
 `check()` 先跑确定性规则；只有触发器是 `merge` / `release` **且**配置里
-`semantic.enabled === true` 时才追加语义复审。
+`semantic.enabled === true` 时才追加语义复审。**硬门禁已经不过时不再请求模型**
+（此时 `semantic` 为 `{ skipped: true, reason: '硬门禁未通过，未请求模型' }`）。
 
 ### 语义复审（`@mycf711/dsh-gate/semantic`）
 
@@ -210,11 +250,12 @@ printf '正文' | node bin/gate.mjs --trigger pr.reply --body-file - --current 1
 | `--current` | 当前 issue/PR 编号；缺省时 `foreign-ref` 跳过 |
 | `--repo` | 仓库目录（默认当前目录） |
 | `--config` | 直接用一份配置，不读四层（调试 / CI） |
-| `--semantic` | 在 `merge` / `release` 上强制跑语义复审 |
+| `--semantic` | 在 `merge` / `release` 上强制跑语义复审（硬门禁已失败时不会请求模型） |
 | `--json` | 输出 JSON |
 | `--help` | 帮助 |
 
-退出码：`0` 通过（warn 不阻断）· `1` 有 `error` 命中 · `2` 用法 / 配置 / IO 错误。
+退出码：`0` 通过（warn 不阻断）· `1` 有 `error` 命中 · `2` 用法 / 配置 / IO 错误
+（未知参数、缺 `--body-file`、未知 trigger、`--current` 非数字、配置文件不存在或非法 JSON）。
 
 ## 安全边界
 
@@ -224,6 +265,8 @@ printf '正文' | node bin/gate.mjs --trigger pr.reply --body-file - --current 1
 - **先脱敏再出网**：`redact()` 覆盖 GitHub / GitLab / Slack / Stripe / npm / AWS / Google /
   JWT / PEM / URL 密码 / 查询参数 / Gitee 令牌等形状。
 - **写盘可回滚**：`writeGateConfig` 先写 `.bak`，临时文件 `0o600`，`rename` 原子替换。
+- **写盘不丢 `extends`**：整层重写只写 `version/name/rules/semantic`；`false` / `"none"` 原样保留，
+  共享形式（`true` / `"default"` / 路径 / 对象）显式报错并点名配置路径 —— 宁可保存失败，也不悄悄冲掉共享规则。
 - **坏配置 fail-open（仅语义复审）**：语义层不可用时放行并给 warning；确定性规则仍逐条执行。
 
 ## 测试
@@ -233,8 +276,10 @@ cd packages/dsh-gate
 node --test
 ```
 
-覆盖：四层合并与同 id 覆盖、`extends`（替换 / 相对路径 / 循环）、脱敏 / 路径 / 无关引用、
-规则类型与触发器过滤、语义复审只 merge/release 与 fail-open、CLI 的 PASS/FAIL 退出码、
+覆盖：四层合并与同 id 覆盖、`extends`（替换 / 相对路径 / 循环 / 写盘 fail closed：共享基拒绝、
+`false` / `"none"` 原样保留、读回仍是替换、坏 JSON 先进 `.bak`）、脱敏 / 路径 / 无关引用、
+规则类型与触发器过滤、规则启停（`enabled` 缺省 / 停用 / 后层复启 / 写盘往返 / 非法形状）、
+语义复审只 merge/release 与 fail-open、硬门禁失败不请求模型、CLI 的 PASS/FAIL 退出码、
 默认 JSON 可解析且 10 条规则都真的能命中。
 
 ## 未验项
@@ -244,6 +289,8 @@ node --test
 - 面板 UI（G3）与主插件路由（G2）不在本包范围。
 - 超大配置文件（数千条规则）的性能未压测。
 - `extends` 跨盘符 / UNC 路径未单独验证。
+- 两个进程同时写同一层配置（读 extends → `.bak` → rename 之间的 TOCTOU）未压测：本包没有文件锁，
+  只靠 `.bak` + 原子 `rename` 兜底。
 
 ## License
 

package/bin/gate.mjs

@@ -146,8 +146,13 @@ async function main(argv) {
   let semantic = { skipped: true }
   const semanticEnabled = Boolean(config.semantic && config.semantic.enabled === true)
   if (SEMANTIC_TRIGGERS.includes(options.trigger) && (options.semantic || semanticEnabled)) {
-    semantic = await semanticReview(text, config, { trigger: options.trigger, current: options.current })
-    hits.push(...(semantic.hits || []))
+    if (!deterministic.ok) {
+      // 先确定性、后语义：硬门禁已经不过，就不再请求模型（也不把正文发出去）。
+      semantic = { skipped: true, reason: '硬门禁未通过，未请求模型' }
+    } else {
+      semantic = await semanticReview(text, config, { trigger: options.trigger, current: options.current })
+      hits.push(...(semantic.hits || []))
+    }
   }
   const ok = hits.every((hit) => hit.severity !== 'error')
   const result = { ok, trigger: options.trigger, current: options.current === undefined ? null : options.current, hits, semantic }

package/lib/index.js

@@ -10,8 +10,9 @@
  *   3. 项目          <repo>/.superagent/gates.json
  *   4. 本地覆盖      <repo>/.superagent/gates.local.json
  *
- * 规则按 id 合并：同 id 覆盖，不同 id 追加。项目 / 本地只能**关闭**语义复审，
- * 不能替用户开复审或换模型。
+ * 规则按 id 合并：同 id 覆盖，不同 id 追加。规则可选 `enabled`（缺省 `true`）：
+ * `enabled:false` 表示本层明确停用该规则，后层写**同 id 完整规则** + `enabled:true` 即恢复。
+ * 项目 / 本地只能**关闭**语义复审，不能替用户开复审或换模型。
  *
  * 除 loadGateConfig / readGateScope / writeGateConfig 这类显式 IO 函数外，其余都是纯函数，方便主插件和测试注入。
  */
@@ -45,7 +46,7 @@ export {
 
 export const PACKAGE_NAME = '@mycf711/dsh-gate'
 /** 与 package.json 的 version 同步（测试守着）。 */
-export const PACKAGE_VERSION = '0.1.0'
+export const PACKAGE_VERSION = '0.1.2'
 
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
 
@@ -96,6 +97,76 @@ function configPathFor(scope, { repo = process.cwd(), home = homedir(), env = pr
   throw new Error('scope 只能是 default / user / project / local，收到：' + String(scope))
 }
 
+// ── extends 的写盘安全 ───────────────────────────────────────────────────────
+// 只有 `false` / `'none'` 能原样写回：它们不引用任何外部内容，写回后语义不变（本层替换）。
+// `true` / `'default'` / 路径字符串 / 内联对象都表示「本层以别处为基」，而写盘是整层重写
+// （只写 version/name/extends/rules/semantic，其中 extends 只保留 false/'none'），
+// 写下去就把基规则连同 `extends` 一起冲掉 —— 必须报错。
+const EXTENDS_ABSENT = 'absent'
+const EXTENDS_KEEP = 'keep'
+const EXTENDS_SHARED = 'shared'
+const EXTENDS_INVALID = 'invalid'
+
+function hasOwn(object, key) {
+  return Boolean(object) && typeof object === 'object'
+    && Object.prototype.hasOwnProperty.call(object, key)
+}
+
+/**
+ * 判断一个 `extends` 值能不能在整层重写里安全保留。
+ * 读侧分类见 `readLayerConfig`：false/'none' = 替换，true/'default'/路径/对象 = 共享基。
+ */
+function classifyExtends(value) {
+  if (value === undefined) return EXTENDS_ABSENT
+  if (value === false || value === 'none') return EXTENDS_KEEP
+  if (typeof value === 'string') return EXTENDS_SHARED // 含 'default'
+  if (value === true) return EXTENDS_SHARED
+  if (value && typeof value === 'object' && !Array.isArray(value)) return EXTENDS_SHARED
+  return EXTENDS_INVALID
+}
+
+function describeExtends(value) {
+  let text
+  try {
+    text = JSON.stringify(value)
+  } catch {
+    text = ''
+  }
+  if (text === undefined || text === '') text = String(value)
+  return text.length > 80 ? text.slice(0, 79) + '…' : text
+}
+
+/** 写盘侧的 extends 拒绝错误：必须点名配置路径 + 解决方式（面板和 CLI 都直接展示它）。 */
+function extendsWriteError(source, path, value) {
+  const detail = source === 'existing'
+    ? '该文件现有的 extends（' + describeExtends(value) + '）会在整层重写时丢失，它共享的基规则也跟着失效。'
+    : '本条配置里的 extends（' + describeExtends(value) + '）无法在整层重写时保留。'
+  const fix = source === 'existing'
+    ? '解决方式：直接手工编辑该文件；或先把基规则合并进本层规则、删掉 extends 后再从面板保存。'
+    : '解决方式：先手工编辑该文件把基规则合并进本层规则，或把 extends 改成 false / "none" 后再保存。'
+  const error = new Error('无法安全写入 extends：' + path + '。' + detail + fix)
+  error.code = 'extends_not_preservable'
+  error.path = path
+  return error
+}
+
+/**
+ * 读磁盘上现有文件的 `extends`。坏 JSON / 非对象：返回 absent ——
+ * 那种文件每次读取都会报错，写盘时原文会先进 `.bak`，不会被静默抹掉。
+ */
+function existingExtends(path) {
+  const absent = { kind: EXTENDS_ABSENT, value: undefined }
+  if (!existsSync(path)) return absent
+  let raw
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return absent
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw) || !hasOwn(raw, 'extends')) return absent
+  return { kind: classifyExtends(raw.extends), value: raw.extends }
+}
+
 function normalizeRule(rule) {
   if (!rule || typeof rule !== 'object' || Array.isArray(rule)) return null
   const id = String(rule.id || '')
@@ -127,7 +198,7 @@ function normalizeRule(rule) {
   // 直接丢弃（validateConfig 会给出具体原因），而不是静默阻断所有回复。
   if (rule.type === 'contains' && (typeof rule.value !== 'string' || rule.value.length === 0)) return null
   if (rule.type === 'maxLength' && !(Number.isFinite(Number(rule.value)) && Number(rule.value) > 0)) return null
-  return {
+  const normalized = {
     id,
     label: String(rule.label || id),
     description: String(rule.description || ''),
@@ -139,6 +210,10 @@ function normalizeRule(rule) {
     value: rule.value,
     message: String(rule.message || rule.label || '未通过门禁'),
   }
+  // 规则级启停：只保留**显式写了的布尔值**，缺省即启用（旧配置写回不凭空加字段）。
+  // 非布尔（例如字符串 "false"）一律忽略：宁可规则继续生效，也不静默把保护关掉。
+  if (typeof rule.enabled === 'boolean') normalized.enabled = rule.enabled
+  return normalized
 }
 
 /** 整理成稳定形状；非法规则被丢弃（`validateConfig` 会给出具体原因）。 */
@@ -330,6 +405,8 @@ export function lintText(text, config, { trigger = 'issue.reply', current } = {}
   const body = String(text ?? '')
   const hits = []
   for (const rule of normalizeConfig(config).rules) {
+    // 本层明确停用（enabled:false）的规则不参与判定：连 warn 都不出，ok 口径不变。
+    if (rule.enabled === false) continue
     if (!rule.triggers.includes(trigger)) continue
     if (!ruleMatches(rule, body, current)) continue
     hits.push({ id: rule.id, label: rule.label, severity: rule.severity, message: rule.message })
@@ -340,11 +417,20 @@ export function lintText(text, config, { trigger = 'issue.reply', current } = {}
 /**
  * 严格校验一份配置（写盘 / 面板保存前用）。
  * 与 `normalizeConfig` 不同：这里不静默丢弃，返回第一条具体错误。
+ *
+ * `extends` 在这里只做**形状**校验，并且会原样带在返回的 `config` 上：
+ * 面板保存走的是 `validateConfig` → `writeGateConfig`，如果在这一步把 `extends` 抹掉，
+ * 写盘端就再也没机会知道调用方传过它（Q1-F3 的静默丢失）。能不能安全写下去由
+ * `writeGateConfig` 按目标路径判定（它才拿得到配置路径，报错时能点名）。
  */
 export function validateConfig(input) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) {
     return { ok: false, error: '配置必须是对象' }
   }
+  const hasExtends = Object.prototype.hasOwnProperty.call(input, 'extends') && input.extends !== undefined
+  if (hasExtends && classifyExtends(input.extends) === EXTENDS_INVALID) {
+    return { ok: false, error: 'extends 只能是 true、false、字符串或对象' }
+  }
   if (!Array.isArray(input.rules)) return { ok: false, error: 'rules 必须是数组' }
   if (input.name !== undefined && typeof input.name !== 'string') return { ok: false, error: 'name 必须是字符串' }
   const seen = new Set()
@@ -356,7 +442,19 @@ export function validateConfig(input) {
     if (!RULE_ID_RE.test(id)) return { ok: false, error: '规则 id 非法：' + (id || '?') }
     if (seen.has(id)) return { ok: false, error: '规则 id 重复：' + id }
     seen.add(id)
-    if (!RULE_TYPE_SET.has(raw.type)) return { ok: false, error: '规则类型非法：' + id }
+    if (raw.enabled !== undefined && typeof raw.enabled !== 'boolean') {
+      return { ok: false, error: 'enabled 必须是布尔值：' + id }
+    }
+    if (!RULE_TYPE_SET.has(raw.type)) {
+      // 只写 { id, enabled } 的「复启」不是合法规则：不完整规则会被合并丢掉，
+      // 面板必须看到具体原因，而不是以为已经保存、实际还停用着。
+      return {
+        ok: false,
+        error: raw.type === undefined
+          ? '规则缺少 type：' + id + '（只写 id + enabled 不能停用或复启，请写完整规则）'
+          : '规则类型非法：' + id,
+      }
+    }
     if (raw.severity !== undefined && raw.severity !== 'error' && raw.severity !== 'warn') {
       return { ok: false, error: 'severity 只能是 error / warn：' + id }
     }
@@ -412,7 +510,9 @@ export function validateConfig(input) {
       return { ok: false, error: 'semantic.maxInputChars 必须是正数' }
     }
   }
-  return { ok: true, config: normalizeConfig(input) }
+  const normalized = normalizeConfig(input)
+  if (hasExtends) normalized.extends = input.extends
+  return { ok: true, config: normalized }
 }
 
 /** 读某一层的原始配置（给面板展示「这一层现在写的是什么」）。 */
@@ -429,19 +529,52 @@ export function readGateScope(scope, { repo = process.cwd(), home = homedir(), e
 /**
  * 写某一层配置：先备份 `.bak`，再原子替换（临时文件 + rename）。
  * 只允许 user / project / local —— 默认规则随包发布，不能从面板改。
+ *
+ * 写盘是**整层重写**（只写 version/name/extends/rules/semantic，其中 extends 只保留 false/'none'），
+ * 所以 `extends` 走 fail closed：
+ * - 入参 `extends: false | 'none'`：允许，原样写回（写回后仍是「替换」语义）；
+ * - 入参 `extends: true | 'default' | '<路径>' | {…}`：抛错（含配置路径与解决方式）；
+ * - 文件里已有这类共享 `extends`：不管入参写什么（包括 `false`）都抛错，绝不静默冲掉基规则；
+ * - 文件里已有 `false | 'none'` 而入参没写：原样保留，避免「替换」悄悄退化成「合并」。
  */
 export function writeGateConfig(scope, config, { repo = process.cwd(), home = homedir(), env = process.env } = {}) {
   if (scope !== 'user' && scope !== 'project' && scope !== 'local') {
     throw new Error('scope 只能是 user / project / local')
   }
+  const path = configPathFor(scope, { repo, home, env })
+  const input = config && typeof config === 'object' && !Array.isArray(config) ? config : {}
+  // 1) 调用方传入的 extends：能原样保留的写回，其余显式报错。
+  const incoming = hasOwn(input, 'extends') ? classifyExtends(input.extends) : EXTENDS_ABSENT
+  if (incoming === EXTENDS_SHARED || incoming === EXTENDS_INVALID) {
+    throw extendsWriteError('incoming', path, input.extends)
+  }
+  // 2) 磁盘上已有的 extends：整层重写会把它冲掉，同样不能无提示改写。
+  const existing = existingExtends(path)
+  if (existing.kind === EXTENDS_SHARED || existing.kind === EXTENDS_INVALID) {
+    throw extendsWriteError('existing', path, existing.value)
+  }
+  // 3) 可安全保留的值：入参优先；入参没写就用文件里已有的（否则等于悄悄改了语义）。
+  const keepExtends = incoming === EXTENDS_KEEP
+    ? { value: input.extends }
+    : existing.kind === EXTENDS_KEEP
+      ? { value: existing.value }
+      : null
   const checked = validateConfig(config)
   if (!checked.ok) throw new Error(checked.error)
-  const path = configPathFor(scope, { repo, home, env })
+  const normalized = checked.config
+  // 明确的字段顺序：extends 跟在 name 后面，读文件的人一眼能看到这一层挂在哪。
+  const output = {
+    version: normalized.version,
+    name: normalized.name,
+    ...(keepExtends ? { extends: keepExtends.value } : {}),
+    rules: normalized.rules,
+    semantic: normalized.semantic,
+  }
   mkdirSync(dirname(path), { recursive: true })
   const tmp = path + '.tmp-' + process.pid + '-' + Date.now()
   try {
     if (existsSync(path)) copyFileSync(path, path + '.bak')
-    writeFileSync(tmp, JSON.stringify(checked.config, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 })
+    writeFileSync(tmp, JSON.stringify(output, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 })
     renameSync(tmp, path)
   } catch (error) {
     try {
@@ -451,7 +584,7 @@ export function writeGateConfig(scope, config, { repo = process.cwd(), home = ho
     }
     throw error
   }
-  return { path, config: checked.config }
+  return { path, config: output }
 }
 
 /**
@@ -463,7 +596,8 @@ export function writeGateConfig(scope, config, { repo = process.cwd(), home = ho
  * if (!result.ok) return
  * ```
  *
- * 语义复审默认跟随配置（`semantic.enabled`），且只对 merge / release 生效。
+ * 语义复审默认跟随配置（`semantic.enabled`），且只对 merge / release 生效；
+ * 确定性门禁先跑，硬门禁已经不过时不再请求模型。
  */
 export function createGate({
   id = 'dsh-gate',
@@ -490,8 +624,13 @@ export function createGate({
       let semanticResult = { skipped: true }
       const semanticEnabled = Boolean(loaded.config.semantic && loaded.config.semantic.enabled === true)
       if (semantic !== false && semanticEnabled && SEMANTIC_TRIGGER_SET.has(trigger)) {
-        semanticResult = await semanticReview(text, loaded.config, { trigger, current, ...semanticOptions })
-        hits.push(...(semanticResult.hits || []))
+        if (!deterministic.ok) {
+          // 先确定性、后语义：硬门禁已经不过，就不再请求模型（省一次调用，也不把正文发出去）。
+          semanticResult = { skipped: true, reason: '硬门禁未通过，未请求模型' }
+        } else {
+          semanticResult = await semanticReview(text, loaded.config, { trigger, current, ...semanticOptions })
+          hits.push(...(semanticResult.hits || []))
+        }
       }
       return {
         ok: hits.every((hit) => hit.severity !== 'error'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycf711/dsh-gate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "内容层门禁：四层配置、确定性规则与可选语义复审，可作为 DSH 插件依赖独立安装。",
   "type": "module",
   "main": "lib/index.js",