autosnippet 3.3.5 → 3.3.7

package/dist/lib/service/search/SearchEngine.js

@@ -1,7 +1,7 @@
 /**
  * SearchEngine - 统一搜索引擎
  *
- * 三级搜索策略: keyword → BM25 ranking → semantic(可选)
+ * 三级搜索策略: keyword → FieldWeighted ranking → semantic(可选)
  * 从 V1 SearchServiceV2 迁移，适配 V2 架构
  */
 import Logger from '../../infrastructure/logging/Logger.js';
@@ -129,22 +129,22 @@ export class SearchEngine {
         let actualMode = mode;
         switch (mode) {
             case 'auto': {
-                // 缓存 BM25 结果, 避免 RRF 降级时重复计算
-                let cachedBm25Items = null;
-                const getBm25 = () => {
-                    if (!cachedBm25Items) {
-                        cachedBm25Items = this._bm25Search(query, type, recallLimit);
+                // 缓存 FieldWeighted 结果, 避免 RRF 降级时重复计算
+                let cachedScorerItems = null;
+                const getScorerResults = () => {
+                    if (!cachedScorerItems) {
+                        cachedScorerItems = this._scorerSearch(query, type, recallLimit);
                     }
-                    return cachedBm25Items;
+                    return cachedScorerItems;
                 };
                 // 优先使用 VectorService 的 hybridSearch (统一 RRF 融合)
                 if (this.vectorService) {
                     try {
-                        const bm25Items = getBm25();
+                        const sparseItems = getScorerResults();
                         const rrfResults = await this.vectorService.hybridSearch(query, {
                             topK: recallLimit,
                             alpha: this._fusionSemanticWeight,
-                            sparseSearchFn: () => bm25Items,
+                            sparseSearchFn: () => sparseItems,
                         });
                         if (rrfResults.length > 0) {
                             results = rrfResults.map((r) => {
@@ -178,15 +178,16 @@ export class SearchEngine {
                         // VectorService RRF 失败, 降级到 min-max 融合
                     }
                 }
-                // 降级: VectorService 不可用或 RRF 零结果 → 纯 BM25
+                // 降级: VectorService 不可用或 RRF 零结果 → 纯 FieldWeighted
                 // 旧版在此做 BM25+semantic min-max 融合，但当 VectorService 不可用时
-                // semantic 通常也会失败，最终退化为纯 BM25。简化为直接走 BM25。
-                results = getBm25();
-                actualMode = 'auto(bm25-only)';
+                // semantic 通常也会失败，最终退化为纯 FieldWeighted。简化为直接走 scorer。
+                results = getScorerResults();
+                actualMode = 'auto(weighted-only)';
                 break;
             }
+            case 'weighted':
             case 'bm25':
-                results = this._bm25Search(query, type, recallLimit);
+                results = this._scorerSearch(query, type, recallLimit);
                 break;
             case 'semantic': {
                 const semResult = await this._semanticSearch(query, type, recallLimit);
@@ -300,7 +301,7 @@ export class SearchEngine {
     /**
      * 关键词搜索 - 直接 SQL LIKE
      * 返回包含 kind 字段的完整结果，使用 ESCAPE 防止通配符注入
-     * 当 SQL LIKE 无结果时，降级到 BM25 搜索以提升自然语言查询的召回率
+     * 当 SQL LIKE 无结果时，降级到 FieldWeighted 搜索以提升自然语言查询的召回率
      */
     _keywordSearch(query, type, limit) {
         const results = [];
@@ -351,23 +352,23 @@ export class SearchEngine {
                 /* table may not exist */
             }
         }
-        // 补充排序信号字段（whenClause/doClause/tags 等），与 BM25/semantic 路径一致
+        // 补充排序信号字段（whenClause/doClause/tags 等），与 scorer/semantic 路径一致
         this._supplementDetails(results);
-        // 当 SQL LIKE 无结果时，降级到 BM25 搜索
+        // 当 SQL LIKE 无结果时，降级到 FieldWeighted 搜索
         // 这让自然语言查询（如 "如何处理网络错误"）在 keyword 模式下也能返回结果
         if (results.length === 0) {
             this.ensureIndex();
-            const bm25Results = this._bm25Search(query, type, limit);
-            return bm25Results;
+            const scorerResults = this._scorerSearch(query, type, limit);
+            return scorerResults;
         }
         return results.slice(0, limit);
     }
     /**
-     * BM25 排序搜索
+     * 加权字段搜索（FieldWeightedScorer）
      * 增加 Title/Trigger 精确匹配 bonus — 当 query 出现在标题/触发词中时
-     * 给予额外 BM25 分数加成，确保精确匹配的条目排名靠前
+     * 给予额外分数加成，确保精确匹配的条目排名靠前
      */
-    _bm25Search(query, type, limit) {
+    _scorerSearch(query, type, limit) {
         let results = this.scorer.search(query, limit * 2);
         if (type !== 'all') {
             // All types now map to 'recipe' since everything is unified
@@ -379,7 +380,7 @@ export class SearchEngine {
             });
         }
         // ── Title/Trigger exact-match bonus ──
-        // 当 query 精确出现在标题或触发词中时，增加 BM25 分数
+        // 当 query 精确出现在标题或触发词中时，增加分数
         // 这解决了 "BaseRequest" 被 "BD前缀类名命名规范" 排在 "BDBaseRequest 继承请求模式" 前面的问题
         const lowerQuery = query.toLowerCase();
         const maxScore = results.length > 0 ? results[0].score : 1;
@@ -432,7 +433,7 @@ export class SearchEngine {
     }
     /**
      * 语义搜索 - 需要 AI Provider 的 embed 功能
-     * 降级到 BM25 如果 AI 不可用
+     * 不可用时降级到 FieldWeighted 搜索
      * @returns >}
      */
     async _semanticSearch(query, type, limit) {
@@ -474,13 +475,13 @@ export class SearchEngine {
         }
         // Legacy fallback: 直接使用 aiProvider embed + vectorStore
         if (!this.aiProvider) {
-            this.logger.debug('AI provider not available, falling back to BM25');
-            return { items: this._bm25Search(query, type, limit), actualMode: 'bm25' };
+            this.logger.debug('AI provider not available, falling back to FieldWeighted search');
+            return { items: this._scorerSearch(query, type, limit), actualMode: 'weighted' };
         }
         try {
             const queryEmbedding = await this.aiProvider.embed(query);
             if (!queryEmbedding || queryEmbedding.length === 0) {
-                return { items: this._bm25Search(query, type, limit), actualMode: 'bm25' };
+                return { items: this._scorerSearch(query, type, limit), actualMode: 'weighted' };
             }
             if (this.vectorStore) {
                 try {
@@ -523,24 +524,24 @@ export class SearchEngine {
                     }
                 }
                 catch (vecErr) {
-                    this.logger.warn('Vector store query failed, falling back to BM25', {
+                    this.logger.warn('Vector store query failed, falling back to FieldWeighted', {
                         error: vecErr.message,
                     });
                 }
             }
-            this.logger.debug('Vector search fallback to BM25');
-            return { items: this._bm25Search(query, type, limit), actualMode: 'bm25' };
+            this.logger.debug('Vector search fallback to FieldWeighted');
+            return { items: this._scorerSearch(query, type, limit), actualMode: 'weighted' };
         }
         catch (err) {
-            this.logger.warn('Semantic search failed, falling back to BM25', {
+            this.logger.warn('Semantic search failed, falling back to FieldWeighted', {
                 error: err.message,
             });
-            return { items: this._bm25Search(query, type, limit), actualMode: 'bm25' };
+            return { items: this._scorerSearch(query, type, limit), actualMode: 'weighted' };
         }
     }
     /**
      * 补充详细字段（content / description / trigger / delivery 字段）— 批量 IN 查询
-     * 用于向量搜索结果与 BM25 结果的一致性
+     * 用于向量搜索结果与 FieldWeighted 结果的一致性
      */
     _supplementDetails(items) {
         if (!items || items.length === 0) {
@@ -730,9 +731,10 @@ export class SearchEngine {
     /**
      * 从 DB 行构建索引文本
      *
-     * 使用 BM25F 思想：高价值字段（title, trigger）重复出现以提升 TF 权重
+     * 高价值字段（title, trigger）通过重复出现提升 TF 权重
      * — title ×3, trigger ×2, description ×1.5（通过重复 token 实现）
-     * 这确保标题匹配的文档获得显著更高的 BM25 分数
+     * 这确保标题匹配的文档获得显著更高的分数
+     * 注：此逻辑主要服务于 BM25Scorer，FieldWeightedScorer 内部已有字段权重机制
      */
     _buildDocText(r) {
         let contentText = '';
@@ -752,7 +754,7 @@ export class SearchEngine {
         catch {
             /* ignore */
         }
-        // BM25F field boosting via token repetition:
+        // Field boosting via token repetition:
         // title ×2, trigger ×2, description ×1, others ×1
         // 使用较温和的 boost 避免长文档 avgLength 膨胀导致 content 匹配被过度稀释
         const title = r.title || '';

package/dist/lib/service/search/SearchTypes.d.ts

@@ -2,26 +2,30 @@
  * SearchTypes — SearchEngine 共享类型定义
  *
  * 从 SearchEngine.ts 提取的所有接口和类型，
- * 供 SearchEngine、BM25Scorer 及测试文件独立消费。
+ * 供 SearchEngine、FieldWeightedScorer、BM25Scorer 及测试文件独立消费。
  *
  * @module SearchTypes
  */
-/** Internal BM25 document representation */
-export interface BM25Document {
+/** Internal scorer document representation */
+export interface ScorerDocument {
     id: string;
     tokens: string[];
     tokenFreq: Record<string, number>;
     length: number;
     meta: Record<string, unknown>;
 }
-/** BM25 search result */
-export interface BM25SearchResult {
+/** Scorer search result */
+export interface ScorerResult {
     id: string;
     score: number;
     meta: Record<string, unknown>;
 }
+/** @deprecated Use ScorerDocument */
+export type BM25Document = ScorerDocument;
+/** @deprecated Use ScorerResult */
+export type BM25SearchResult = ScorerResult;
 /**
- * Scorer 通用接口 — BM25Scorer 与 FieldWeightedScorer 共同实现
+ * Scorer 通用接口 — FieldWeightedScorer（默认）与 BM25Scorer 共同实现
  *
  * SearchEngine 通过此接口与具体评分器解耦，可在运行时切换。
  */
@@ -36,11 +40,11 @@ export interface Scorer {
     removeDocument(id: string): boolean;
     updateDocument(id: string, text: string, meta: Record<string, unknown>): void;
     hasDocument(id: string): boolean;
-    search(query: string, limit?: number): BM25SearchResult[];
+    search(query: string, limit?: number): ScorerResult[];
     clear(): void;
 }
 /** Meta structure produced by _buildDocMeta */
-export interface BM25DocMeta {
+export interface DocMeta {
     type: string;
     title: string;
     trigger: string;
@@ -58,6 +62,8 @@ export interface BM25DocMeta {
     qualityScore: number;
     [key: string]: unknown;
 }
+/** @deprecated Use DocMeta */
+export type BM25DocMeta = DocMeta;
 /** Unified search result item flowing through the ranking pipeline */
 export interface SearchResultItem {
     id: string;

package/dist/lib/service/search/SearchTypes.js

@@ -2,7 +2,7 @@
  * SearchTypes — SearchEngine 共享类型定义
  *
  * 从 SearchEngine.ts 提取的所有接口和类型，
- * 供 SearchEngine、BM25Scorer 及测试文件独立消费。
+ * 供 SearchEngine、FieldWeightedScorer、BM25Scorer 及测试文件独立消费。
  *
  * @module SearchTypes
  */

package/dist/lib/service/search/tokenizer.d.ts

@@ -6,7 +6,7 @@
  *
  * @module tokenizer
  */
-/** BM25 调参常量 */
+/** 评分调参常量（原 BM25 k1/b 参数，BM25Scorer 仍在使用） */
 export declare const BM25_K1 = 1.2;
 export declare const BM25_B = 0.75;
 /**

package/dist/lib/service/search/tokenizer.js

@@ -6,11 +6,11 @@
  *
  * @module tokenizer
  */
-/** BM25 调参常量 */
+/** 评分调参常量（原 BM25 k1/b 参数，BM25Scorer 仍在使用） */
 export const BM25_K1 = 1.2;
 export const BM25_B = 0.75;
 /**
- * 中文停用词表 — 过滤常见虚词/助词/代词/连词，减少 BM25 噪声
+ * 中文停用词表 — 过滤常见虚词/助词/代词/连词，减少搜索噪声
  * 参考 jieba / Elasticsearch smartcn_stop / 百度停用词表
  */
 const CJK_STOPWORDS = new Set([

package/dist/lib/service/skills/SignalCollector.d.ts

@@ -73,6 +73,7 @@ interface ContainerService {
 }
 interface ContainerLike {
     get(name: string): ContainerService | null;
+    singletons?: Record<string, unknown>;
 }
 export declare class SignalCollector {
     #private;

package/dist/lib/service/skills/SignalCollector.js

@@ -112,8 +112,8 @@ export class SignalCollector {
             this.#logger.info('[SignalCollector] mode=off, skipping start');
             return;
         }
-        const aiProvider = this.#container?.get('aiProvider');
-        if (!aiProvider || aiProvider.name === 'mock') {
+        const manager = this.#container?.singletons?._aiProviderManager;
+        if (manager?.isMock) {
             this.#logger.info('[SignalCollector] no AI provider available, starting in rule-fallback mode');
         }
         if (this.#timer) {
@@ -217,8 +217,9 @@ export class SignalCollector {
                 codeChanges: this.#collectCodeChangeSignals(),
             };
             // ── 离线 Fallback: 当 AI 不可用时，降级到 SkillAdvisor 规则引擎 ──
-            const aiProvider = this.#container?.get('aiProvider');
-            if (!this.#agentFactory || !aiProvider || aiProvider.name === 'mock') {
+            const isMock = this.#container?.singletons?._aiProviderManager
+                ?.isMock ?? true;
+            if (!this.#agentFactory || isMock) {
                 this.#logger.info('[SignalCollector] AI unavailable, falling back to rule-based analysis');
                 return this.#ruleFallback();
             }
@@ -226,7 +227,7 @@ export class SignalCollector {
             const prompt = this.#buildAnalysisPrompt(signals);
             // 3. 调用 Agent 系统进行 AI 分析
             this.#logger.debug('[SignalCollector] invoking Agent for analysis...');
-            const agent = this.#agentFactory.createChat({ lang: 'en' });
+            const agent = this.#agentFactory?.createChat({ lang: 'en' });
             const { AgentMessage } = await import('#agent/AgentMessage.js');
             const message = AgentMessage.internal(prompt, { source: 'signal_collector' });
             const result = await agent.execute(message);

package/dist/lib/service/vector/ContextualEnricher.d.ts

@@ -15,6 +15,7 @@
  * @module service/vector/ContextualEnricher
  */
 export interface AiProviderLike {
+    name?: string;
     chat(prompt: string, options?: {
         system?: string;
         maxTokens?: number;

package/dist/lib/service/vector/ContextualEnricher.js

@@ -40,6 +40,10 @@ export class ContextualEnricher {
         if (chunks.length === 0) {
             return [];
         }
+        // Mock 模式下跳过 AI enrichment，直接返回原始 chunks
+        if (this.#aiProvider.name === 'mock') {
+            return chunks;
+        }
         const systemPrompt = this.#buildSystemPrompt(document);
         const enriched = [];
         for (const chunk of chunks) {

package/dist/lib/shared/LanguageService.js

@@ -206,6 +206,7 @@ const LANG_ALIASES = Object.freeze({
 // ═══════════════════════════════════════════════════════════
 const ECO_TO_LANGS = Object.freeze({
     spm: Object.freeze(['swift', 'objectivec']),
+    xcode: Object.freeze(['swift', 'objectivec']),
     node: Object.freeze(['javascript', 'typescript']),
     go: Object.freeze(['go']),
     jvm: Object.freeze(['java', 'kotlin']),
@@ -223,6 +224,8 @@ const BUILD_SYSTEM_MARKERS = Object.freeze([
     // Apple / iOS
     { file: 'Package.swift', eco: 'spm', buildTool: 'SPM' },
     { file: 'Podfile', eco: 'spm', buildTool: 'CocoaPods' },
+    { file: '*.xcodeproj', eco: 'xcode', buildTool: 'Xcode' },
+    { file: '*.xcworkspace', eco: 'xcode', buildTool: 'Xcode' },
     // JS / TS (lock files before package.json to detect specific tool)
     { file: 'yarn.lock', eco: 'node', buildTool: 'Yarn' },
     { file: 'pnpm-lock.yaml', eco: 'node', buildTool: 'pnpm' },

package/dist/lib/shared/developer-identity.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 开发者身份解析
+ *
+ * 优先级链：
+ *   1. 环境变量 AUTOSNIPPET_USER
+ *   2. git config user.name（项目级 → 全局）
+ *   3. 操作系统用户名
+ *   4. 'unknown'
+ *
+ * 结果在进程级缓存，避免重复 exec。
+ */
+/**
+ * 同步获取当前开发者标识（缓存）。
+ * @param cwd — 用于解析 git config 的工作目录（默认 process.cwd()）
+ */
+export declare function getDeveloperIdentity(cwd?: string): string;
+/** 清除缓存（测试用） */
+export declare function clearDeveloperIdentityCache(): void;

package/dist/lib/shared/developer-identity.js

@@ -0,0 +1,62 @@
+/**
+ * 开发者身份解析
+ *
+ * 优先级链：
+ *   1. 环境变量 AUTOSNIPPET_USER
+ *   2. git config user.name（项目级 → 全局）
+ *   3. 操作系统用户名
+ *   4. 'unknown'
+ *
+ * 结果在进程级缓存，避免重复 exec。
+ */
+import { execSync } from 'node:child_process';
+import { userInfo } from 'node:os';
+let _cached = null;
+/**
+ * 同步获取当前开发者标识（缓存）。
+ * @param cwd — 用于解析 git config 的工作目录（默认 process.cwd()）
+ */
+export function getDeveloperIdentity(cwd) {
+    if (_cached) {
+        return _cached;
+    }
+    _cached = resolveDeveloperIdentity(cwd);
+    return _cached;
+}
+/** 清除缓存（测试用） */
+export function clearDeveloperIdentityCache() {
+    _cached = null;
+}
+function resolveDeveloperIdentity(cwd) {
+    // 1. 环境变量
+    const envUser = process.env['AUTOSNIPPET_USER'];
+    if (envUser?.trim()) {
+        return envUser.trim();
+    }
+    // 2. git config user.name
+    try {
+        const name = execSync('git config user.name', {
+            cwd: cwd || process.cwd(),
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (name) {
+            return name;
+        }
+    }
+    catch {
+        // git 未安装或不在 git repo 中
+    }
+    // 3. OS 用户名
+    try {
+        const info = userInfo();
+        if (info.username) {
+            return info.username;
+        }
+    }
+    catch {
+        // 极罕见：userInfo() 在某些容器环境可能失败
+    }
+    return 'unknown';
+}

package/dist/lib/shared/schemas/common.d.ts

@@ -25,20 +25,20 @@ export declare const KnowledgeTypeEnum: z.ZodEnum<{
     "code-pattern": "code-pattern";
     architecture: "architecture";
     "best-practice": "best-practice";
-    "event-and-data-flow": "event-and-data-flow";
+    "module-dependency": "module-dependency";
+    "boundary-constraint": "boundary-constraint";
     "code-standard": "code-standard";
     "code-style": "code-style";
     "code-relation": "code-relation";
-    "module-dependency": "module-dependency";
-    "boundary-constraint": "boundary-constraint";
     "data-flow": "data-flow";
+    "event-and-data-flow": "event-and-data-flow";
     solution: "solution";
     "anti-pattern": "anti-pattern";
 }>;
 export declare const ComplexityEnum: z.ZodEnum<{
     intermediate: "intermediate";
-    beginner: "beginner";
     advanced: "advanced";
+    beginner: "beginner";
 }>;
 export declare const ScopeEnum: z.ZodEnum<{
     universal: "universal";

package/dist/lib/shared/schemas/http-requests.d.ts

@@ -23,51 +23,49 @@ export declare const CreateKnowledgeBody: z.ZodObject<{
     title: z.ZodString;
     content: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
     description: z.ZodOptional<z.ZodString>;
-    kind: z.ZodOptional<z.ZodEnum<{
+    kind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         pattern: "pattern";
         rule: "rule";
         fact: "fact";
-    }>>;
+    }>>>;
     language: z.ZodOptional<z.ZodString>;
     category: z.ZodOptional<z.ZodString>;
     knowledgeType: z.ZodOptional<z.ZodString>;
-    complexity: z.ZodOptional<z.ZodEnum<{
-        intermediate: "intermediate";
-        basic: "basic";
-        advanced: "advanced";
-    }>>;
-    scope: z.ZodOptional<z.ZodEnum<{
-        universal: "universal";
-        project: "project";
-        team: "team";
-        personal: "personal";
-    }>>;
+    complexity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 export declare const UpdateKnowledgeBody: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    kind: z.ZodOptional<z.ZodEnum<{
+    kind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         pattern: "pattern";
         rule: "rule";
         fact: "fact";
-    }>>;
+    }>>>;
     language: z.ZodOptional<z.ZodString>;
     category: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 export declare const DeprecateKnowledgeBody: z.ZodObject<{
     reason: z.ZodString;
 }, z.core.$strip>;
 export declare const BatchPublishBody: z.ZodObject<{
     ids: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+export declare const BatchDeleteBody: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const BatchDeprecateBody: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const KnowledgeUsageBody: z.ZodObject<{
     type: z.ZodDefault<z.ZodEnum<{
+        view: "view";
         feedback: "feedback";
         adoption: "adoption";
-        view: "view";
     }>>;
     feedback: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
@@ -240,6 +238,10 @@ export declare const ModuleBootstrapBody: z.ZodObject<{
     skipGuard: z.ZodDefault<z.ZodBoolean>;
     contentMaxLines: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
+export declare const ModuleRescanBody: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare const GraphQuery: z.ZodObject<{
     nodeId: z.ZodString;
     nodeType: z.ZodString;

package/dist/lib/shared/schemas/http-requests.js

@@ -30,28 +30,31 @@ const PaginationQuery = z.object({
     limit: z.coerce.number().int().min(1).max(1000).default(20),
 });
 // ═══ Knowledge ═══════════════════════════════════
-export const CreateKnowledgeBody = z.object({
+export const CreateKnowledgeBody = z
+    .object({
     title: z.string().min(1, 'title is required'),
     content: z.union([z.string().min(1), z.record(z.string(), z.unknown())]),
     description: z.string().optional(),
-    kind: z.enum(['rule', 'pattern', 'fact']).optional(),
+    kind: z.enum(['rule', 'pattern', 'fact']).nullish(),
     language: z.string().optional(),
     category: z.string().optional(),
     knowledgeType: z.string().optional(),
-    complexity: z.enum(['basic', 'intermediate', 'advanced']).optional(),
-    scope: z.enum(['universal', 'project', 'team', 'personal']).optional(),
+    complexity: z.string().nullish(),
+    scope: z.string().nullish(),
     tags: z.array(z.string()).optional(),
-});
+})
+    .loose();
 export const UpdateKnowledgeBody = z
     .object({
     title: z.string().min(1).optional(),
     description: z.string().optional(),
     content: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
-    kind: z.enum(['rule', 'pattern', 'fact']).optional(),
+    kind: z.enum(['rule', 'pattern', 'fact']).nullish(),
     language: z.string().optional(),
     category: z.string().optional(),
     tags: z.array(z.string()).optional(),
 })
+    .loose()
     .refine((data) => Object.keys(data).length > 0, {
     message: 'At least one field must be provided for update',
 });
@@ -59,6 +62,10 @@ export const DeprecateKnowledgeBody = z.object({
     reason: z.string().min(1, 'reason is required'),
 });
 export const BatchPublishBody = BatchIds;
+export const BatchDeleteBody = BatchIds;
+export const BatchDeprecateBody = BatchIds.extend({
+    reason: z.string().optional(),
+});
 export const KnowledgeUsageBody = z.object({
     type: z.enum(['adoption', 'view', 'feedback']).default('adoption'),
     feedback: z.unknown().optional(),
@@ -236,6 +243,10 @@ export const ModuleBootstrapBody = z.object({
     skipGuard: z.boolean().default(false),
     contentMaxLines: z.number().int().min(1).max(10000).default(120),
 });
+export const ModuleRescanBody = z.object({
+    reason: z.string().optional(),
+    dimensions: z.array(z.string()).optional(),
+});
 // ═══ Graph Search ════════════════════════════════
 export const GraphQuery = z.object({
     nodeId: z.string().min(1, 'nodeId is required'),