dsh-config-manager 0.1.39 → 0.1.41

package/src/market/types.ts

@@ -194,6 +194,8 @@ export interface MarketStatusResponse {
   /** 是否已添加过至少一个市场 */
   configured: boolean;
   markets: MarketSummary[];
+  /** 本次 dsh 启动后市场是否已刷新过（首次打开市场页自动更新一次的依据；进程内存，dsh 重启后重置） */
+  bootAutoRefreshed?: boolean;
 }
 
 /** POST /market/add | /market/remove 响应：{ ok, markets } */

package/src/security/secret-scanner.ts

@@ -7,10 +7,19 @@
  * 判定策略（两级，避免误伤/漏报）：
  *  - 字段名：规范化（小写、去 `_-. ` 分隔符）后做「精确命中 / 敏感后缀 / 敏感前缀」三级匹配；
  *    只剥离**字符串叶值**（对象/数组整体递归，不整块剥离——保证 `credentials: [...]` 状态数组存活）。
- *  - 引用豁免：`apiKeyEnv` 等「只存引用名」字段、以及形如 `DEEPSEEK_API_KEY` 的全大写环境变量名
- *    （`isEnvVarName`）一律保留——值是名字不是秘密。
+ *  - 引用豁免：`apiKeyEnv` 等「只存引用名」字段、形如 `DEEPSEEK_API_KEY` 的全大写环境变量名
+ *    （`isEnvVarName`）以及 `${VAR}` / `{{VAR}}` / `%VAR%` / `$VAR` 模板引用（`isTemplateReference`）
+ *    一律保留——值是名字不是秘密。
  *  - 值形状启发式（规范 §6「不能只根据固定字段判断」）：字段名未命中但值长得像 secret
- *    （sk- / JWT / AKIA / GitHub PAT / PEM 私钥 / Bearer）也剥离；高熵 base64 默认关（误伤率高）。
+ *    （sk- / JWT / AKIA / GitHub PAT / PEM 私钥 / Bearer）也剥离；**示例/占位形态**（含
+ *    your/example/xxx/test/<...> 等占位词的 `sk-your-*`、`Bearer example-*`、JWT 教学串）放行。
+ *  - 两种判定档位（2026-08-21 优化）：
+ *    * 保守档（默认，导出/同步脱敏用）：字段名敏感**即**剥离（值形状优先、引用/env 名豁免）；
+ *    * 宽松档（`literalValueOnly`，市场发布扫描用）：字段名敏感**且**值像真实字面量凭据
+ *      （非占位符 / 非类型词 / 非代码表达式 / 非模板引用 / 非短标识符）才命中——消除
+ *      `"token": "your-token"`、`"token": "${OPENAI_API_KEY}"`、`"Authorization": "Bearer <token>"`
+ *      等「值不是秘密」的误报。
+ *  - 高熵 base64 默认关（误伤率高）。
  *
  * 实现不变量：返回 sanitized 为**全新对象**（不改原数据）；迭代式显式栈（防爆栈）+ 深度上限；
  * 命中记录只含路径与字段名，**值永不外泄**。
@@ -65,6 +74,42 @@ export const SECRET_VALUE_PATTERNS: readonly ValuePattern[] = [
   { name: 'bearer-token', re: /Bearer [A-Za-z0-9._~+/=-]{8,}/ },
 ];
 
+/**
+ * 值形状命中片段中的「示例/占位」词：匹配到的片段含其中任一 → 视为示例形态放行。
+ * 覆盖 `sk-your-*`、`sk-example-*`、`sk-test-*`、`Bearer example-*`、`AKIA...EXAMPLE`（AWS 官方示例）、
+ * JWT 教学串（第三段 signature）等；真实随机密钥串几乎不可能包含这些完整单词，安全不回退。
+ */
+const SECRET_SHAPE_PLACEHOLDER_WORDS = [
+  'your', 'their', 'example', 'sample', 'dummy', 'placeholder',
+  'test', 'demo', 'signature', 'secret', 'value', 'xxxx',
+] as const;
+
+/** 值形状命中是否「示例/占位」形态（含占位词或尖括号包裹）→ 放行 */
+function isExampleSecretShape(matched: string): boolean {
+  if (/<[^>]+>/.test(matched)) return true;
+  const lower = matched.toLowerCase();
+  return SECRET_SHAPE_PLACEHOLDER_WORDS.some((w) => lower.includes(w));
+}
+
+/** 值形状命中详情（模式名 + 实际匹配片段；示例降噪用） */
+interface ValuePatternHit { name: string; matched: string }
+
+function matchSecretValuePatternHit(value: string): ValuePatternHit | null {
+  for (const p of SECRET_VALUE_PATTERNS) {
+    const m = p.re.exec(value);
+    if (m !== null) return { name: p.name, matched: m[0] };
+  }
+  return null;
+}
+
+/** 值是否命中强模式 secret 形状（示例/占位形态 → null；返回命中模式名；未命中返回 null） */
+export function matchSecretValuePattern(value: string): string | null {
+  const hit = matchSecretValuePatternHit(value);
+  if (hit === null) return null;
+  if (isExampleSecretShape(hit.matched)) return null;
+  return hit.name;
+}
+
 export interface SecretScannerOptions {
   /** 附加敏感字段名（任意原始形态，内部会规范化） */
   extraFieldNames?: string[];
@@ -74,6 +119,13 @@ export interface SecretScannerOptions {
   valuePatterns?: boolean;
   /** 高熵长串启发式（默认 false：误伤风险高，需显式开启） */
   highEntropy?: boolean;
+  /**
+   * 宽松档（默认 false = 保守档）。
+   * 保守档（导出/同步脱敏）：字段名敏感即命中，值形状优先、引用/env 名豁免；
+   * 宽松档（市场发布扫描）：字段名敏感**且**值像真实字面量凭据才命中——占位符 /
+   * 模板引用 / 代码表达式 / 类型词 / 短标识符放行，消除「值不是秘密」的误报。
+   */
+  literalValueOnly?: boolean;
   /** 最大递归深度（默认 64，与 JSON 深度上限一致） */
   maxDepth?: number;
 }
@@ -88,6 +140,23 @@ export function isEnvVarName(value: string): boolean {
   return /^[A-Z][A-Z0-9_]{2,}$/.test(value);
 }
 
+/** 是否为模板/环境变量引用形态（${VAR} / {{VAR}} / %VAR% / $VAR）→ 值是名字不是秘密。
+ *  注意：文本扫描的 `field: value` 正则用 `[^\s,;}]` 取值，`${...}` / `{{...}}` 的右花括号
+ *  会被截断，因此除完整闭合形态外，也接受「以 ${ / {{ / % 开头、内容全为变量名字符」的截断形态。 */
+export function isTemplateReference(value: string): boolean {
+  const v = value.trim();
+  // 完整闭合形态
+  if (/^\$\{[A-Za-z0-9_.]+\}$/.test(v)) return true;
+  if (/^\{\{[A-Za-z0-9_.]+\}\}$/.test(v)) return true;
+  if (/^%[A-Za-z0-9_.]+%$/.test(v)) return true;
+  if (/^\$[A-Z][A-Z0-9_]{2,}$/.test(v)) return true;
+  // 截断形态（右花括号被取值正则排除）：真实凭据不会以 ${ / {{ / % 开头，放行安全
+  if (/^\$\{[A-Za-z0-9_.]*$/.test(v)) return true;
+  if (/^\{\{[A-Za-z0-9_.]*$/.test(v)) return true;
+  if (/^%[A-Za-z0-9_.]*$/.test(v)) return true;
+  return false;
+}
+
 /** 字段名是否命中敏感名单（规范化后精确 / 敏感后缀 / 敏感前缀） */
 export function isSensitiveFieldName(
   field: string,
@@ -109,14 +178,6 @@ export function isReferenceField(
   return [...DEFAULT_REFERENCE_FIELDS, ...extra].includes(norm);
 }
 
-/** 值是否命中强模式 secret 形状（返回命中模式名；未命中返回 null） */
-export function matchSecretValuePattern(value: string): string | null {
-  for (const p of SECRET_VALUE_PATTERNS) {
-    if (p.re.test(value)) return p.name;
-  }
-  return null;
-}
-
 /** 高熵启发式：长 base64/hex 串且 Shannon 熵高（默认关） */
 function isHighEntropySecret(value: string): boolean {
   if (!/^[A-Za-z0-9+/=_-]{32,}$/.test(value)) return false;
@@ -131,10 +192,65 @@ function isHighEntropySecret(value: string): boolean {
   return entropy > 4.2;
 }
 
+/* ---------------- 值形态判定（结构化扫描与文本扫描共用） ---------------- */
+
+/** 占位符 / 示例形态：xxx、your-token、<...>、example、sample、dummy、placeholder、... */
+const PLACEHOLDER_RE = /^(x{3,}|your[-_ ]?[\w]+|their[-_ ]?[\w]+|<[^>]+>|example|examples?|sample|dummy|placeholder|som[e]thing|^\u2026)/i;
+
+/** 类型/关键字形态（代码声明，如 `authToken: string`、`token: null`） */
+const TYPE_KEYWORD_RE = /^(string|number|boolean|object|array|any|unknown|null|undefined|void|true|false|required|optional)$/i;
+
+/** 代码表达式/引用形态：值里出现调用/成员访问/引号/运算符/空白等 → 是代码而非字面量密钥 */
+function isCodeExpressionValue(value: string): boolean {
+  // 方法调用 / 成员访问：data.token、process.env.X、wx.getStorageSync(...)、a.b(...)
+  if (/[.([\]'"`]/.test(value)) return true;
+  // 赋值/比较/模板：a=b、a&&b 等
+  if (/[=+*/%<>!&|?]+/.test(value)) return true;
+  // 含空白 → 短语/语句而非单个字面量
+  if (/\s/.test(value)) return true;
+  return false;
+}
+
+/** 混合字符长串是否「疑似真实凭据」：含数字、或含字母数字连字符下划线以外的符号、或大小写混合
+ *  （纯小写字母+连字符的示例值如 `abc-def-ghi-jkl` → 放行；`s3cretP@ssw0rd` / `abc123-def456` → 拦截） */
+function looksLikeCredential(value: string): boolean {
+  if (value.length < 8) return false;
+  if (/[0-9]/.test(value)) return true;
+  if (/[^A-Za-z0-9_-]/.test(value)) return true;
+  if (/[a-z]/.test(value) && /[A-Z]/.test(value)) return true;
+  return false;
+}
+
+/** 值是否为「字面量密钥」：既不是代码表达式，也不是占位符/类型词/短标识符/环境引用。
+ *  只有字段名敏感 **且** 值像真实字面量凭据时才报告 —— 消除技能文档中
+ *  `authToken: string`、`password: process.env.X`、`token: data.token` 等代码示例误报。 */
+function isLiteralSecretValue(value: string): boolean {
+  if (value === '') return false;
+  // 值形状强信号（sk- / ghp_ / AKIA / JWT / PEM / Bearer，示例/占位形态已降噪）—— 任何字段都视为真凭据
+  if (matchSecretValuePattern(value) !== null) return true;
+  if (PLACEHOLDER_RE.test(value)) return false;
+  if (TYPE_KEYWORD_RE.test(value)) return false;
+  if (isCodeExpressionValue(value)) return false;
+  if (isEnvVarName(value)) return false;
+  if (isTemplateReference(value)) return false;
+  // 纯字母数字短标识符（变量名/普通词，如 authToken、data、key）→ 非密钥
+  if (/^[A-Za-z0-9_]+$/.test(value) && value.length < 20) return false;
+  // 其余：混合字符串，仅当像真实凭据（含数字/符号/大小写混合）才疑似
+  return looksLikeCredential(value);
+}
+
 /** 判定单个「字段名 + 字符串值」：strip | keep（含引用豁免与值形状）
- * 顺序：值形状优先（AKIA 等全大写 secret 形状不能被 env 名豁免误放）→ 引用字段 → env 名 → 字段名。 */
-function judgeFieldValue(field: string, value: string, opts: Required<Pick<SecretScannerOptions, 'extraFieldNames' | 'extraReferenceFields' | 'valuePatterns' | 'highEntropy'>>): boolean {
+ * 顺序：值形状优先（AKIA 等全大写 secret 形状不能被 env 名豁免误放）→ 引用字段 → env 名 → 字段名。
+ * 宽松档（literalValueOnly，市场发布）：字段名命中还要求值像真实字面量凭据（非占位/引用/代码）。 */
+function judgeFieldValue(field: string, value: string, opts: Required<Pick<SecretScannerOptions, 'extraFieldNames' | 'extraReferenceFields' | 'valuePatterns' | 'highEntropy' | 'literalValueOnly'>>): boolean {
   if (value === '') return false;
+  if (opts.literalValueOnly) {
+    // 宽松档（市场发布扫描）：值形状强信号字段无关必拦；字段名敏感 + 值像真实字面量凭据才拦
+    if (opts.valuePatterns && matchSecretValuePattern(value) !== null) return true;
+    if (isSensitiveFieldName(field, opts.extraFieldNames) && isLiteralSecretValue(value)) return true;
+    return false;
+  }
+  // 保守档（导出/同步脱敏）：值形状优先 → 引用字段/env 名豁免 → 字段名敏感即剥
   if (opts.valuePatterns && matchSecretValuePattern(value) !== null) return true;
   if (isReferenceField(field, opts.extraReferenceFields)) return false;
   if (isEnvVarName(value)) return false; // 值是 env 变量名 → 引用
@@ -146,11 +262,12 @@ function judgeFieldValue(field: string, value: string, opts: Required<Pick<Secre
 /** 递归扫描 + 剥离（纯函数，不改原数据；深度保护；返回清洗后数据与命中清单） */
 export function scanAndRedact(data: unknown, opts: SecretScannerOptions = {}): { sanitized: unknown; hits: SensitiveHit[] } {
   const maxDepth = opts.maxDepth ?? 64;
-  const cfg: Required<Pick<SecretScannerOptions, 'extraFieldNames' | 'extraReferenceFields' | 'valuePatterns' | 'highEntropy'>> = {
+  const cfg: Required<Pick<SecretScannerOptions, 'extraFieldNames' | 'extraReferenceFields' | 'valuePatterns' | 'highEntropy' | 'literalValueOnly'>> = {
     extraFieldNames: opts.extraFieldNames ?? [],
     extraReferenceFields: opts.extraReferenceFields ?? [],
     valuePatterns: opts.valuePatterns ?? true,
     highEntropy: opts.highEntropy ?? false,
+    literalValueOnly: opts.literalValueOnly ?? false,
   };
   const hits: SensitiveHit[] = [];
 
@@ -225,7 +342,11 @@ const FIELD_VALUE_RE = [
   { re: /([A-Za-z0-9_.\-]+)\s*:\s*([^\s,;}]+)/g, json: false },
 ] as const;
 
-/** 文本级扫描：逐行找「敏感字段名 = 值」与「值形状」命中（只报告，不修改文本） */
+/** 文本级扫描：逐行找「敏感字段名 + 疑似真实字面量凭据」与「值形状」命中（只报告，不修改文本）。
+ *  2026-08-20 优化：字段名命中不再是充分条件 —— 值必须是「非代码引用 / 非占位符 / 非类型词 /
+ *  非短标识符」的字面量，消除技能/代码文档中 `token:`/`password:` 等示例命名的误报；
+ *  2026-08-21 优化：值形状（sk-/ghp_/AKIA/JWT/PEM/Bearer）对示例/占位形态（含 your/example/
+ *  xxx/test/<...> 等占位词）放行；混合字符串需像真实凭据（含数字/符号/大小写混合）才报告。 */
 export function scanText(text: string, opts: SecretScannerOptions = {}): SensitiveHit[] {
   const hits: SensitiveHit[] = [];
   const extra = opts.extraFieldNames ?? [];
@@ -243,16 +364,12 @@ export function scanText(text: string, opts: SecretScannerOptions = {}): Sensiti
         const field = m[1]!;
         const value = m[2]!;
         if (!isSensitiveFieldName(field, extra)) continue;
-        if (json) {
-          // JSON 形态下引号内值才报告（引用名豁免由调用方结合场景决定，这里保守报告）
-          hits.push({ path: linePath, field });
-          continue;
-        }
-        if (isEnvVarName(value)) continue; // 引用名不报告
+        // 值必须是「疑似字面量凭据」才报告（消除代码示例/占位符误报）
+        if (!isLiteralSecretValue(value)) continue;
         hits.push({ path: linePath, field });
       }
     }
-    // 值形状（字段名无关）
+    // 值形状（字段名无关；整行 trim 后匹配 sk-/ghp_/JWT/PEM/Bearer 等强信号，示例形态已降噪）
     if (valuePatterns) {
       const trimmed = line.trim();
       const name = matchSecretValuePattern(trimmed);

package/src/security/security.test.ts

@@ -619,7 +619,7 @@ test('scanner: 引用豁免（apiKeyEnv 等只存名字的字段、env 名形态
     apiKeyEnv: 'DEEPSEEK_API_KEY',
     api_key_env: 'GITHUB_TOKEN',
     apiKey: 'DEEPSEEK_API_KEY', // 值是 env 变量名形态 → 视为引用
-    realKey: 'sk-real-secret-value',
+    realKey: 'sk-proj-9f8e7d6c5b4a3210abcdef', // 真实形态密钥 → 仍拦截
     tokenRef: 'MY_TOKEN_REF',
   };
   const { sanitized } = scanAndRedact(input);
@@ -635,7 +635,7 @@ test('scanner: 值形状启发式（字段名无关的 secret 形状也剥离）
   const input = {
     note: 'use sk-abc1234567890abc for api',
     jwt: 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U',
-    aws: 'AKIAIOSFODNN7EXAMPLE',
+    aws: 'AKIAIOSFODNN7A1B2C3D4',
     github: 'ghp_abcdefghijklmnopqrstuvwxyz',
     pem: '-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA...',
     fine: 'just a note',
@@ -653,6 +653,26 @@ test('scanner: 值形状启发式（字段名无关的 secret 形状也剥离）
   assert.equal(matchSecretValuePattern('plain text'), null);
 });
 
+test('scanner: 值形状示例/占位形态放行（sk-your-*、AKIA...EXAMPLE、JWT 教学串）', () => {
+  const input = {
+    yourKey: 'sk-your-api-key-here',            // 占位词 your
+    exampleKey: 'sk-example-key-12345',          // 占位词 example
+    testKey: 'sk-test-key-1234567890',           // 占位词 test
+    awsSample: 'AKIAIOSFODNN7EXAMPLE',           // AWS 官方文档示例 key
+    jwtSample: 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signature', // 教学串第三段 signature
+    note: 'use sk-your-demo-key for api',        // 文本叙述中的示例
+  };
+  const { sanitized, hits } = scanAndRedact(input);
+  const s = sanitized as Record<string, unknown>;
+  assert.equal(s['yourKey'], 'sk-your-api-key-here', 'sk-your-* 示例应放行');
+  assert.equal(s['exampleKey'], 'sk-example-key-12345', 'sk-example-* 示例应放行');
+  assert.equal(s['testKey'], 'sk-test-key-1234567890', 'sk-test-* 示例应放行');
+  assert.equal(s['awsSample'], 'AKIAIOSFODNN7EXAMPLE', 'AWS 官方示例应放行');
+  assert.equal(s['jwtSample'], 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signature', 'JWT 教学串应放行');
+  assert.equal(s['note'], 'use sk-your-demo-key for api', '叙述中的示例应放行');
+  assert.equal(hits.length, 0);
+});
+
 test('scanner: 深层嵌套上限（≤64 通过，超限抛错）与循环引用防护', () => {
   const deep = (n: number): unknown => {
     let v: unknown = 'leaf';
@@ -700,6 +720,95 @@ test('scanner: isSensitiveFieldName / createSecretScanner（core 契约）', ()
   assert.ok(textHits.some((h) => h.path.startsWith('line:')));
 });
 
+test('scanText: 技能/代码文档中的示例命名不再误报（2026-08-20 优化）', () => {
+  // 真实技能文件（api-tester.md / frontend-developer.md 等）里出现过的代码示例形态 —— 全部应放行
+  const skillDoc = [
+    'let authToken: string;',                       // 类型声明（值=string 类型词）
+    'password: process.env.TEST_USER_PASSWORD',      // 代码引用（含 . 与 (）—— 注意 field: value 正则截取 value 为 process.env.TEST_USER_PASSWORD
+    'authToken = data.token;',                       // 赋值 + 成员访问
+    'const token = loginResponse.json(\'token\');',  // 方法调用
+    'key={virtualItem.key}',                         // React key prop（key 不入敏感名单）
+    'queryKey: [\'products\'],',                     // 数组字面量
+    'token: your-token-here',                        // 占位符
+    'api_key: <your-key>',                           // 占位符
+    'max_tokens: 100',                               // 值=数字…… 但正则只匹配 \w+；"100" 是短标识符？100 长3 <20 → 放行 ✓
+  ].join('\n');
+  const hits = scanText(skillDoc);
+  assert.equal(hits.length, 0, `技能文档示例不应误报，实际: ${JSON.stringify(hits)}`);
+});
+
+test('scanText: 真实字面量密钥仍然拦截（优化不回退安全）', () => {
+  // 字段名敏感 + 真正的字面量长串 → 报
+  const real = [
+    'password: s3cretP@ssw0rdXyZ2024',              // 字段 password + 混合字面量长串
+    'client_secret: abcdef1234567890abcdef12345678', // 字段敏感 + 长混合串
+    '"apiKey": "sk-proj-abcdef1234567890"',          // JSON 形态 + sk- 值形状（强信号）
+    'token=ghp_abcdefghijklmnopqrstuvwxyzABCDEF',    // GitHub PAT 值形状
+  ].join('\n');
+  const hits = scanText(real);
+  assert.ok(hits.length >= 4, `真实密钥应全部拦截，实际: ${JSON.stringify(hits)} (${hits.length})`);
+});
+
+test('scanText: 占位/示例/模板引用/普通示例值放行（2026-08-21 优化）', () => {
+  const doc = [
+    'token: ${OPENAI_API_KEY}',                    // 模板引用
+    'api_key: {{MY_KEY}}',                          // 模板引用（双花括号）
+    'secret: $ENV_SECRET',                          // $VAR 引用
+    'password: your-token-here',                    // 占位符
+    'token: abc-def-ghi-jkl',                       // 纯小写字母+连字符示例值（无数字/符号/大小写混合）
+    'Bearer example-token-here',                    // 值形状示例形态
+    'sk-your-api-key-here',                         // 值形状示例形态
+    'use sk-demo-key-1234567890 in this doc',       // 叙述中的示例
+  ].join('\n');
+  const hits = scanText(doc);
+  assert.equal(hits.length, 0, `示例文档不应误报，实际: ${JSON.stringify(hits)}`);
+});
+
+test('scanText: 含数字/符号的混合串仍是真实凭据特征 → 拦截（不回退）', () => {
+  const real = [
+    'token: abc123-def456',                         // 含数字的混合串
+    'password: AbCdEfGh-1234',                      // 大小写混合 + 数字 + 连字符（非纯字母数字，不落短标识符豁免）
+    'apiKey: sk-proj-9f8e7d6c5b4a3210abcdef',       // 真实形态 sk-（无占位词）
+  ].join('\n');
+  const hits = scanText(real);
+  assert.ok(hits.length >= 3, `真实凭据特征应拦截，实际: ${JSON.stringify(hits)} (${hits.length})`);
+});
+
+test('scanAndRedact: 宽松档（literalValueOnly，市场发布）占位/模板/代码引用放行，真凭据仍拦', () => {
+  // 宽松档：字段名敏感但值不是秘密 → 全部放行（市场发布场景，消除误报）
+  const benign = {
+    token: 'your-token',
+    apiKey: '${OPENAI_API_KEY}',
+    secret: '{{MY_SECRET}}',
+    password: 'process.env.PASSWORD',
+    Authorization: 'Bearer <token>',
+    clientSecret: 'client-secret-value', // 混合字符但纯小写+连字符（无数字/符号/大小写混合）→ 非凭据
+    max_tokens: 100,
+    note: 'just a note',
+  };
+  const r = scanAndRedact(benign, { literalValueOnly: true });
+  assert.equal(r.hits.length, 0, `宽松档不应误报，实际: ${JSON.stringify(r.hits)}`);
+  assert.deepEqual(r.sanitized, benign);
+
+  // 宽松档：真实凭据仍然拦截（安全不回退）
+  const real = {
+    token: 'sk-proj-9f8e7d6c5b4a3210abcdef',
+    Authorization: 'Bearer xyz1234567890abcdef',
+    clientSecret: 's3cretP@ssw0rdXyZ2024',
+  };
+  const rr = scanAndRedact(real, { literalValueOnly: true });
+  assert.equal(rr.hits.length, 3, `宽松档真凭据仍应拦截，实际: ${JSON.stringify(rr.hits)}`);
+});
+
+test('scanAndRedact: 保守档（默认，导出/同步）字段名敏感即剥，不受宽松档影响', () => {
+  // 默认模式：字段名敏感 + 任意值 → 剥离（导出脱敏保持保守，行为不变）
+  const input = { token: 'your-token', apiKey: '${OPENAI_API_KEY}' };
+  const { sanitized } = scanAndRedact(input);
+  const s = sanitized as Record<string, unknown>;
+  assert.equal(s['token'], REDACTED_PLACEHOLDER, '保守档字段名敏感即剥（占位符值也剥）');
+  assert.equal(s['apiKey'], REDACTED_PLACEHOLDER, '保守档模板引用值也剥');
+});
+
 /* ================= redaction ================= */
 
 test('redaction: 结构化字段三形态 + 值形状 + URL query', () => {