autosnippet 3.2.21 → 3.3.2

package/dist/lib/{platform/ios/spm → core/discovery}/SpmDiscoverer.js

@@ -2,20 +2,27 @@
  * @module SpmDiscoverer
  * @description SPM 项目发现器，适配 ProjectDiscoverer 接口
  *
- * 直接使用 PackageSwiftParser 解析 Package.swift，提供模块列表和文件遍历。
- * SpmHelper 仅用于 Xcode 工作流的依赖检查/修复，不在此链路加载。
+ * 内置 Package.swift 正则解析，提供模块列表和文件遍历。
  *
  * 检测: 项目根或子目录存在 Package.swift
  */
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, dirname, extname, join } from 'node:path';
-import { ProjectDiscoverer } from '#core/discovery/ProjectDiscoverer.js';
 import { LanguageService } from '#shared/LanguageService.js';
-import { PackageSwiftParser } from './PackageSwiftParser.js';
+import { ProjectDiscoverer } from './ProjectDiscoverer.js';
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'Build',
+    '.build',
+    '.swiftpm',
+    'Pods',
+    'DerivedData',
+    'Carthage',
+    '.cursor',
+]);
 export class SpmDiscoverer extends ProjectDiscoverer {
-    #parser = null;
     #projectRoot = null;
-    /** >} */
     #parsedPackages = [];
     get id() {
         return 'spm';
@@ -24,12 +31,10 @@ export class SpmDiscoverer extends ProjectDiscoverer {
         return 'Swift Package Manager (SPM)';
     }
     async detect(projectRoot) {
-        // 检查项目根是否有 Package.swift
         const hasRoot = existsSync(join(projectRoot, 'Package.swift'));
         if (hasRoot) {
             return { match: true, confidence: 0.95, reason: 'Package.swift found at project root' };
         }
-        // 检查子目录是否有 Package.swift（多包项目）
         try {
             const entries = readdirSync(projectRoot, { withFileTypes: true });
             for (const entry of entries) {
@@ -51,12 +56,11 @@ export class SpmDiscoverer extends ProjectDiscoverer {
     }
     async load(projectRoot) {
         this.#projectRoot = projectRoot;
-        this.#parser = new PackageSwiftParser(projectRoot);
         this.#parsedPackages = [];
-        const allPaths = this.#parser.findAllPackageSwifts(projectRoot);
+        const allPaths = this.#findAllPackageSwifts(projectRoot);
         for (const pkgPath of allPaths) {
             try {
-                const parsed = this.#parser.parse(pkgPath);
+                const parsed = this.#parsePackageSwift(pkgPath);
                 if (parsed) {
                     this.#parsedPackages.push({ pkgPath, parsed });
                 }
@@ -67,9 +71,6 @@ export class SpmDiscoverer extends ProjectDiscoverer {
         }
     }
     async listTargets() {
-        if (!this.#parser) {
-            return [];
-        }
         const targets = [];
         for (const { pkgPath, parsed } of this.#parsedPackages) {
             const pkgDir = dirname(pkgPath);
@@ -91,17 +92,12 @@ export class SpmDiscoverer extends ProjectDiscoverer {
         return targets;
     }
     async getTargetFiles(target) {
-        if (!this.#parser) {
-            return [];
-        }
         const targetName = typeof target === 'string' ? target : target.name;
-        // 找到 target 所在的包目录和自定义 path
         let sourcesDir = null;
         for (const { pkgPath, parsed } of this.#parsedPackages) {
             const matchTarget = parsed.targets?.find((t) => t.name === targetName);
             if (matchTarget) {
                 const pkgDir = dirname(pkgPath);
-                // 优先使用 target 声明的自定义 path
                 const candidates = [];
                 if (matchTarget.path) {
                     candidates.push(join(pkgDir, matchTarget.path));
@@ -120,7 +116,6 @@ export class SpmDiscoverer extends ProjectDiscoverer {
             }
         }
         if (!sourcesDir) {
-            // Fallback: projectRoot/Sources/targetName
             const fallback = join(this.#projectRoot, 'Sources', targetName);
             if (existsSync(fallback)) {
                 sourcesDir = fallback;
@@ -137,7 +132,7 @@ export class SpmDiscoverer extends ProjectDiscoverer {
         }));
     }
     async getDependencyGraph() {
-        if (!this.#projectRoot || !this.#parser) {
+        if (!this.#projectRoot) {
             return { nodes: [], edges: [] };
         }
         if (this.#parsedPackages.length === 0) {
@@ -147,7 +142,6 @@ export class SpmDiscoverer extends ProjectDiscoverer {
         const edges = [];
         const pkgNameSet = new Set();
         const targetToPkg = new Map();
-        // ── 第一遍：收集所有 package + target 节点 ──
         const allParsed = [];
         const umbrellaNames = new Set();
         for (const { pkgPath, parsed } of this.#parsedPackages) {
@@ -156,14 +150,12 @@ export class SpmDiscoverer extends ProjectDiscoverer {
             }
             pkgNameSet.add(parsed.name);
             allParsed.push({ ...parsed, _dir: dirname(pkgPath) });
-            // 跳过 umbrella 包（无 targets + 无 products）——它只是组织子包的入口
             const hasTargets = parsed.targets && parsed.targets.length > 0;
             const hasProducts = parsed.products && parsed.products.length > 0;
             if (!hasTargets && !hasProducts) {
                 umbrellaNames.add(parsed.name);
                 continue;
             }
-            // package 节点
             nodes.push({
                 id: parsed.name,
                 label: parsed.name,
@@ -171,7 +163,6 @@ export class SpmDiscoverer extends ProjectDiscoverer {
                 fullPath: dirname(pkgPath),
                 targetCount: parsed.targets.length,
             });
-            // target 节点
             for (const t of parsed.targets) {
                 nodes.push({
                     id: t.name,
@@ -182,27 +173,22 @@ export class SpmDiscoverer extends ProjectDiscoverer {
                 });
                 targetToPkg.set(t.name, parsed.name);
             }
-            // product name → package（product 名可能和 target 名不同）
             for (const prod of parsed.products || []) {
                 if (!targetToPkg.has(prod.name)) {
                     targetToPkg.set(prod.name, parsed.name);
                 }
             }
         }
-        // ── 第二遍：构建 edges ──
         for (const parsed of allParsed) {
-            // 跳过 umbrella 包的边
             if (umbrellaNames.has(parsed.name)) {
                 continue;
             }
-            // 包级 local path 依赖
             for (const dep of parsed.dependencies || []) {
                 if (dep.type === 'local' && 'path' in dep && dep.path) {
                     const depPkgSwift = join(parsed._dir, dep.path, 'Package.swift');
                     if (existsSync(depPkgSwift)) {
                         try {
-                            const depParsed = this.#parser.parse(depPkgSwift);
-                            // 跳过指向 umbrella 包的边
+                            const depParsed = this.#parsePackageSwift(depPkgSwift);
                             if (!umbrellaNames.has(depParsed.name)) {
                                 edges.push({ from: parsed.name, to: depParsed.name, type: 'depends_on' });
                             }
@@ -224,12 +210,9 @@ export class SpmDiscoverer extends ProjectDiscoverer {
                     edges.push({ from: parsed.name, to: remoteName, type: 'depends_on' });
                 }
             }
-            // target 级依赖
             for (const t of parsed.targets || []) {
-                // target → parent package (contains)
                 edges.push({ from: parsed.name, to: t.name, type: 'contains' });
                 for (const depName of t.dependencies || []) {
-                    // target → target 依赖（跳过指向 umbrella 包的）
                     if (!umbrellaNames.has(depName)) {
                         edges.push({ from: t.name, to: depName, type: 'depends_on' });
                     }
@@ -238,16 +221,148 @@ export class SpmDiscoverer extends ProjectDiscoverer {
         }
         return { nodes, edges };
     }
-    /** @deprecated SpmHelper 不再由 SpmDiscoverer 持有，仅 XcodeIntegration 通过 container 使用 */
-    getSpmService() {
-        return null;
-    }
     // ─────────────── Private Helpers ───────────────
-    /**
-     * 遍历源码目录，返回源文件列表
-     * @param dir 源码根目录
-     * @returns []}
-     */
+    /** 向下递归扫描所有 Package.swift（支持多 Package 项目） */
+    #findAllPackageSwifts(rootDir) {
+        const results = [];
+        const scan = (dir, depth = 0) => {
+            if (depth > 5) {
+                return;
+            }
+            try {
+                const entries = readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        if (SKIP_DIRS.has(entry.name)) {
+                            continue;
+                        }
+                        scan(join(dir, entry.name), depth + 1);
+                    }
+                    else if (entry.name === 'Package.swift') {
+                        results.push(join(dir, entry.name));
+                    }
+                }
+            }
+            catch {
+                // 权限错误等，跳过
+            }
+        };
+        scan(rootDir);
+        return results;
+    }
+    /** 简易解析 Package.swift（无 Swift 编译器，使用正则） */
+    #parsePackageSwift(packagePath) {
+        if (!packagePath || !existsSync(packagePath)) {
+            throw new Error(`Package.swift not found: ${packagePath}`);
+        }
+        const content = readFileSync(packagePath, 'utf-8');
+        return {
+            path: packagePath,
+            name: this.#extractName(content),
+            version: this.#extractVersion(content),
+            targets: this.#extractTargets(content),
+            dependencies: this.#extractDependencies(content),
+            products: this.#extractProducts(content),
+            platforms: this.#extractPlatforms(content),
+        };
+    }
+    #extractName(content) {
+        const m = content.match(/name\s*:\s*"([^"]+)"/);
+        return m ? m[1] : 'unknown';
+    }
+    #extractVersion(content) {
+        const m = content.match(/version\s*:\s*"([^"]+)"/);
+        return m ? m[1] : '0.0.0';
+    }
+    #extractTargets(content) {
+        const targets = [];
+        const re = /\.(?:target|testTarget|executableTarget)\s*\(/g;
+        let match;
+        while ((match = re.exec(content)) !== null) {
+            const type = match[0].includes('testTarget')
+                ? 'testTarget'
+                : match[0].includes('executableTarget')
+                    ? 'executableTarget'
+                    : 'target';
+            const startPos = match.index + match[0].length;
+            let depth = 1;
+            let endPos = startPos;
+            while (depth > 0 && endPos < content.length) {
+                if (content[endPos] === '(') {
+                    depth++;
+                }
+                else if (content[endPos] === ')') {
+                    depth--;
+                }
+                endPos++;
+            }
+            if (depth === 0) {
+                const block = content.substring(startPos, endPos - 1);
+                const nameMatch = block.match(/name\s*:\s*"([^"]+)"/);
+                if (!nameMatch) {
+                    continue;
+                }
+                const pathMatch = block.match(/path\s*:\s*"([^"]+)"/);
+                const depsMatch = block.match(/dependencies\s*:\s*\[([^\]]*)\]/s);
+                const deps = [];
+                if (depsMatch) {
+                    const depRe = /\.(?:product|target)\s*\(\s*name\s*:\s*"([^"]+)"/g;
+                    let dm;
+                    while ((dm = depRe.exec(depsMatch[1])) !== null) {
+                        deps.push(dm[1]);
+                    }
+                }
+                targets.push({
+                    name: nameMatch[1],
+                    type,
+                    path: pathMatch ? pathMatch[1] : null,
+                    dependencies: deps,
+                });
+            }
+        }
+        return targets;
+    }
+    #extractDependencies(content) {
+        const deps = [];
+        const urlRe = /\.package\s*\(\s*url\s*:\s*"([^"]+)"[^)]*\)/g;
+        let m;
+        while ((m = urlRe.exec(content)) !== null) {
+            const block = m[0];
+            const fromMatch = block.match(/from\s*:\s*"([^"]+)"/);
+            const exactMatch = block.match(/exact\s*:\s*"([^"]+)"/);
+            deps.push({
+                url: m[1],
+                version: fromMatch ? fromMatch[1] : exactMatch ? exactMatch[1] : null,
+                type: 'package',
+            });
+        }
+        const pathRe = /\.package\s*\(\s*path\s*:\s*"([^"]+)"\s*\)/g;
+        while ((m = pathRe.exec(content)) !== null) {
+            deps.push({
+                path: m[1],
+                type: 'local',
+            });
+        }
+        return deps;
+    }
+    #extractProducts(content) {
+        const products = [];
+        const re = /\.(library|executable)\s*\(\s*name\s*:\s*"([^"]+)"/g;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+            products.push({ name: m[2], type: m[1] });
+        }
+        return products;
+    }
+    #extractPlatforms(content) {
+        const platforms = [];
+        const re = /\.(iOS|macOS|tvOS|watchOS|visionOS)\s*\(\s*\.v(\d+(?:_\d+)?)\s*\)/g;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+            platforms.push({ name: m[1], version: m[2].replace(/_/g, '.') });
+        }
+        return platforms;
+    }
     #walkSourceFiles(dir) {
         const CODE_EXTS = new Set(['.swift', '.m', '.h', '.c', '.cpp', '.mm']);
         const SKIP_DIRS = new Set([

package/dist/lib/core/discovery/index.d.ts

@@ -7,7 +7,6 @@ import { DiscovererRegistry } from './DiscovererRegistry.js';
 export declare function getDiscovererRegistry(): DiscovererRegistry;
 /** 重置 Registry（仅用于测试） */
 export declare function resetDiscovererRegistry(): void;
-export { SpmDiscoverer } from '../../platform/ios/spm/SpmDiscoverer.js';
 export { DartDiscoverer } from './DartDiscoverer.js';
 export { DiscovererRegistry } from './DiscovererRegistry.js';
 export { GenericDiscoverer } from './GenericDiscoverer.js';
@@ -17,3 +16,4 @@ export { NodeDiscoverer } from './NodeDiscoverer.js';
 export { ProjectDiscoverer } from './ProjectDiscoverer.js';
 export { PythonDiscoverer } from './PythonDiscoverer.js';
 export { RustDiscoverer } from './RustDiscoverer.js';
+export { SpmDiscoverer } from './SpmDiscoverer.js';

package/dist/lib/core/discovery/index.js

@@ -2,7 +2,6 @@
  * @module discovery/index
  * @description ProjectDiscoverer 系统入口 - 初始化 Registry 并注册所有 Discoverer
  */
-import { SpmDiscoverer } from '../../platform/ios/spm/SpmDiscoverer.js';
 import { DartDiscoverer } from './DartDiscoverer.js';
 import { DiscovererRegistry } from './DiscovererRegistry.js';
 import { GenericDiscoverer } from './GenericDiscoverer.js';
@@ -11,6 +10,7 @@ import { JvmDiscoverer } from './JvmDiscoverer.js';
 import { NodeDiscoverer } from './NodeDiscoverer.js';
 import { PythonDiscoverer } from './PythonDiscoverer.js';
 import { RustDiscoverer } from './RustDiscoverer.js';
+import { SpmDiscoverer } from './SpmDiscoverer.js';
 let _registry = null;
 /** 获取全局 DiscovererRegistry 单例 */
 export function getDiscovererRegistry() {
@@ -32,7 +32,6 @@ export function getDiscovererRegistry() {
 export function resetDiscovererRegistry() {
     _registry = null;
 }
-export { SpmDiscoverer } from '../../platform/ios/spm/SpmDiscoverer.js';
 export { DartDiscoverer } from './DartDiscoverer.js';
 export { DiscovererRegistry } from './DiscovererRegistry.js';
 export { GenericDiscoverer } from './GenericDiscoverer.js';
@@ -43,3 +42,4 @@ export { NodeDiscoverer } from './NodeDiscoverer.js';
 export { ProjectDiscoverer } from './ProjectDiscoverer.js';
 export { PythonDiscoverer } from './PythonDiscoverer.js';
 export { RustDiscoverer } from './RustDiscoverer.js';
+export { SpmDiscoverer } from './SpmDiscoverer.js';

package/dist/lib/domain/knowledge/KnowledgeEntry.d.ts

@@ -11,6 +11,7 @@ export interface KnowledgeEntryProps {
         at: number;
     }>;
     autoApprovable?: boolean;
+    stagingDeadline?: number | null;
     language?: string;
     category?: string;
     knowledgeType?: string;
@@ -62,6 +63,7 @@ export declare class KnowledgeEntry {
         at: number;
     }>;
     autoApprovable: boolean;
+    stagingDeadline: number | null;
     language: string;
     category: string;
     knowledgeType: string;
@@ -240,6 +242,14 @@ export declare class KnowledgeEntry {
             guardHits: number;
             searchHits: number;
             authority: number;
+            lastHitAt: number | null;
+            lastSearchedAt: number | null;
+            lastGuardHitAt: number | null;
+            hitsLast30d: number;
+            hitsLast90d: number;
+            searchHitsLast30d: number;
+            version: number;
+            ruleFalsePositiveRate: number | null;
         };
         headers: string[];
         headerPaths: string[];

package/dist/lib/domain/knowledge/KnowledgeEntry.js

@@ -10,6 +10,7 @@ export class KnowledgeEntry {
     lifecycle;
     lifecycleHistory;
     autoApprovable;
+    stagingDeadline;
     // Language & Classification
     language;
     category;
@@ -65,6 +66,7 @@ export class KnowledgeEntry {
         this.lifecycle = normalizeLifecycle(props.lifecycle || Lifecycle.PENDING);
         this.lifecycleHistory = props.lifecycleHistory || [];
         this.autoApprovable = props.autoApprovable ?? false;
+        this.stagingDeadline = props.stagingDeadline ?? null;
         // ── 语言与分类 ──
         this.language = props.language || '';
         this.category = props.category || '';

package/dist/lib/domain/knowledge/Lifecycle.d.ts

@@ -1,28 +1,45 @@
 /**
- * Lifecycle — 知识实体生命周期状态机（3 状态简化版）
+ * Lifecycle — 知识实体生命周期状态机（六态版）
  *
  * pending    — 待审核（所有新条目初始状态）
+ * staging    — 暂存期（高置信度，Grace Period 后自动 active）
  * active     — 已发布（可被搜索/Guard/Export 消费）
+ * evolving   — 进化中（有 EvolutionProposal 附着，内容待更新）
+ * decaying   — 衰退观察（30d Grace + 3x 确认后 deprecated）
  * deprecated — 已废弃
  */
 export declare const Lifecycle: {
     /** 待审核 */
     PENDING: string;
+    /** 暂存期（高置信度，Grace Period 后自动 active） */
+    STAGING: string;
     /** 已发布（可被搜索/Guard/Export 消费） */
     ACTIVE: string;
+    /** 进化中（有 EvolutionProposal 附着） */
+    EVOLVING: string;
+    /** 衰退观察期 */
+    DECAYING: string;
     /** 已弃用 */
     DEPRECATED: string;
 };
 /** 候选阶段的所有状态 */
 export declare const CANDIDATE_STATES: string[];
+/** 可消费状态（Guard/Search/Delivery 可使用的状态） */
+export declare const CONSUMABLE_STATES: string[];
+/** 降级消费状态（Guard violation 降为 warning，Search 降权） */
+export declare const DEGRADED_STATES: string[];
 /** 规范化生命周期值 */
 export declare function normalizeLifecycle(lifecycle: string): string;
 /** 检查状态转移是否合法 */
 export declare function isValidTransition(from: string, to: string): boolean;
 /** 是否为合法的生命周期值 */
 export declare function isValidLifecycle(lifecycle: string): boolean;
-/** 是否处于候选阶段（待审核） */
+/** 是否处于候选阶段（待审核或暂存） */
 export declare function isCandidate(lifecycle: string): boolean;
+/** 是否为可消费状态（Guard/Search/Delivery 可使用） */
+export declare function isConsumable(lifecycle: string): boolean;
+/** 是否为降级消费状态 */
+export declare function isDegraded(lifecycle: string): boolean;
 /** 从 knowledgeType 推导 kind */
 export declare function inferKind(knowledgeType: string): 'rule' | 'pattern' | 'fact';
 export default Lifecycle;

package/dist/lib/domain/knowledge/Lifecycle.js

@@ -1,24 +1,40 @@
 /**
- * Lifecycle — 知识实体生命周期状态机（3 状态简化版）
+ * Lifecycle — 知识实体生命周期状态机（六态版）
  *
  * pending    — 待审核（所有新条目初始状态）
+ * staging    — 暂存期（高置信度，Grace Period 后自动 active）
  * active     — 已发布（可被搜索/Guard/Export 消费）
+ * evolving   — 进化中（有 EvolutionProposal 附着，内容待更新）
+ * decaying   — 衰退观察（30d Grace + 3x 确认后 deprecated）
  * deprecated — 已废弃
  */
 export const Lifecycle = {
     /** 待审核 */
     PENDING: 'pending',
+    /** 暂存期（高置信度，Grace Period 后自动 active） */
+    STAGING: 'staging',
     /** 已发布（可被搜索/Guard/Export 消费） */
     ACTIVE: 'active',
+    /** 进化中（有 EvolutionProposal 附着） */
+    EVOLVING: 'evolving',
+    /** 衰退观察期 */
+    DECAYING: 'decaying',
     /** 已弃用 */
     DEPRECATED: 'deprecated',
 };
 /** 候选阶段的所有状态 */
-export const CANDIDATE_STATES = [Lifecycle.PENDING];
+export const CANDIDATE_STATES = [Lifecycle.PENDING, Lifecycle.STAGING];
+/** 可消费状态（Guard/Search/Delivery 可使用的状态） */
+export const CONSUMABLE_STATES = [Lifecycle.STAGING, Lifecycle.ACTIVE, Lifecycle.EVOLVING];
+/** 降级消费状态（Guard violation 降为 warning，Search 降权） */
+export const DEGRADED_STATES = [Lifecycle.DECAYING];
 /** 合法状态转移表 */
 const VALID_TRANSITIONS = {
-    [Lifecycle.PENDING]: [Lifecycle.ACTIVE, Lifecycle.DEPRECATED],
-    [Lifecycle.ACTIVE]: [Lifecycle.DEPRECATED],
+    [Lifecycle.PENDING]: [Lifecycle.STAGING, Lifecycle.ACTIVE, Lifecycle.DEPRECATED],
+    [Lifecycle.STAGING]: [Lifecycle.ACTIVE, Lifecycle.PENDING],
+    [Lifecycle.ACTIVE]: [Lifecycle.EVOLVING, Lifecycle.DECAYING, Lifecycle.DEPRECATED],
+    [Lifecycle.EVOLVING]: [Lifecycle.ACTIVE, Lifecycle.DECAYING],
+    [Lifecycle.DECAYING]: [Lifecycle.ACTIVE, Lifecycle.DEPRECATED],
     [Lifecycle.DEPRECATED]: [Lifecycle.PENDING],
 };
 /** 规范化生命周期值 */
@@ -39,10 +55,20 @@ export function isValidTransition(from, to) {
 export function isValidLifecycle(lifecycle) {
     return Object.values(Lifecycle).includes(lifecycle);
 }
-/** 是否处于候选阶段（待审核） */
+/** 是否处于候选阶段（待审核或暂存） */
 export function isCandidate(lifecycle) {
     const normalized = normalizeLifecycle(lifecycle);
-    return normalized === Lifecycle.PENDING;
+    return normalized === Lifecycle.PENDING || normalized === Lifecycle.STAGING;
+}
+/** 是否为可消费状态（Guard/Search/Delivery 可使用） */
+export function isConsumable(lifecycle) {
+    const normalized = normalizeLifecycle(lifecycle);
+    return CONSUMABLE_STATES.includes(normalized);
+}
+/** 是否为降级消费状态 */
+export function isDegraded(lifecycle) {
+    const normalized = normalizeLifecycle(lifecycle);
+    return DEGRADED_STATES.includes(normalized);
 }
 /* ── knowledgeType → kind 映射 ── */
 const KIND_MAP = {

package/dist/lib/domain/knowledge/UnifiedValidator.d.ts

@@ -4,10 +4,7 @@
  * 替代 CandidateGuardrail + RecipeReadinessChecker 的分裂验证，
  * 提供单一入口的三层验证 (字段完整性 + 内容质量 + 去重)。
  *
- * 分级模式:
- *   strict   — 默认：完整 REQUIRED 字段检查（标准知识条目）
- *   document — knowledgeType='dev-document' 时自动切换：跳过 Cursor 交付字段
- *   fallback — source 含 'fallback' 时：REQUIRED 降级为 WARNING
+ * 统一严格模式：完整 REQUIRED 字段检查，无宽松降级。
  *
  * @module shared/UnifiedValidator
  */
@@ -31,7 +28,6 @@ export declare class UnifiedValidator {
      * @returns }
      */
     validate(candidate: Record<string, unknown>, options?: {
-        mode?: 'strict' | 'document' | 'fallback';
         systemInjectedFields?: string[];
         skipUniqueness?: boolean;
     }): {

package/dist/lib/domain/knowledge/UnifiedValidator.js

@@ -4,25 +4,12 @@
  * 替代 CandidateGuardrail + RecipeReadinessChecker 的分裂验证，
  * 提供单一入口的三层验证 (字段完整性 + 内容质量 + 去重)。
  *
- * 分级模式:
- *   strict   — 默认：完整 REQUIRED 字段检查（标准知识条目）
- *   document — knowledgeType='dev-document' 时自动切换：跳过 Cursor 交付字段
- *   fallback — source 含 'fallback' 时：REQUIRED 降级为 WARNING
+ * 统一严格模式：完整 REQUIRED 字段检查，无宽松降级。
  *
  * @module shared/UnifiedValidator
  */
 import { LanguageService } from '#shared/LanguageService.js';
 import { FieldLevel, STANDARD_CATEGORIES, V3_FIELD_SPEC, VALID_KINDS, WHITELISTED_CATEGORIES, } from './FieldSpec.js';
-// ── Cursor 交付字段集合（document 模式跳过这些） ────────────
-const CURSOR_DELIVERY_FIELDS = new Set([
-    'trigger',
-    'kind',
-    'doClause',
-    'dontClause',
-    'whenClause',
-    'coreCode',
-    'topicHint',
-]);
 // ── 代码指纹工具函数 ───────────────────────────────────────
 /** 生成代码模式指纹 — 去除空白/注释后取前 200 字符的小写形式 */
 function codeFingerprint(code) {
@@ -33,17 +20,6 @@ function codeFingerprint(code) {
         .toLowerCase()
         .slice(0, 200);
 }
-// ── 模式自动检测 ────────────────────────────────────────────
-/** 自动检测适合的验证模式 */
-function detectMode(candidate) {
-    if (candidate.knowledgeType === 'dev-document') {
-        return 'document';
-    }
-    if (typeof candidate.source === 'string' && candidate.source.includes('fallback')) {
-        return 'fallback';
-    }
-    return 'strict';
-}
 // ── UnifiedValidator ────────────────────────────────────────
 export class UnifiedValidator {
     /** 已提交标题 (小写) */
@@ -70,14 +46,11 @@ export class UnifiedValidator {
     validate(candidate, options = {}) {
         const errors = [];
         const warnings = [];
-        const mode = options.mode || detectMode(candidate);
         const systemInjected = new Set(options.systemInjectedFields || []);
         // ── Layer 1: 字段完整性 (基于 V3_FIELD_SPEC) ──
-        this.#checkFields(candidate, mode, systemInjected, errors, warnings);
+        this.#checkFields(candidate, systemInjected, errors, warnings);
         // ── Layer 2: 内容质量 (来自 CandidateGuardrail.validateQuality) ──
-        if (mode !== 'fallback') {
-            this.#checkContentQuality(candidate, mode, errors, warnings);
-        }
+        this.#checkContentQuality(candidate, errors, warnings);
         // ── Layer 3: 唯一性 (来自 CandidateGuardrail.validateUniqueness) ──
         if (!options.skipUniqueness) {
             this.#checkUniqueness(candidate, errors);
@@ -89,13 +62,9 @@ export class UnifiedValidator {
         };
     }
     // ── Layer 1: 基于 FieldSpec 检查 ─────────────────────────
-    #checkFields(candidate, mode, systemInjected, errors, warnings) {
+    #checkFields(candidate, systemInjected, errors, warnings) {
         for (const field of V3_FIELD_SPEC) {
             const { name, level, rule } = field;
-            // document 模式：跳过 Cursor 交付字段
-            if (mode === 'document' && CURSOR_DELIVERY_FIELDS.has(name.split('.')[0])) {
-                continue;
-            }
             // 系统注入字段：跳过
             if (systemInjected.has(name)) {
                 continue;
@@ -106,13 +75,7 @@ export class UnifiedValidator {
                 continue;
             }
             if (level === FieldLevel.REQUIRED) {
-                if (mode === 'fallback') {
-                    // fallback 模式：REQUIRED 降级为 warning
-                    warnings.push(`${name}: ${rule}`);
-                }
-                else {
-                    errors.push(`缺少必填字段: ${name} — ${rule}`);
-                }
+                errors.push(`缺少必填字段: ${name} — ${rule}`);
             }
             else if (level === FieldLevel.EXPECTED) {
                 warnings.push(`建议填写: ${name} — ${rule}`);
@@ -149,7 +112,7 @@ export class UnifiedValidator {
         }
     }
     // ── Layer 2: 内容质量启发式 ──────────────────────────────
-    #checkContentQuality(candidate, mode, errors, warnings) {
+    #checkContentQuality(candidate, errors, warnings) {
         const markdown = candidate.content?.markdown || '';
         // markdown ≥ 200 字符
         if (markdown && markdown.length > 0 && markdown.length < 200) {
@@ -171,7 +134,7 @@ export class UnifiedValidator {
             }
         }
         // coreCode 语法完整性
-        if (mode !== 'document') {
+        {
             const coreCode = (candidate.coreCode || '').trim();
             if (coreCode) {
                 const firstChar = coreCode[0];