autosnippet 3.3.5 → 3.3.7

package/dist/lib/infrastructure/cache/CacheCoordinator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * CacheCoordinator — 跨进程缓存失效协调器
+ *
+ * 利用 SQLite 内置的 `PRAGMA data_version` 检测其他进程的 DB 写入。
+ * 当检测到 data_version 变化时，通知所有注册的订阅者清除内存缓存。
+ *
+ * 原理：
+ *   - SQLite 的 data_version 是一个连接级别的计数器
+ *   - 当 *其他* 连接（包括其他进程）提交写事务后，当前连接的下次读操作
+ *     会看到递增的 data_version
+ *   - 通过定期轮询（默认 2s），实现近实时的跨进程缓存失效
+ *   - 开销极低：一次 pragma 读取 < 0.01ms
+ *
+ * 典型场景：
+ *   - MCP Server 冷启动写入 33 条 Recipe → HTTP Server 的 data_version 变化
+ *   - 用户 CLI 执行 `asd embed` → Dashboard API 的缓存自动失效
+ *
+ * @module infrastructure/cache/CacheCoordinator
+ */
+import type { SqliteDatabase } from '../database/DatabaseConnection.js';
+export type InvalidateHandler = () => void;
+export declare class CacheCoordinator {
+    #private;
+    constructor(db: SqliteDatabase, pollIntervalMs?: number);
+    /** 启动轮询（仅长驻进程需要：HTTP server / MCP server） */
+    start(): void;
+    /** 停止轮询 */
+    stop(): void;
+    /**
+     * 注册缓存失效回调
+     *
+     * @param name  标识名（用于日志，如 'panoramaService'）
+     * @param handler 失效时调用的清除函数
+     * @returns 取消注册函数
+     */
+    subscribe(name: string, handler: InvalidateHandler): () => void;
+    /** 当前订阅者数量（诊断用） */
+    get subscriberCount(): number;
+    /** 手动触发一次检查（测试用） */
+    check(): boolean;
+}

package/dist/lib/infrastructure/cache/CacheCoordinator.js

@@ -0,0 +1,105 @@
+/**
+ * CacheCoordinator — 跨进程缓存失效协调器
+ *
+ * 利用 SQLite 内置的 `PRAGMA data_version` 检测其他进程的 DB 写入。
+ * 当检测到 data_version 变化时，通知所有注册的订阅者清除内存缓存。
+ *
+ * 原理：
+ *   - SQLite 的 data_version 是一个连接级别的计数器
+ *   - 当 *其他* 连接（包括其他进程）提交写事务后，当前连接的下次读操作
+ *     会看到递增的 data_version
+ *   - 通过定期轮询（默认 2s），实现近实时的跨进程缓存失效
+ *   - 开销极低：一次 pragma 读取 < 0.01ms
+ *
+ * 典型场景：
+ *   - MCP Server 冷启动写入 33 条 Recipe → HTTP Server 的 data_version 变化
+ *   - 用户 CLI 执行 `asd embed` → Dashboard API 的缓存自动失效
+ *
+ * @module infrastructure/cache/CacheCoordinator
+ */
+import Logger from '../logging/Logger.js';
+export class CacheCoordinator {
+    #db;
+    #lastVersion;
+    #interval = null;
+    #subscribers = new Map();
+    #pollMs;
+    constructor(db, pollIntervalMs = 2000) {
+        this.#db = db;
+        this.#pollMs = pollIntervalMs;
+        this.#lastVersion = this.#readVersion();
+    }
+    /** 启动轮询（仅长驻进程需要：HTTP server / MCP server） */
+    start() {
+        if (this.#interval) {
+            return;
+        }
+        this.#interval = setInterval(() => this.#check(), this.#pollMs);
+        // unref 避免阻止进程正常退出
+        if (this.#interval.unref) {
+            this.#interval.unref();
+        }
+        Logger.info('[CacheCoordinator] Started', {
+            pollMs: this.#pollMs,
+            subscribers: this.#subscribers.size,
+        });
+    }
+    /** 停止轮询 */
+    stop() {
+        if (this.#interval) {
+            clearInterval(this.#interval);
+            this.#interval = null;
+        }
+    }
+    /**
+     * 注册缓存失效回调
+     *
+     * @param name  标识名（用于日志，如 'panoramaService'）
+     * @param handler 失效时调用的清除函数
+     * @returns 取消注册函数
+     */
+    subscribe(name, handler) {
+        this.#subscribers.set(name, handler);
+        return () => {
+            this.#subscribers.delete(name);
+        };
+    }
+    /** 当前订阅者数量（诊断用） */
+    get subscriberCount() {
+        return this.#subscribers.size;
+    }
+    /** 手动触发一次检查（测试用） */
+    check() {
+        return this.#check();
+    }
+    // ── 内部方法 ──────────────────────────────────────
+    #readVersion() {
+        return this.#db.pragma('data_version', { simple: true });
+    }
+    /** @returns true 如果版本变化并触发了失效 */
+    #check() {
+        const current = this.#readVersion();
+        if (current === this.#lastVersion) {
+            return false;
+        }
+        const prev = this.#lastVersion;
+        this.#lastVersion = current;
+        const names = [...this.#subscribers.keys()];
+        Logger.info('[CacheCoordinator] DB changed by another process, invalidating caches', {
+            prevVersion: prev,
+            newVersion: current,
+            targets: names,
+        });
+        for (const [name, handler] of this.#subscribers) {
+            try {
+                handler();
+            }
+            catch (err) {
+                Logger.warn(`[CacheCoordinator] Invalidation handler "${name}" threw`, {
+                    error: err.message,
+                });
+            }
+        }
+        return true;
+    }
+}

package/dist/lib/infrastructure/database/migrations/006_lifecycle_transition_events.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Migration 006 — Lifecycle Transition Events
+ *
+ * Recipe 生命周期状态转移事件日志表（Event Sourcing 模式）。
+ * 记录每次状态转移的完整审计信息，支持回溯与监控。
+ */
+export default function migrate(db: import('better-sqlite3').Database): void;

package/dist/lib/infrastructure/database/migrations/006_lifecycle_transition_events.js

@@ -0,0 +1,28 @@
+/**
+ * Migration 006 — Lifecycle Transition Events
+ *
+ * Recipe 生命周期状态转移事件日志表（Event Sourcing 模式）。
+ * 记录每次状态转移的完整审计信息，支持回溯与监控。
+ */
+export default function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS lifecycle_transition_events (
+      id            TEXT PRIMARY KEY,
+      recipe_id     TEXT NOT NULL,
+      from_state    TEXT NOT NULL,
+      to_state      TEXT NOT NULL,
+      trigger       TEXT NOT NULL,
+      operator_id   TEXT NOT NULL DEFAULT 'system',
+      evidence_json TEXT,
+      proposal_id   TEXT,
+      created_at    INTEGER NOT NULL,
+
+      FOREIGN KEY (recipe_id)   REFERENCES knowledge_entries(id),
+      FOREIGN KEY (proposal_id) REFERENCES evolution_proposals(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_lte_recipe_id  ON lifecycle_transition_events(recipe_id);
+    CREATE INDEX IF NOT EXISTS idx_lte_created_at ON lifecycle_transition_events(created_at);
+    CREATE INDEX IF NOT EXISTS idx_lte_trigger    ON lifecycle_transition_events(trigger);
+  `);
+}

package/dist/lib/infrastructure/vector/HnswVectorAdapter.js

@@ -468,7 +468,7 @@ export class HnswVectorAdapter extends VectorStore {
         }));
     }
     /**
-     * 关键词搜索 (BM25 简化版: token 匹配 + IDF 近似)
+     * 关键词搜索 (token 匹配 + IDF 近似)
      * @returns >}
      */
     #keywordSearch(queryText, limit, filter) {

package/dist/lib/injection/ServiceContainer.d.ts

@@ -32,11 +32,12 @@ export declare class ServiceContainer {
     /**
      * 热重载 AI Provider（API Key 变更后调用，无需重启进程）
      *
-     * 流程：
-     *  1. 替换 singletons.aiProvider
-     *  2. 重新创建 _embedProvider（如果主 provider 不支持 embedding）
-     *  3. 清除已缓存的依赖 AI 的 singleton（SearchEngine 等），
-     *     下次 get() 时会用新 provider 重新创建
+     * 委托给 AiProviderManager.switchProvider() — 原子操作:
+     *  1. 替换 provider 引用 + DI 数据管道同步
+     *  2. Token 追踪 AOP 重新挂载
+     *  3. Embedding fallback 重建
+     *  4. 清除已缓存的依赖 AI 的 singleton（SearchEngine 等）
+     *  5. 监听器回调通知
      */
     reloadAiProvider(newProvider: Record<string, unknown> | null): void;
     /** 获取当前默认 UI 语言偏好 */

package/dist/lib/injection/ServiceContainer.js

@@ -5,6 +5,7 @@ import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import ProjectGraph from '../core/ast/ProjectGraph.js';
 // ─── v3.1: Multi-Language Discovery + Enhancement ────────
 import { initEnhancementRegistry } from '../core/enhancement/index.js';
+import { CacheCoordinator } from '../infrastructure/cache/CacheCoordinator.js';
 import { GraphCache } from '../infrastructure/cache/GraphCache.js';
 // ─── P3: Infrastructure ──────────────────────────────
 import Logger from '../infrastructure/logging/Logger.js';
@@ -132,6 +133,8 @@ export class ServiceContainer {
             await VectorModule.initializeVectorService(this);
             // v3.4: 初始化 Knowledge 服务（绑定 EventBus → SearchEngine.refreshIndex + sourceRefs）
             KnowledgeModule.initializeKnowledgeServices(this);
+            // v3.5: 跨进程缓存协调器（利用 SQLite PRAGMA data_version 检测其他进程写入）
+            this.#initCacheCoordinator();
             this.logger.info('Service container initialized successfully');
         }
         catch (error) {
@@ -144,36 +147,72 @@ export class ServiceContainer {
     /**
      * 热重载 AI Provider（API Key 变更后调用，无需重启进程）
      *
-     * 流程：
-     *  1. 替换 singletons.aiProvider
-     *  2. 重新创建 _embedProvider（如果主 provider 不支持 embedding）
-     *  3. 清除已缓存的依赖 AI 的 singleton（SearchEngine 等），
-     *     下次 get() 时会用新 provider 重新创建
+     * 委托给 AiProviderManager.switchProvider() — 原子操作:
+     *  1. 替换 provider 引用 + DI 数据管道同步
+     *  2. Token 追踪 AOP 重新挂载
+     *  3. Embedding fallback 重建
+     *  4. 清除已缓存的依赖 AI 的 singleton（SearchEngine 等）
+     *  5. 监听器回调通知
      */
     reloadAiProvider(newProvider) {
-        const old = this.singletons.aiProvider;
-        this.singletons.aiProvider = newProvider;
-        // 重新创建 embedding fallback provider（委托 AiModule）
-        this.singletons._embedProvider = null;
-        if (newProvider &&
-            typeof newProvider.supportsEmbedding === 'function' &&
-            !newProvider.supportsEmbedding()) {
-            AiModule.initEmbeddingFallback(this);
+        if (!newProvider) {
+            this.logger.warn('[ServiceContainer] reloadAiProvider called with null — ignored');
+            return;
         }
-        // 清除持有旧 aiProvider 引用的 singleton 缓存
-        // 下次调用 container.get() 时会使用新 provider 重建
-        const cleared = [];
-        for (const key of this._aiDependentSingletons || []) {
-            if (this.singletons[key]) {
-                this.singletons[key] = null;
-                cleared.push(key);
+        const manager = this.singletons._aiProviderManager;
+        manager.switchProvider(newProvider);
+    }
+    // ─── 跨进程缓存协调 ─────
+    /**
+     * 初始化 CacheCoordinator：当其他进程写入 DB 后，自动清除本进程的内存缓存。
+     *
+     * 订阅的服务：
+     *   - panoramaService: invalidate() — 模块图 + 全景分析
+     *   - guardCheckEngine: clearCache() — 规则缓存
+     *   - searchEngine: buildIndex() — 搜索索引
+     *
+     * 仅在长驻进程（HTTP server / MCP server）中自动启动轮询。
+     * CLI 场景无需启动（进程生命周期短，缓存不会过时）。
+     */
+    #initCacheCoordinator() {
+        try {
+            const db = this.singletons.database;
+            const rawDb = db?.getDb ? db.getDb() : null;
+            if (!rawDb) {
+                return;
+            }
+            const coordinator = new CacheCoordinator(rawDb);
+            this.singletons.cacheCoordinator = coordinator;
+            this.register('cacheCoordinator', () => coordinator);
+            // 懒订阅：仅在对应服务已初始化时绑定
+            coordinator.subscribe('panoramaService', () => {
+                const svc = this.singletons.panoramaService;
+                svc?.invalidate?.();
+            });
+            coordinator.subscribe('guardCheckEngine', () => {
+                const svc = this.singletons.guardCheckEngine;
+                svc?.clearCache?.();
+            });
+            coordinator.subscribe('searchEngine', () => {
+                const svc = this.singletons.searchEngine;
+                svc?.buildIndex?.();
+            });
+            // 长驻进程自动启动轮询（CLI 不启动）
+            const isMcp = process.env.ASD_MCP_MODE === '1';
+            const isApiServer = process.env.ASD_API_SERVER === '1';
+            if (isMcp || isApiServer) {
+                coordinator.start();
             }
+            this.logger.info('CacheCoordinator initialized', {
+                subscribers: coordinator.subscriberCount,
+                polling: isMcp || isApiServer,
+            });
+        }
+        catch (err) {
+            this.logger.warn('CacheCoordinator init failed (non-blocking)', {
+                error: err.message,
+            });
         }
-        this.logger.info('AI provider hot-reloaded', {
-            old: old?.constructor?.name || 'none',
-            new: newProvider?.constructor?.name || 'none',
-            clearedSingletons: cleared,
-        });
     }
     // ─── 容器级语言偏好 ─────
     /** 获取当前默认 UI 语言偏好 */

package/dist/lib/injection/ServiceMap.d.ts

@@ -6,6 +6,7 @@
  *
  * @module ServiceMap
  */
+import type DimensionCopy from '#domain/dimension/DimensionCopy.js';
 import type { AgentFactory } from '../agent/AgentFactory.js';
 import type { ToolRegistry } from '../agent/tools/ToolRegistry.js';
 import type { KnowledgeSyncService } from '../cli/KnowledgeSyncService.js';
@@ -13,8 +14,10 @@ import type ProjectGraph from '../core/ast/ProjectGraph.js';
 import type Constitution from '../core/constitution/Constitution.js';
 import type Gateway from '../core/gateway/Gateway.js';
 import type { AiProvider } from '../external/ai/AiProvider.js';
+import type { AiProviderManager } from '../external/ai/AiProviderManager.js';
 import type AuditLogger from '../infrastructure/audit/AuditLogger.js';
 import type AuditStore from '../infrastructure/audit/AuditStore.js';
+import type { CacheCoordinator } from '../infrastructure/cache/CacheCoordinator.js';
 import type DatabaseConnection from '../infrastructure/database/DatabaseConnection.js';
 import type { EventBus } from '../infrastructure/event/EventBus.js';
 import type Logger from '../infrastructure/logging/Logger.js';
@@ -24,7 +27,6 @@ import type { VectorStore } from '../infrastructure/vector/VectorStore.js';
 import type { KnowledgeRepositoryImpl } from '../repository/knowledge/KnowledgeRepository.impl.js';
 import type { TokenUsageStore } from '../repository/token/TokenUsageStore.js';
 import type { BootstrapTaskManager } from '../service/bootstrap/BootstrapTaskManager.js';
-import type DimensionCopy from '../service/bootstrap/DimensionCopyRegistry.js';
 import type { CursorDeliveryPipeline } from '../service/delivery/CursorDeliveryPipeline.js';
 import type { ComplianceReporter } from '../service/guard/ComplianceReporter.js';
 import type { ExclusionManager } from '../service/guard/ExclusionManager.js';
@@ -97,6 +99,7 @@ export interface ServiceMap {
     dimensionCopy: typeof DimensionCopy;
     constitution: Constitution | null;
     aiProvider: AiProvider | null;
+    aiProviderManager: AiProviderManager;
     projectGraph: ProjectGraph | null;
     vectorService: VectorService;
     contextualEnricher: ContextualEnricher | null;
@@ -117,4 +120,10 @@ export interface ServiceMap {
     layerInferrer: LayerInferrer;
     panoramaAggregator: PanoramaAggregator;
     panoramaService: PanoramaService;
+    cacheCoordinator: CacheCoordinator;
+    _projectRoot: string;
+    _config: Record<string, unknown>;
+    _lang: string | null;
+    _fileCache: unknown[] | null;
+    _embedProvider: unknown;
 }

package/dist/lib/injection/modules/AiModule.d.ts

@@ -6,6 +6,7 @@
  *
  * 职责:
  *   - AI Provider 自动探测与创建
+ *   - AiProviderManager 统一管理层
  *   - Embedding fallback provider 管理
  *   - AiFactory 实例注入
  *
@@ -17,19 +18,15 @@ import type { ServiceContainer } from '../ServiceContainer.js';
  *
  * 1. 动态导入 AiFactory
  * 2. 自动探测可用 AI Provider
- * 3. 创建 Embedding fallback（若主 provider 不支持 embedding）
+ * 3. 创建 AiProviderManager（统一管理层）
+ * 4. 绑定 Token 追踪、Embedding fallback、DI 级联清理
  */
 export declare function initialize(c: ServiceContainer): Promise<void>;
-/**
- * 创建/刷新 Embedding fallback provider
- *
- * 若主 provider 不支持 embedding（如 Claude），尝试从其他可用 provider 创建备用。
- */
-export declare function initEmbeddingFallback(c: ServiceContainer): void;
 /**
  * 注册 AI 相关的服务到容器
  *
- * 当前 AI Provider 和 AiFactory 通过 singletons 直接管理，
- * 此方法注册便于其他模块通过 container.get() 获取的快捷服务。
+ * - 标记 AI 模块就绪
+ * - 注册 aiProviderManager 服务
+ * - 延迟注入 TokenRecorder（tokenUsageStore 此时已可用）
  */
 export declare function register(c: ServiceContainer): void;

package/dist/lib/injection/modules/AiModule.js

@@ -6,17 +6,20 @@
  *
  * 职责:
  *   - AI Provider 自动探测与创建
+ *   - AiProviderManager 统一管理层
  *   - Embedding fallback provider 管理
  *   - AiFactory 实例注入
  *
  * @module AiModule
  */
+import { AiProviderManager } from '../../external/ai/AiProviderManager.js';
 /**
  * 初始化 AI Provider（在模块注册前调用）
  *
  * 1. 动态导入 AiFactory
  * 2. 自动探测可用 AI Provider
- * 3. 创建 Embedding fallback（若主 provider 不支持 embedding）
+ * 3. 创建 AiProviderManager（统一管理层）
+ * 4. 绑定 Token 追踪、Embedding fallback、DI 级联清理
  */
 export async function initialize(c) {
     const logger = c.logger;
@@ -43,56 +46,96 @@ export async function initialize(c) {
             c.singletons.aiProvider = null;
         }
     }
-    // Embedding fallback provider
-    initEmbeddingFallback(c);
+    // ── 创建 AiProviderManager（统一管理层）──
+    const manager = new AiProviderManager(c.singletons.aiProvider || { name: 'mock', model: 'mock-fallback' });
+    c.singletons._aiProviderManager = manager;
+    // 绑定: DI 数据管道同步（切换时更新 singletons 中的 provider 引用，供工厂函数读取）
+    manager._bindDiSync((provider, embed) => {
+        c.singletons.aiProvider = provider;
+        c.singletons._embedProvider = embed;
+    });
+    // 绑定: DI 级联清理回调
+    manager._bindDependentClearer(() => {
+        const cleared = [];
+        for (const key of c._aiDependentSingletons || []) {
+            if (c.singletons[key]) {
+                c.singletons[key] = null;
+                cleared.push(key);
+            }
+        }
+        return cleared;
+    });
+    // 绑定: Embedding fallback 初始化器
+    manager._bindEmbedFallbackInit((currentProvider) => {
+        return createEmbedFallback(c, currentProvider);
+    });
+    // Token 追踪 AOP（manager 自身已在构造时 wire，此处延迟注入 recorder）
+    // recorder 注入放到 register() 之后（tokenUsageStore 需先注册）
+    // Embedding fallback: manager 的 embedFallbackInit 回调已绑定，初始化时主动触发一次
+    const initialEmbed = createEmbedFallback(c, c.singletons.aiProvider);
+    if (initialEmbed) {
+        manager.setEmbedProvider(initialEmbed);
+        c.singletons._embedProvider = initialEmbed;
+    }
 }
 /**
- * 创建/刷新 Embedding fallback provider
- *
- * 若主 provider 不支持 embedding（如 Claude），尝试从其他可用 provider 创建备用。
+ * 纯函数: 尝试为给定 provider 创建 Embedding fallback
+ * 被 initEmbeddingFallback() 和 AiProviderManager 的 embedFallbackInit 回调共用
  */
-export function initEmbeddingFallback(c) {
-    const currentProvider = c.singletons.aiProvider;
-    if ((currentProvider &&
-        typeof currentProvider
-            .supportsEmbedding !== 'function') ||
-        (currentProvider &&
-            !currentProvider.supportsEmbedding?.())) {
-        try {
-            const aiFactory = (c.singletons._aiFactory || {});
-            const providerName = (currentProvider?.name || '').replace('-', '');
-            const fbCandidates = typeof aiFactory.getAvailableFallbacks === 'function'
-                ? aiFactory.getAvailableFallbacks(providerName)
-                : [];
-            for (const fb of fbCandidates) {
-                try {
-                    const fbProvider = aiFactory.createProvider({ provider: fb });
-                    if (typeof fbProvider.supportsEmbedding === 'function' &&
-                        fbProvider.supportsEmbedding()) {
-                        c.singletons._embedProvider = fbProvider;
-                        c.logger.info('Embedding fallback provider created', { provider: fb });
-                        break;
-                    }
-                }
-                catch {
-                    /* skip */
+function createEmbedFallback(c, currentProvider) {
+    if (!currentProvider ||
+        (typeof currentProvider.supportsEmbedding === 'function' && currentProvider.supportsEmbedding())) {
+        return null; // 主 provider 已支持 embedding，无需 fallback
+    }
+    try {
+        const aiFactory = (c.singletons._aiFactory || {});
+        const providerName = (currentProvider.name || '').replace('-', '');
+        const fbCandidates = typeof aiFactory.getAvailableFallbacks === 'function'
+            ? aiFactory.getAvailableFallbacks(providerName)
+            : [];
+        for (const fb of fbCandidates) {
+            try {
+                const fbProvider = aiFactory.createProvider?.({ provider: fb });
+                if (fbProvider &&
+                    typeof fbProvider.supportsEmbedding === 'function' &&
+                    fbProvider.supportsEmbedding()) {
+                    c.logger.info('Embedding fallback provider created', { provider: fb });
+                    return fbProvider;
                 }
             }
-        }
-        catch {
-            /* no embed fallback available */
+            catch {
+                /* skip */
+            }
         }
     }
+    catch {
+        /* no embed fallback available */
+    }
+    return null;
 }
 /**
  * 注册 AI 相关的服务到容器
  *
- * 当前 AI Provider 和 AiFactory 通过 singletons 直接管理，
- * 此方法注册便于其他模块通过 container.get() 获取的快捷服务。
+ * - 标记 AI 模块就绪
+ * - 注册 aiProviderManager 服务
+ * - 延迟注入 TokenRecorder（tokenUsageStore 此时已可用）
  */
 export function register(c) {
-    // aiProvider 和 _aiFactory 已通过 initialize() 写入 singletons
-    // KnowledgeModule 中已注册 'aiProvider' 的 register 工厂
-    // 此处仅标记 AI 模块已就绪
     c.singletons._aiModuleReady = true;
+    // 注册 aiProviderManager（消费者通过 container.get('aiProviderManager') 获取）
+    c.register('aiProviderManager', () => c.singletons._aiProviderManager);
+    // 延迟注入 TokenRecorder 到 manager（tokenUsageStore 在 AppModule 中注册）
+    const manager = c.singletons._aiProviderManager;
+    const containerRef = c;
+    manager.setTokenRecorder({
+        record(r) {
+            try {
+                const store = containerRef.get('tokenUsageStore');
+                store.record(r);
+            }
+            catch {
+                /* tokenUsageStore not available yet */
+            }
+        },
+    });
 }

package/dist/lib/injection/modules/KnowledgeModule.js

@@ -7,6 +7,7 @@
  *   - discovererRegistry, enhancementRegistry, languageService, dimensionCopy
  *   - constitution, aiProvider, projectGraph
  */
+import { DimensionCopy } from '#domain/dimension/DimensionCopy.js';
 import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import { getDiscovererRegistry } from '../../core/discovery/index.js';
 import { getEnhancementRegistry } from '../../core/enhancement/index.js';
@@ -14,13 +15,14 @@ import { HnswVectorAdapter } from '../../infrastructure/vector/HnswVectorAdapter
 import { IndexingPipeline } from '../../infrastructure/vector/IndexingPipeline.js';
 import { JsonVectorAdapter } from '../../infrastructure/vector/JsonVectorAdapter.js';
 import { ProposalRepository } from '../../repository/evolution/ProposalRepository.js';
-import { DimensionCopy } from '../../service/bootstrap/DimensionCopyRegistry.js';
 import { ConsolidationAdvisor } from '../../service/evolution/ConsolidationAdvisor.js';
+import { ContentPatcher } from '../../service/evolution/ContentPatcher.js';
 import { ContradictionDetector } from '../../service/evolution/ContradictionDetector.js';
 import { DecayDetector } from '../../service/evolution/DecayDetector.js';
 import { EnhancementSuggester } from '../../service/evolution/EnhancementSuggester.js';
 import { KnowledgeMetabolism } from '../../service/evolution/KnowledgeMetabolism.js';
 import { ProposalExecutor } from '../../service/evolution/ProposalExecutor.js';
+import { RecipeLifecycleSupervisor } from '../../service/evolution/RecipeLifecycleSupervisor.js';
 import { RedundancyAnalyzer } from '../../service/evolution/RedundancyAnalyzer.js';
 import { StagingManager } from '../../service/evolution/StagingManager.js';
 import { CodeEntityGraph } from '../../service/knowledge/CodeEntityGraph.js';
@@ -184,10 +186,22 @@ export function register(c) {
         const db = ct.get('database');
         return new ProposalRepository(db.getDb());
     });
+    c.singleton('contentPatcher', (ct) => {
+        const db = ct.get('database');
+        return new ContentPatcher(db.getDb());
+    });
+    c.singleton('lifecycleSupervisor', (ct) => {
+        const db = ct.get('database');
+        return new RecipeLifecycleSupervisor(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
     c.singleton('proposalExecutor', (ct) => {
         const db = ct.get('database');
         return new ProposalExecutor(db.getDb(), ct.get('proposalRepository'), {
             signalBus: ct.singletons.signalBus || undefined,
+            contentPatcher: ct.get('contentPatcher'),
+            supervisor: ct.get('lifecycleSupervisor'),
         });
     });
     c.singleton('consolidationAdvisor', (ct) => {

package/dist/lib/injection/modules/PanoramaModule.js

@@ -32,7 +32,7 @@ export const PanoramaModule = {
         ct.singleton('roleRefiner', () => new RoleRefiner(getDb(), getProjectRoot()));
         ct.singleton('couplingAnalyzer', () => new CouplingAnalyzer(getDb(), getProjectRoot()));
         ct.singleton('layerInferrer', () => new LayerInferrer());
-        ct.singleton('dimensionAnalyzer', () => new DimensionAnalyzer(getDb()));
+        ct.singleton('dimensionAnalyzer', () => new DimensionAnalyzer(getDb(), getProjectRoot()));
         ct.singleton('panoramaAggregator', (c) => {
             const sc = c;
             const roleRefiner = sc.get('roleRefiner');

package/dist/lib/repository/knowledge/KnowledgeRepository.impl.d.ts

@@ -40,6 +40,10 @@ export declare class KnowledgeRepositoryImpl extends BaseRepository {
      * ★ Drizzle 类型安全 INSERT — 列名拼写编译期检查
      */
     create(entry: KnowledgeEntry): Promise<unknown>;
+    /**
+     * 按标题精确查找（大小写不敏感）
+     */
+    findByTitle(title: string): Promise<KnowledgeEntry | null>;
     /**
      * 更新 KnowledgeEntry（接受完整实体或部分数据）
      * ★ Drizzle 类型安全 UPDATE