autosnippet 3.3.4 → 3.3.6

package/dist/lib/http/routes/knowledge.js

@@ -5,7 +5,7 @@
  */
 import express from 'express';
 import { ioLimit } from '#shared/concurrency.js';
-import { BatchPublishBody, CreateKnowledgeBody, DeprecateKnowledgeBody, KnowledgeUsageBody, UpdateKnowledgeBody, } from '#shared/schemas/http-requests.js';
+import { BatchDeleteBody, BatchDeprecateBody, BatchPublishBody, CreateKnowledgeBody, DeprecateKnowledgeBody, KnowledgeUsageBody, UpdateKnowledgeBody, } from '#shared/schemas/http-requests.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getServiceContainer } from '../../injection/ServiceContainer.js';
 import { validate } from '../middleware/validate.js';
@@ -140,6 +140,28 @@ router.get('/lifecycle', async (req, res) => {
     }
     res.json({ success: true, data: lifecycle });
 });
+/**
+ * POST /api/v1/knowledge/quality/refresh-all
+ * 批量重新计算所有条目的质量评分
+ */
+router.post('/quality/refresh-all', async (_req, res) => {
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const result = await knowledgeService.list({}, { page: 1, pageSize: 10000 });
+    const all = result.data;
+    let updated = 0;
+    let failed = 0;
+    for (const entry of all) {
+        try {
+            await knowledgeService.updateQuality(entry.id);
+            updated++;
+        }
+        catch {
+            failed++;
+        }
+    }
+    res.json({ success: true, data: { updated, failed, total: all.length } });
+});
 /**
  * GET /api/v1/knowledge/:id
  * 获取知识条目详情
@@ -229,6 +251,54 @@ router.patch('/:id/reactivate', requirePermission('knowledge', 'update'), async
     const entry = await knowledgeService.reactivate(id, context);
     res.json({ success: true, data: sanitizeForAPI(entry) });
 });
+/**
+ * PATCH /api/v1/knowledge/:id/stage
+ * 暂存 (pending → staging)
+ */
+router.patch('/:id/stage', requirePermission('knowledge', 'update'), async (req, res) => {
+    const id = String(req.params.id);
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const context = getContext(req);
+    const entry = await knowledgeService.stage(id, context);
+    res.json({ success: true, data: sanitizeForAPI(entry) });
+});
+/**
+ * PATCH /api/v1/knowledge/:id/evolve
+ * 进化 (active → evolving)
+ */
+router.patch('/:id/evolve', requirePermission('knowledge', 'update'), async (req, res) => {
+    const id = String(req.params.id);
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const context = getContext(req);
+    const entry = await knowledgeService.evolve(id, context);
+    res.json({ success: true, data: sanitizeForAPI(entry) });
+});
+/**
+ * PATCH /api/v1/knowledge/:id/decay
+ * 衰退 (active|evolving → decaying)
+ */
+router.patch('/:id/decay', requirePermission('knowledge', 'update'), async (req, res) => {
+    const id = String(req.params.id);
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const context = getContext(req);
+    const entry = await knowledgeService.decay(id, context);
+    res.json({ success: true, data: sanitizeForAPI(entry) });
+});
+/**
+ * PATCH /api/v1/knowledge/:id/restore
+ * 恢复为已发布 (decaying|evolving → active)
+ */
+router.patch('/:id/restore', requirePermission('knowledge', 'update'), async (req, res) => {
+    const id = String(req.params.id);
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const context = getContext(req);
+    const entry = await knowledgeService.restore(id, context);
+    res.json({ success: true, data: sanitizeForAPI(entry) });
+});
 /* ═══ 批量操作 ═══════════════════════════════════════════ */
 /**
  * POST /api/v1/knowledge/batch-publish
@@ -258,6 +328,57 @@ router.post('/batch-publish', requirePermission('knowledge', 'publish'), validat
         },
     });
 });
+/**
+ * POST /api/v1/knowledge/batch-delete
+ * 批量删除知识条目
+ */
+router.post('/batch-delete', requirePermission('knowledge', 'delete'), validate(BatchDeleteBody), async (req, res) => {
+    const { ids } = req.body;
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const context = getContext(req);
+    const results = await Promise.allSettled(ids.map((id) => ioLimit(() => knowledgeService.delete(id, context))));
+    const deleted = results.filter((r) => r.status === 'fulfilled').length;
+    const failed = results
+        .map((r, i) => (r.status === 'rejected' ? { id: ids[i], error: r.reason?.message } : null))
+        .filter(Boolean);
+    res.json({
+        success: true,
+        data: {
+            total: ids.length,
+            deletedCount: deleted,
+            failureCount: failed.length,
+            failed,
+        },
+    });
+});
+/**
+ * POST /api/v1/knowledge/batch-deprecate
+ * 批量废弃知识条目 (active → deprecated)
+ */
+router.post('/batch-deprecate', requirePermission('knowledge', 'publish'), validate(BatchDeprecateBody), async (req, res) => {
+    const { ids, reason } = req.body;
+    const container = getServiceContainer();
+    const knowledgeService = container.get('knowledgeService');
+    const context = getContext(req);
+    const results = await Promise.allSettled(ids.map((id) => ioLimit(() => knowledgeService.deprecate(id, reason || 'batch deprecate', context))));
+    const deprecated = results
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => sanitizeForAPI(r.value));
+    const failed = results
+        .map((r, i) => (r.status === 'rejected' ? { id: ids[i], error: r.reason?.message } : null))
+        .filter(Boolean);
+    res.json({
+        success: true,
+        data: {
+            deprecated,
+            failed,
+            total: ids.length,
+            successCount: deprecated.length,
+            failureCount: failed.length,
+        },
+    });
+});
 /* ═══ 使用 / 质量 ═══════════════════════════════════════ */
 /**
  * POST /api/v1/knowledge/:id/usage

package/dist/lib/http/routes/modules.js

@@ -5,7 +5,7 @@
  * 所有端点通过 container.get('moduleService') 获取 ModuleService 实例
  */
 import express from 'express';
-import { ModuleBootstrapBody, ScanFolderBody, ScanProjectBody, ScanTargetBody, } from '#shared/schemas/http-requests.js';
+import { ModuleBootstrapBody, ModuleRescanBody, ScanFolderBody, ScanProjectBody, ScanTargetBody, } from '#shared/schemas/http-requests.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getServiceContainer } from '../../injection/ServiceContainer.js';
 import { validate } from '../middleware/validate.js';
@@ -416,14 +416,17 @@ router.get('/project-info', async (req, res) => {
 router.post('/bootstrap', validate(ModuleBootstrapBody), async (req, res) => {
     const { maxFiles, skipGuard, contentMaxLines } = req.body || {};
     const container = getServiceContainer();
-    const agentFactory = container.get('agentFactory');
     logger.info('Bootstrap cold start initiated (ModuleService path)');
-    const bootstrapResult = await agentFactory.bootstrapKnowledge({
+    // 直接调用 bootstrap-internal handler（统一编排管线）
+    const { bootstrapKnowledge } = await import('#external/mcp/handlers/bootstrap-internal.js');
+    const raw = await bootstrapKnowledge({ container, logger }, {
         maxFiles: maxFiles || 500,
         skipGuard: skipGuard || false,
         contentMaxLines: contentMaxLines || 120,
         loadSkills: true,
     });
+    const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    const bootstrapResult = parsed?.data || parsed;
     res.json({
         success: true,
         data: {
@@ -456,4 +459,23 @@ router.get('/bootstrap/status', async (req, res) => {
         data: taskManager.getSessionStatus(),
     });
 });
+/**
+ * POST /api/v1/modules/rescan
+ * 增量扫描：保留已有 Recipe，重新分析项目，补齐缺失知识
+ * 使用内部 Agent pipeline 自动完成知识补齐
+ */
+router.post('/rescan', validate(ModuleRescanBody), async (req, res) => {
+    const { reason, dimensions } = req.body || {};
+    const container = getServiceContainer();
+    logger.info('Rescan (internal) initiated from Dashboard', { reason, dimensions });
+    // 直接调用 rescan-internal handler（统一编排管线）
+    const { rescanInternal } = await import('#external/mcp/handlers/rescan-internal.js');
+    const raw = await rescanInternal({ container, logger }, { reason: reason || 'dashboard-rescan', dimensions });
+    const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    const result = parsed?.data || parsed;
+    res.json({
+        success: true,
+        data: result,
+    });
+});
 export default router;

package/dist/lib/http/routes/panorama.js

@@ -14,7 +14,7 @@ const router = express.Router();
  * GET /api/v1/panorama
  * 返回项目全景概览（层级、模块、覆盖率）
  */
-router.get('/', async (_req, res) => {
+router.get('/', async (req, res) => {
     try {
         const container = getServiceContainer();
         const panoramaService = container.get('panoramaService');
@@ -25,6 +25,9 @@ router.get('/', async (_req, res) => {
             });
             return;
         }
+        if (req.query.refresh === 'true' && typeof panoramaService.invalidate === 'function') {
+            panoramaService.invalidate();
+        }
         if (typeof panoramaService.ensureData === 'function') {
             await panoramaService.ensureData();
         }
@@ -42,7 +45,7 @@ router.get('/', async (_req, res) => {
  * GET /api/v1/panorama/health
  * 返回全景健康度评分
  */
-router.get('/health', async (_req, res) => {
+router.get('/health', async (req, res) => {
     try {
         const container = getServiceContainer();
         const panoramaService = container.get('panoramaService');
@@ -53,6 +56,9 @@ router.get('/health', async (_req, res) => {
             });
             return;
         }
+        if (req.query.refresh === 'true' && typeof panoramaService.invalidate === 'function') {
+            panoramaService.invalidate();
+        }
         if (typeof panoramaService.ensureData === 'function') {
             await panoramaService.ensureData();
         }
@@ -70,7 +76,7 @@ router.get('/health', async (_req, res) => {
  * GET /api/v1/panorama/gaps
  * 返回知识空白区列表
  */
-router.get('/gaps', async (_req, res) => {
+router.get('/gaps', async (req, res) => {
     try {
         const container = getServiceContainer();
         const panoramaService = container.get('panoramaService');
@@ -81,6 +87,9 @@ router.get('/gaps', async (_req, res) => {
             });
             return;
         }
+        if (req.query.refresh === 'true' && typeof panoramaService.invalidate === 'function') {
+            panoramaService.invalidate();
+        }
         if (typeof panoramaService.ensureData === 'function') {
             await panoramaService.ensureData();
         }
@@ -98,7 +107,7 @@ router.get('/gaps', async (_req, res) => {
  * GET /api/v1/panorama/coverage
  * 返回各模块知识覆盖率热力图数据
  */
-router.get('/coverage', async (_req, res) => {
+router.get('/coverage', async (req, res) => {
     try {
         const container = getServiceContainer();
         const panoramaService = container.get('panoramaService');
@@ -109,6 +118,9 @@ router.get('/coverage', async (_req, res) => {
             });
             return;
         }
+        if (req.query.refresh === 'true' && typeof panoramaService.invalidate === 'function') {
+            panoramaService.invalidate();
+        }
         if (typeof panoramaService.ensureData === 'function') {
             await panoramaService.ensureData();
         }

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.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) {
@@ -175,6 +178,58 @@ export class ServiceContainer {
             clearedSingletons: cleared,
         });
     }
+    // ─── 跨进程缓存协调 ─────
+    /**
+     * 初始化 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,
+            });
+        }
+    }
     // ─── 容器级语言偏好 ─────
     /** 获取当前默认 UI 语言偏好 */
     getLang() {

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';
@@ -15,6 +16,7 @@ import type Gateway from '../core/gateway/Gateway.js';
 import type { AiProvider } from '../external/ai/AiProvider.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 +26,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';
@@ -117,4 +118,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/InfraModule.js

@@ -65,7 +65,10 @@ export function register(c) {
     });
     c.singleton('knowledgeSyncService', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
-        return new KnowledgeSyncService(projectRoot);
+        const sourceRefReconciler = ct.singletons.sourceRefReconciler;
+        return new KnowledgeSyncService(projectRoot, {
+            sourceRefReconciler: sourceRefReconciler || undefined,
+        });
     });
     // ═══ ReportStore ═══
     c.singleton('reportStore', (ct) => {