autosnippet 3.2.15 → 3.2.17

package/dist/lib/service/knowledge/KnowledgeFileWriter.d.ts

@@ -24,77 +24,54 @@ export declare class KnowledgeFileWriter {
     logger: ReturnType<typeof Logger.getInstance>;
     projectRoot: string;
     recipesDir: string;
-    /**
-     * @param {string} projectRoot 项目根目录
-     */
+    /** @param projectRoot 项目根目录 */
     constructor(projectRoot: string);
-    /**
-     * 将 KnowledgeEntry 序列化为完整 .md（YAML frontmatter + body）
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string}
-     */
+    /** 将 KnowledgeEntry 序列化为完整 .md（YAML frontmatter + body） */
     serialize(entry: KnowledgeEntry): string;
-    /**
-     * 构建 Markdown body
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string}
-     */
+    /** 构建 Markdown body */
     _buildBody(entry: KnowledgeEntry): string;
     /**
      * 将 KnowledgeEntry 落盘到对应目录
      * - isCandidate() → AutoSnippet/candidates/{category}/
      * - isActive()/deprecated → AutoSnippet/recipes/{category}/
      *
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string|null} 写入的文件路径，失败返回 null
+     * @returns 写入的文件路径，失败返回 null
      */
     persist(entry: KnowledgeEntry): string | null;
-    /**
-     * 删除 KnowledgeEntry 对应的 .md 文件
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {boolean}
-     */
+    /** 删除 KnowledgeEntry 对应的 .md 文件 */
     remove(entry: KnowledgeEntry): boolean;
     /**
      * 当 lifecycle 切换时，移动 .md 文件到正确目录
      * candidates/ ↔ recipes/
      *
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string|null} 新的文件路径
+     * @returns 新的文件路径
      */
     moveOnLifecycleChange(entry: KnowledgeEntry): string | null;
     /**
      * 计算文件存储路径
-     * @returns {{ dir: string, filename: string }}
+     * @returns }
      */
     _resolveFilePath(entry: KnowledgeEntry): {
         dir: string;
         filename: string;
     };
-    /**
-     * 清理旧文件（category 变更或 lifecycle 切换场景）
-     */
+    /** 清理旧文件（category 变更或 lifecycle 切换场景） */
     _cleanupOldFile(entry: KnowledgeEntry, newPath: string): void;
-    /**
-     * 通过 id 扫描所有 .md 文件来删除
-     * @returns {boolean}
-     */
+    /** 通过 id 扫描所有 .md 文件来删除 */
     _removeByIdScan(id: string): boolean;
 }
 /**
  * 计算 .md 内容的 SHA-256 hash（去除 _content_hash 行后）
- * @param {string} content
- * @returns {string} 16 字符 hex
+ * @returns 16 字符 hex
  */
 export declare function computeKnowledgeHash(content: string): string;
 /**
  * 从 .md 内容解析为 wire format JSON
  * 返回值可直接 KnowledgeEntry.fromJSON(data) 构造实体
  *
- * @param {string} content  .md 文件全文
- * @param {string} [relPath]  相对路径（用于溯源）
- * @returns {Object} wire format JSON
+ * @param content .md 文件全文
+ * @param [relPath] 相对路径（用于溯源）
+ * @returns wire format JSON
  */
 export declare function parseKnowledgeMarkdown(content: string, relPath?: string): Record<string, unknown>;
 export default KnowledgeFileWriter;
-//# sourceMappingURL=KnowledgeFileWriter.d.ts.map

package/dist/lib/service/knowledge/KnowledgeFileWriter.js

@@ -65,9 +65,7 @@ export class KnowledgeFileWriter {
     logger;
     projectRoot;
     recipesDir;
-    /**
-     * @param {string} projectRoot 项目根目录
-     */
+    /** @param projectRoot 项目根目录 */
     constructor(projectRoot) {
         this.projectRoot = projectRoot;
         this.recipesDir = path.join(projectRoot, RECIPES_DIR);
@@ -75,11 +73,7 @@ export class KnowledgeFileWriter {
         this.logger = Logger.getInstance();
     }
     /* ═══ 序列化 ═══════════════════════════════════════════ */
-    /**
-     * 将 KnowledgeEntry 序列化为完整 .md（YAML frontmatter + body）
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string}
-     */
+    /** 将 KnowledgeEntry 序列化为完整 .md（YAML frontmatter + body） */
     serialize(entry) {
         const json = entry.toJSON();
         const lines = ['---'];
@@ -145,11 +139,7 @@ export class KnowledgeFileWriter {
         const hash = computeKnowledgeHash(cleanedForHash);
         return md.replace(hashPlaceholder, hash);
     }
-    /**
-     * 构建 Markdown body
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string}
-     */
+    /** 构建 Markdown body */
     _buildBody(entry) {
         const c = entry.content;
         const lines = [];
@@ -230,8 +220,7 @@ export class KnowledgeFileWriter {
      * - isCandidate() → AutoSnippet/candidates/{category}/
      * - isActive()/deprecated → AutoSnippet/recipes/{category}/
      *
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string|null} 写入的文件路径，失败返回 null
+     * @returns 写入的文件路径，失败返回 null
      */
     persist(entry) {
         try {
@@ -267,11 +256,7 @@ export class KnowledgeFileWriter {
             return null;
         }
     }
-    /**
-     * 删除 KnowledgeEntry 对应的 .md 文件
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {boolean}
-     */
+    /** 删除 KnowledgeEntry 对应的 .md 文件 */
     remove(entry) {
         if (!entry?.id) {
             return false;
@@ -311,8 +296,7 @@ export class KnowledgeFileWriter {
      * 当 lifecycle 切换时，移动 .md 文件到正确目录
      * candidates/ ↔ recipes/
      *
-     * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
-     * @returns {string|null} 新的文件路径
+     * @returns 新的文件路径
      */
     moveOnLifecycleChange(entry) {
         const oldPath = entry.sourceFile ? path.join(this.projectRoot, entry.sourceFile) : null;
@@ -337,7 +321,7 @@ export class KnowledgeFileWriter {
     /* ═══ 内部工具 ═══════════════════════════════════════════ */
     /**
      * 计算文件存储路径
-     * @returns {{ dir: string, filename: string }}
+     * @returns }
      */
     _resolveFilePath(entry) {
         const baseDir = entry.isCandidate() ? this.candidatesDir : this.recipesDir;
@@ -346,9 +330,7 @@ export class KnowledgeFileWriter {
         const filename = _slugFilename(entry.trigger, entry.title, entry.id);
         return { dir, filename };
     }
-    /**
-     * 清理旧文件（category 变更或 lifecycle 切换场景）
-     */
+    /** 清理旧文件（category 变更或 lifecycle 切换场景） */
     _cleanupOldFile(entry, newPath) {
         if (!entry.sourceFile) {
             return;
@@ -393,10 +375,7 @@ export class KnowledgeFileWriter {
             oldPath: entry.sourceFile,
         });
     }
-    /**
-     * 通过 id 扫描所有 .md 文件来删除
-     * @returns {boolean}
-     */
+    /** 通过 id 扫描所有 .md 文件来删除 */
     _removeByIdScan(id) {
         for (const baseDir of [this.candidatesDir, this.recipesDir]) {
             if (!fs.existsSync(baseDir)) {
@@ -421,8 +400,7 @@ export class KnowledgeFileWriter {
  * ═══════════════════════════════════════════════════════════ */
 /**
  * 计算 .md 内容的 SHA-256 hash（去除 _content_hash 行后）
- * @param {string} content
- * @returns {string} 16 字符 hex
+ * @returns 16 字符 hex
  */
 export function computeKnowledgeHash(content) {
     const cleaned = content.replace(/^_contentHash:.*\n?/m, '').trim();
@@ -432,9 +410,9 @@ export function computeKnowledgeHash(content) {
  * 从 .md 内容解析为 wire format JSON
  * 返回值可直接 KnowledgeEntry.fromJSON(data) 构造实体
  *
- * @param {string} content  .md 文件全文
- * @param {string} [relPath]  相对路径（用于溯源）
- * @returns {Object} wire format JSON
+ * @param content .md 文件全文
+ * @param [relPath] 相对路径（用于溯源）
+ * @returns wire format JSON
  */
 export function parseKnowledgeMarkdown(content, relPath) {
     const fmMatch = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
@@ -582,10 +560,7 @@ export function parseKnowledgeMarkdown(content, relPath) {
 /* ═══ 私有辅助 ═══════════════════════════════════════════ */
 /**
  * 生成文件名 slug
- * @param {string} trigger
- * @param {string} title
- * @param {string} id
- * @returns {string} 文件名（含 .md 后缀）
+ * @returns 文件名（含 .md 后缀）
  */
 function _slugFilename(trigger, title, id) {
     // 优先用 trigger
@@ -614,9 +589,7 @@ function _slugFilename(trigger, title, id) {
     // 最后用 id 前 8 位
     return `${(id || 'unknown').slice(0, 8)}.md`;
 }
-/**
- * 将 YAML 值安全序列化
- */
+/** 将 YAML 值安全序列化 */
 function _yamlValue(key, val) {
     if (typeof val === 'number' || typeof val === 'boolean') {
         return String(val);
@@ -628,10 +601,7 @@ function _yamlValue(key, val) {
     }
     return str;
 }
-/**
- * 递归扫描目录，删除包含指定 id 的 .md 文件
- * @returns {boolean}
- */
+/** 递归扫描目录，删除包含指定 id 的 .md 文件 */
 function _walkAndRemoveById(dir, id) {
     if (!fs.existsSync(dir)) {
         return false;
@@ -655,4 +625,3 @@ function _walkAndRemoveById(dir, id) {
     return false;
 }
 export default KnowledgeFileWriter;
-//# sourceMappingURL=KnowledgeFileWriter.js.map

package/dist/lib/service/knowledge/KnowledgeGraphService.d.ts

@@ -47,9 +47,7 @@ export declare class KnowledgeGraphService {
     db: DbLike;
     logger: ReturnType<typeof Logger.getInstance>;
     constructor(db: DbLike);
-    /**
-     * 添加关系边
-     */
+    /** 添加关系边 */
     addEdge(fromId: string, fromType: string, toId: string, toType: string, relation: string, metadata?: Record<string, unknown>): {
         success: boolean;
         error?: undefined;
@@ -57,24 +55,16 @@ export declare class KnowledgeGraphService {
         success: boolean;
         error: string;
     };
-    /**
-     * 删除关系边
-     */
+    /** 删除关系边 */
     removeEdge(fromId: string, fromType: string, toId: string, toType: string, relation: string): void;
-    /**
-     * 查询某个节点的所有关系
-     */
+    /** 查询某个节点的所有关系 */
     getEdges(nodeId: string, nodeType: string, direction?: string): {
         outgoing: MappedEdge[];
         incoming: MappedEdge[];
     };
-    /**
-     * 查询指定关系类型的连接
-     */
+    /** 查询指定关系类型的连接 */
     getRelated(nodeId: string, nodeType: string, relation: string): MappedEdge[];
-    /**
-     * 查找两个节点之间的路径 (BFS, 最大深度 5)
-     */
+    /** 查找两个节点之间的路径 (BFS, 最大深度 5) */
     findPath(fromId: string, fromType: string, toId: string, toType: string, maxDepth?: number): {
         found: boolean;
         path: {
@@ -90,16 +80,10 @@ export declare class KnowledgeGraphService {
         }[];
         depth: number;
     };
-    /**
-     * 获取节点的影响范围（下游依赖分析）
-     */
+    /** 获取节点的影响范围（下游依赖分析） */
     getImpactAnalysis(nodeId: string, nodeType: string, maxDepth?: number): any[];
-    /**
-     * 获取图谱整体统计
-     */
-    /**
-     * @param {string} [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
-     */
+    /** 获取图谱整体统计 */
+    /** @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部 */
     getStats(nodeType?: string): {
         totalEdges: number;
         byRelation: {
@@ -109,8 +93,8 @@ export declare class KnowledgeGraphService {
     };
     /**
      * 获取全量边（供 Dashboard 图谱可视化）
-     * @param {number} [limit=500] 最大返回条数
-     * @param {string} [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
+     * @param [limit=500] 最大返回条数
+     * @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
      */
     getAllEdges(limit?: number, nodeType?: string): MappedEdge[];
     _mapEdge(row: EdgeRow): MappedEdge;
@@ -118,4 +102,3 @@ export declare class KnowledgeGraphService {
 export declare function initKnowledgeGraphService(db: DbLike): KnowledgeGraphService;
 export declare function getKnowledgeGraphService(): KnowledgeGraphService | null;
 export default KnowledgeGraphService;
-//# sourceMappingURL=KnowledgeGraphService.d.ts.map

package/dist/lib/service/knowledge/KnowledgeGraphService.js

@@ -15,9 +15,7 @@ export class KnowledgeGraphService {
         this.db = typeof db?.getDb === 'function' ? db.getDb() : db;
         this.logger = Logger.getInstance();
     }
-    /**
-     * 添加关系边
-     */
+    /** 添加关系边 */
     addEdge(fromId, fromType, toId, toType, relation, metadata = {}) {
         const now = Math.floor(Date.now() / 1000);
         try {
@@ -35,9 +33,7 @@ export class KnowledgeGraphService {
             return { success: false, error: errMsg };
         }
     }
-    /**
-     * 删除关系边
-     */
+    /** 删除关系边 */
     removeEdge(fromId, fromType, toId, toType, relation) {
         this.db
             .prepare(`
@@ -45,9 +41,7 @@ export class KnowledgeGraphService {
     `)
             .run(fromId, fromType, toId, toType, relation);
     }
-    /**
-     * 查询某个节点的所有关系
-     */
+    /** 查询某个节点的所有关系 */
     getEdges(nodeId, nodeType, direction = 'both') {
         const outgoing = direction === 'both' || direction === 'out'
             ? this.db
@@ -64,9 +58,7 @@ export class KnowledgeGraphService {
             incoming: incoming.map((row) => this._mapEdge(row)),
         };
     }
-    /**
-     * 查询指定关系类型的连接
-     */
+    /** 查询指定关系类型的连接 */
     getRelated(nodeId, nodeType, relation) {
         const rows = this.db
             .prepare(`
@@ -77,9 +69,7 @@ export class KnowledgeGraphService {
             .all(nodeId, nodeType, relation, nodeId, nodeType, relation);
         return rows.map((row) => this._mapEdge(row));
     }
-    /**
-     * 查找两个节点之间的路径 (BFS, 最大深度 5)
-     */
+    /** 查找两个节点之间的路径 (BFS, 最大深度 5) */
     findPath(fromId, fromType, toId, toType, maxDepth = 5) {
         const visited = new Set();
         const queue = [
@@ -125,9 +115,7 @@ export class KnowledgeGraphService {
             depth: -1,
         };
     }
-    /**
-     * 获取节点的影响范围（下游依赖分析）
-     */
+    /** 获取节点的影响范围（下游依赖分析） */
     getImpactAnalysis(nodeId, nodeType, maxDepth = 3) {
         const impacted = new Map();
         const queue = [{ id: nodeId, type: nodeType, depth: 0 }];
@@ -157,12 +145,8 @@ export class KnowledgeGraphService {
         }
         return Array.from(impacted.values());
     }
-    /**
-     * 获取图谱整体统计
-     */
-    /**
-     * @param {string} [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
-     */
+    /** 获取图谱整体统计 */
+    /** @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部 */
     getStats(nodeType) {
         const typeFilter = nodeType
             ? ` WHERE from_type = '${nodeType}' AND to_type = '${nodeType}'`
@@ -186,8 +170,8 @@ export class KnowledgeGraphService {
     }
     /**
      * 获取全量边（供 Dashboard 图谱可视化）
-     * @param {number} [limit=500] 最大返回条数
-     * @param {string} [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
+     * @param [limit=500] 最大返回条数
+     * @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
      */
     getAllEdges(limit = 500, nodeType) {
         let sql, params;
@@ -227,4 +211,3 @@ export function getKnowledgeGraphService() {
     return instance;
 }
 export default KnowledgeGraphService;
-//# sourceMappingURL=KnowledgeGraphService.js.map

package/dist/lib/service/knowledge/KnowledgeService.d.ts

@@ -68,17 +68,6 @@ export declare class KnowledgeService {
     gateway: unknown;
     logger: ReturnType<typeof Logger.getInstance>;
     repository: KnowledgeRepository;
-    /**
-     * @param {import('../../domain/knowledge/KnowledgeRepository.js').KnowledgeRepository} repository
-     * @param {object} auditLogger
-     * @param {object} gateway
-     * @param {object} knowledgeGraphService
-     * @param {object} [options]
-     * @param {import('./KnowledgeFileWriter.js').KnowledgeFileWriter} [options.fileWriter]
-     * @param {import('../skills/SkillHooks.js').SkillHooks} [options.skillHooks]
-     * @param {import('./ConfidenceRouter.js').ConfidenceRouter} [options.confidenceRouter]
-     * @param {import('../quality/QualityScorer.js').QualityScorer} [options.qualityScorer]
-     */
     constructor(repository: KnowledgeRepository, auditLogger: AuditLoggerLike, gateway: unknown, knowledgeGraphService: KnowledgeGraphService | null, options?: KnowledgeServiceOptions);
     /**
      * 创建知识条目
@@ -87,51 +76,37 @@ export declare class KnowledgeService {
      * 所有新条目初始状态为 pending（待审核）。
      * ConfidenceRouter 仅标记 auto_approvable 标志，不改变 lifecycle。
      *
-     * @param {Object} data - wire format 数据
-     * @param {Object} context - { userId }
-     * @returns {Promise<KnowledgeEntry>}
+     * @param data wire format 数据
+     * @param context { userId }
      */
     create(data: KnowledgeEntryProps, context: ServiceContext): Promise<KnowledgeEntry>;
-    /**
-     * 获取单个知识条目
-     * @param {string} id
-     * @returns {Promise<KnowledgeEntry>}
-     */
+    /** 获取单个知识条目 */
     get(id: string): Promise<KnowledgeEntry>;
     /**
      * 更新知识条目（仅允许白名单字段）
-     * @param {string} id
-     * @param {Object} data 部分字段（camelCase）
-     * @param {Object} context - { userId }
-     * @returns {Promise<KnowledgeEntry>}
+     * @param data 部分字段（camelCase）
+     * @param context { userId }
      */
     update(id: string, data: Partial<KnowledgeEntryProps>, context: ServiceContext): Promise<KnowledgeEntry>;
     /**
      * 删除知识条目
-     * @param {string} id
-     * @param {Object} context - { userId }
-     * @returns {Promise<{ success: boolean, id: string }>}
+     * @param context { userId }
+     * @returns >}
      */
     delete(id: string, context: ServiceContext): Promise<{
         success: boolean;
         id: string;
     }>;
-    /**
-     * 发布 (pending → active) — 仅开发者可执行
-     */
+    /** 发布 (pending → active) — 仅开发者可执行 */
     publish(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
     /**
      * 触发 Cursor Delivery Pipeline（非阻塞、容错）
      * @private
      */
     _triggerCursorDeliveryAsync(): void;
-    /**
-     * 弃用 (pending|active → deprecated)
-     */
+    /** 弃用 (pending|active → deprecated) */
     deprecate(id: string, reason: string, context: ServiceContext): Promise<KnowledgeEntry>;
-    /**
-     * 重新激活 (deprecated → pending)
-     */
+    /** 重新激活 (deprecated → pending) */
     reactivate(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
     /** @deprecated 简化后所有条目直接进 pending */
     submit(id: string, _context: ServiceContext): Promise<KnowledgeEntry>;
@@ -147,27 +122,19 @@ export declare class KnowledgeService {
     fastTrack(id: string, context: ServiceContext): Promise<KnowledgeEntry>;
     /**
      * 查询列表
-     * @param {Object} filters - { lifecycle, kind, language, category, knowledgeType, source, tag }
-     * @param {Object} pagination - { page, pageSize }
+     * @param filters { lifecycle, kind, language, category, knowledgeType, source, tag }
+     * @param pagination { page, pageSize }
      */
     list(filters?: ListFilters, pagination?: PaginationOptions): Promise<import("../../domain/knowledge/KnowledgeRepository.js").PaginatedResult>;
-    /**
-     * 按 Kind 查询
-     */
+    /** 按 Kind 查询 */
     listByKind(kind: string, pagination?: PaginationOptions): Promise<import("../../domain/knowledge/KnowledgeRepository.js").PaginatedResult>;
-    /**
-     * 搜索
-     */
+    /** 搜索 */
     search(keyword: string, pagination?: PaginationOptions): Promise<import("../../domain/knowledge/KnowledgeRepository.js").PaginatedResult>;
-    /**
-     * 获取统计信息
-     */
+    /** 获取统计信息 */
     getStats(): Promise<Record<string, unknown>>;
     /**
      * 增加使用计数
-     * @param {string} id
-     * @param {'adoption'|'application'|'guard_hit'|'view'|'success'} type
-     * @param {Object} [options] - { actor, feedback }
+     * @param [options] { actor, feedback }
      */
     incrementUsage(id: string, type?: string, options?: {
         actor?: string;
@@ -175,27 +142,20 @@ export declare class KnowledgeService {
     }): Promise<KnowledgeEntry>;
     /**
      * 更新质量评分
-     * @param {string} id
-     * @param {Object} [context] - { userId }
+     * @param [context] { userId }
      */
     updateQuality(id: string, context?: Partial<ServiceContext>): Promise<{
         score: number;
         dimensions: Record<string, number>;
         grade: string;
     }>;
-    /**
-     * 统一生命周期转换编排
-     */
+    /** 统一生命周期转换编排 */
     _lifecycleTransition(id: string, method: string, context: ServiceContext, options?: {
         entityArgs?: unknown[];
     }): Promise<KnowledgeEntry>;
-    /**
-     * 查找或抛出 NotFoundError
-     */
+    /** 查找或抛出 NotFoundError */
     _findOrThrow(id: string): Promise<KnowledgeEntry>;
-    /**
-     * 验证创建输入
-     */
+    /** 验证创建输入 */
     _validateCreateInput(data: KnowledgeEntryProps): void;
     /**
      * 为 QualityScorer 适配输入
@@ -204,27 +164,18 @@ export declare class KnowledgeService {
     _adaptForScorer(entry: KnowledgeEntry): Record<string, unknown>;
     /**
      * 自动发现同 category/moduleName/tags 的已有条目并建立 'related' 边
-     * @param {string} id 新创建的条目 ID
-     * @param {KnowledgeEntry} entry 条目实体
+     * @param id 新创建的条目 ID
+     * @param entry 条目实体
      */
     _autoDiscoverRelations(id: string, entry: KnowledgeEntry): Promise<void>;
-    /**
-     * 将 relations 同步到 knowledge_edges 表
-     */
+    /** 将 relations 同步到 knowledge_edges 表 */
     _syncRelationsToGraph(id: string, relations: unknown): void;
-    /**
-     * 删除所有关联边
-     */
+    /** 删除所有关联边 */
     _removeAllEdges(id: string): void;
-    /**
-     * 落盘到 .md 文件 + 回写 sourceFile
-     */
+    /** 落盘到 .md 文件 + 回写 sourceFile */
     _persistToFile(entry: KnowledgeEntry): void;
-    /**
-     * 删除 .md 文件
-     */
+    /** 删除 .md 文件 */
     _removeFile(entry: KnowledgeEntry): void;
     _audit(action: string, id: string, actor: string, details?: Record<string, unknown> | string): Promise<void>;
 }
 export default KnowledgeService;
-//# sourceMappingURL=KnowledgeService.d.ts.map