autosnippet 3.3.0 → 3.3.3

package/dist/lib/repository/knowledge/KnowledgeRepository.impl.js

@@ -200,7 +200,10 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
         SELECT
           COUNT(*) as total,
           SUM(CASE WHEN lifecycle = 'pending' THEN 1 ELSE 0 END) as pending,
+          SUM(CASE WHEN lifecycle = 'staging' THEN 1 ELSE 0 END) as staging,
           SUM(CASE WHEN lifecycle = 'active' THEN 1 ELSE 0 END) as active,
+          SUM(CASE WHEN lifecycle = 'evolving' THEN 1 ELSE 0 END) as evolving,
+          SUM(CASE WHEN lifecycle = 'decaying' THEN 1 ELSE 0 END) as decaying,
           SUM(CASE WHEN lifecycle = 'deprecated' THEN 1 ELSE 0 END) as deprecated,
           SUM(CASE WHEN kind = 'rule' THEN 1 ELSE 0 END) as rules,
           SUM(CASE WHEN kind = 'pattern' THEN 1 ELSE 0 END) as patterns,
@@ -238,6 +241,8 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             // SQLite INTEGER → boolean
             autoApprovable: !!row.autoApprovable,
             includeHeaders: !!row.includeHeaders,
+            // Staging support
+            stagingDeadline: row.staging_deadline || null,
         });
     }
     /** KnowledgeEntry → DB Row (camelCase 列名 = 属性名，直传) */
@@ -287,6 +292,7 @@ export class KnowledgeRepositoryImpl extends BaseRepository {
             updatedAt: e.updatedAt || now,
             publishedAt: e.publishedAt || null,
             publishedBy: e.publishedBy || null,
+            staging_deadline: e.stagingDeadline || null,
         };
     }
     /**

package/dist/lib/service/bootstrap/BootstrapTaskManager.d.ts

@@ -18,6 +18,7 @@
  *   bootstrap:all-completed — 全部任务完成
  */
 import type { EventBus } from '../../infrastructure/event/EventBus.js';
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
 interface TaskMeta {
     type?: string;
     dimId?: string;
@@ -40,6 +41,7 @@ interface TaskDef {
 }
 interface BootstrapTaskManagerOpts {
     eventBus?: EventBus | null;
+    signalBus?: SignalBus | null;
     getRealtimeService?: (() => {
         broadcastEvent(name: string, data: unknown): void;
     } | null) | null;
@@ -96,7 +98,7 @@ declare class BootstrapSession {
 }
 export declare class BootstrapTaskManager {
     #private;
-    constructor({ eventBus, getRealtimeService }?: BootstrapTaskManagerOpts);
+    constructor({ eventBus, signalBus, getRealtimeService }?: BootstrapTaskManagerOpts);
     /**
      * 启动新的 bootstrap 会话
      *

package/dist/lib/service/bootstrap/BootstrapTaskManager.js

@@ -118,10 +118,12 @@ class BootstrapSession {
 export class BootstrapTaskManager {
     #currentSession = null;
     #eventBus = null;
+    #signalBus = null;
     /** 获取 RealtimeService 的 getter（延迟获取，避免循环依赖） */
     #getRealtimeService = null;
-    constructor({ eventBus, getRealtimeService } = {}) {
+    constructor({ eventBus, signalBus, getRealtimeService } = {}) {
         this.#eventBus = eventBus || null;
+        this.#signalBus = signalBus || null;
         this.#getRealtimeService = getRealtimeService || null;
     }
     // ═══════════════════════════════════════════════════════════
@@ -197,6 +199,15 @@ export class BootstrapTaskManager {
                 error: t.error,
             })),
         });
+        this.#signalBus?.send('lifecycle', 'Bootstrap', 0.3, {
+            metadata: {
+                action: 'bootstrap_aborted',
+                sessionId: session.id,
+                reason,
+                completed: session.completedTasks,
+                failed: session.failedTasks,
+            },
+        });
     }
     /**
      * 验证 sessionId 是否仍然是活跃 session
@@ -350,6 +361,14 @@ export class BootstrapTaskManager {
                 error: t.error,
             })),
         });
+        this.#signalBus?.send('lifecycle', 'Bootstrap', 1, {
+            metadata: {
+                action: 'bootstrap_completed',
+                sessionId: session.id,
+                completed: session.completedTasks,
+                failed: session.failedTasks,
+            },
+        });
     }
     /** 发射事件到 EventBus + 推送到前端 Socket.io */
     #emit(eventName, data) {

package/dist/lib/service/bootstrap/UiStartupTasks.d.ts

@@ -0,0 +1,45 @@
+/**
+ * UiStartupTasks — asd ui 启动后异步后台刷新任务
+ *
+ * 在 Dashboard 启动后异步执行，不阻塞 UI:
+ *   1. syncAll:          .md → DB 全量同步 + sourceRefs 对账
+ *   2. staging promote:  到期 staging → active 晋升
+ *   3. vector reconcile: 向量对账（best-effort）
+ *   4. refreshIndex:     BM25 增量刷新
+ */
+interface UiStartupContext {
+    projectRoot: string;
+    container: {
+        get(name: string): unknown;
+        services: Record<string, unknown>;
+        singletons: Record<string, unknown>;
+    };
+}
+export interface UiStartupReport {
+    syncAll?: {
+        synced: number;
+        created: number;
+        updated: number;
+    };
+    reconcile?: {
+        inserted: number;
+        active: number;
+        stale: number;
+    };
+    staging?: {
+        promoted: number;
+    };
+    vectorReconcile?: {
+        orphans: number;
+        missing: number;
+    };
+    indexRefresh?: boolean;
+    durationMs: number;
+    errors: string[];
+}
+/**
+ * 异步执行所有启动后台任务。
+ * 每个阶段独立 try/catch，一个失败不影响后续。
+ */
+export declare function runUiStartupTasks(ctx: UiStartupContext): Promise<UiStartupReport>;
+export {};

package/dist/lib/service/bootstrap/UiStartupTasks.js

@@ -0,0 +1,101 @@
+/**
+ * UiStartupTasks — asd ui 启动后异步后台刷新任务
+ *
+ * 在 Dashboard 启动后异步执行，不阻塞 UI:
+ *   1. syncAll:          .md → DB 全量同步 + sourceRefs 对账
+ *   2. staging promote:  到期 staging → active 晋升
+ *   3. vector reconcile: 向量对账（best-effort）
+ *   4. refreshIndex:     BM25 增量刷新
+ */
+import Logger from '../../infrastructure/logging/Logger.js';
+const logger = Logger.getInstance();
+/**
+ * 异步执行所有启动后台任务。
+ * 每个阶段独立 try/catch，一个失败不影响后续。
+ */
+export async function runUiStartupTasks(ctx) {
+    const start = Date.now();
+    const report = { durationMs: 0, errors: [] };
+    logger.info('[UiStartupTasks] Starting background refresh...');
+    // ── Stage 1: syncAll (.md → DB + sourceRefs reconcile) ──
+    try {
+        const { KnowledgeSyncService } = await import('../../cli/KnowledgeSyncService.js');
+        const syncService = new KnowledgeSyncService(ctx.projectRoot);
+        const db = ctx.container.get('database');
+        const rawDb = db.getDb();
+        const syncReport = await syncService.syncAll(rawDb, { skipViolations: true });
+        report.syncAll = {
+            synced: syncReport.synced,
+            created: syncReport.created,
+            updated: syncReport.updated,
+        };
+        if (syncReport.reconcileReport) {
+            report.reconcile = {
+                inserted: syncReport.reconcileReport.inserted,
+                active: syncReport.reconcileReport.active,
+                stale: syncReport.reconcileReport.stale,
+            };
+        }
+        logger.info('[UiStartupTasks] Stage 1 complete: syncAll', report.syncAll);
+    }
+    catch (err) {
+        const msg = `syncAll failed: ${err.message}`;
+        report.errors.push(msg);
+        logger.warn(`[UiStartupTasks] ${msg}`);
+    }
+    // ── Stage 2: Staging auto-promotion (Bug 2 fix) ──
+    try {
+        if (ctx.container.services.stagingManager) {
+            const sm = ctx.container.get('stagingManager');
+            const result = sm.checkAndPromote();
+            report.staging = { promoted: result.promoted.length };
+            if (result.promoted.length > 0) {
+                logger.info(`[UiStartupTasks] Stage 2: auto-promoted ${result.promoted.length} staging entries`);
+            }
+        }
+    }
+    catch (err) {
+        const msg = `staging promote failed: ${err.message}`;
+        report.errors.push(msg);
+        logger.warn(`[UiStartupTasks] ${msg}`);
+    }
+    // ── Stage 3: Vector reconcile (best-effort) ──
+    try {
+        if (ctx.container.services.vectorService) {
+            const vectorService = ctx.container.get('vectorService');
+            if (vectorService.syncCoordinator &&
+                typeof vectorService.syncCoordinator.reconcile === 'function') {
+                const result = await vectorService.syncCoordinator.reconcile();
+                report.vectorReconcile = {
+                    orphans: result.orphansRemoved,
+                    missing: result.missingQueued,
+                };
+                logger.info('[UiStartupTasks] Stage 3: vector reconcile complete', report.vectorReconcile);
+            }
+        }
+    }
+    catch (err) {
+        const msg = `vector reconcile failed: ${err.message}`;
+        report.errors.push(msg);
+        logger.warn(`[UiStartupTasks] ${msg}`);
+    }
+    // ── Stage 4: BM25 index refresh ──
+    try {
+        if (ctx.container.services.searchEngine) {
+            const searchEngine = ctx.container.get('searchEngine');
+            searchEngine.refreshIndex({ force: true });
+            report.indexRefresh = true;
+            logger.info('[UiStartupTasks] Stage 4: BM25 index refreshed');
+        }
+    }
+    catch (err) {
+        const msg = `index refresh failed: ${err.message}`;
+        report.errors.push(msg);
+        logger.warn(`[UiStartupTasks] ${msg}`);
+    }
+    report.durationMs = Date.now() - start;
+    logger.info(`[UiStartupTasks] All tasks completed in ${report.durationMs}ms`, {
+        errors: report.errors.length,
+    });
+    return report;
+}

package/dist/lib/service/delivery/AgentInstructionsGenerator.js

@@ -44,16 +44,15 @@ const MCP_TOOLS_SUMMARY = [
         name: 'autosnippet_submit_knowledge',
         desc: 'Submit a knowledge candidate (strict validation)',
     },
-    {
-        name: 'autosnippet_submit_knowledge_batch',
-        desc: 'Batch submit candidates (with dedup + throttle)',
-    },
     { name: 'autosnippet_guard', desc: 'Code compliance check (single file or batch audit)' },
     { name: 'autosnippet_structure', desc: 'Project structure discovery (targets/files/metadata)' },
     { name: 'autosnippet_graph', desc: 'Knowledge graph query (query/impact/path/stats)' },
     { name: 'autosnippet_skill', desc: 'Skill management (list/load/create/update/delete)' },
-    { name: 'autosnippet_save_document', desc: 'Save development document (auto-publish)' },
     { name: 'autosnippet_bootstrap', desc: 'Project cold-start & scan' },
+    {
+        name: 'autosnippet_panorama',
+        desc: 'Project panorama (operation: overview/module/gaps/health)',
+    },
     { name: 'autosnippet_health', desc: 'Service health & KB statistics' },
     { name: 'autosnippet_capabilities', desc: 'List all available MCP tools (self-discovery)' },
 ];

package/dist/lib/service/delivery/CursorDeliveryPipeline.d.ts

@@ -157,7 +157,9 @@ export declare class CursorDeliveryPipeline {
         };
     }>;
     /**
-     * 加载知识条目（active + high-confidence pending）
+     * 加载知识条目（active + staging + high-confidence pending）
+     *
+     * M2 六态状态机: staging/active/evolving 均为 CONSUMABLE 状态
      */
     _loadEntries(): Promise<KnowledgeEntryProps[]>;
     /**

package/dist/lib/service/delivery/CursorDeliveryPipeline.js

@@ -137,24 +137,27 @@ export class CursorDeliveryPipeline {
     }
     // ─── 内部方法 ───────────────────────────────────────
     /**
-     * 加载知识条目（active + high-confidence pending）
+     * 加载知识条目（active + staging + high-confidence pending）
+     *
+     * M2 六态状态机: staging/active/evolving 均为 CONSUMABLE 状态
      */
     async _loadEntries() {
         const allEntries = [];
-        // 加载 active
-        try {
-            const active = await this.knowledgeService.list({ lifecycle: 'active' }, { page: 1, pageSize: 200 });
-            const activeItems = this._extractItems(active);
-            allEntries.push(...activeItems);
-        }
-        catch (e) {
-            this.logger.warn?.(`[CursorDelivery] Failed to load active entries: ${e.message}`);
+        // 加载 active + staging + evolving（CONSUMABLE 状态）
+        for (const state of ['active', 'staging', 'evolving']) {
+            try {
+                const result = await this.knowledgeService.list({ lifecycle: state }, { page: 1, pageSize: 200 });
+                const items = this._extractItems(result);
+                allEntries.push(...items);
+            }
+            catch (e) {
+                this.logger.warn?.(`[CursorDelivery] Failed to load ${state} entries: ${e.message}`);
+            }
         }
         // 加载 pending（高置信度的也纳入）
         try {
             const pending = await this.knowledgeService.list({ lifecycle: 'pending' }, { page: 1, pageSize: 200 });
             const pendingItems = this._extractItems(pending);
-            // 过滤高置信度 pending（quality.confidence >= PENDING_MIN 或无 quality 字段）
             const highConfPending = pendingItems.filter((e) => {
                 const qual = e.quality;
                 const conf = qual?.confidence;

package/dist/lib/service/delivery/RulesGenerator.js

@@ -173,9 +173,10 @@ export class RulesGenerator {
             '',
             '- `autosnippet_bootstrap` — Cold-start: analyze the project and generate initial knowledge entries',
             '- `autosnippet_search({ query })` — Search knowledge base (BM25 + semantic)',
-            '- `autosnippet_create_recipe` — Create a new coding recipe from current context',
+            '- `autosnippet_submit_knowledge` — Submit a knowledge candidate (strict validation)',
             '- `autosnippet_guard` — Run compliance review on current changes',
-            '- `autosnippet_task_start` / `autosnippet_task_close` — Track coding tasks with automatic knowledge capture',
+            '- `autosnippet_task` — Task & decision management (prime/create/claim/close/record_decision)',
+            '- `autosnippet_panorama` — Project panorama (overview/module/gaps/health)',
             '',
             '## Recommended First Steps',
             '',

package/dist/lib/service/evolution/ConsolidationAdvisor.d.ts

@@ -0,0 +1,114 @@
+/**
+ * ConsolidationAdvisor — 提交前融合顾问
+ *
+ * 解决问题：Agent 逐条提交 Recipe 导致碎片化、低价值条目激增。
+ *
+ * 设计思路：在新知识提交前分析已有知识库，给出 4 种建议之一：
+ *   create       — 独立有价值，正常新建（走正常可信度判断）
+ *   merge        — 与 1 条 Recipe 相似，将候选内容合并到已有 Recipe，合并后 Recipe → staging
+ *   reorganize   — 与多条 Recipe 交叉重叠，将候选功能拆分到已有 Recipe 上，被修改的 Recipe → staging
+ *   insufficient — 独立价值不足且已有足够 Recipe 覆盖，交给 Agent 与开发者决定
+ *
+ * 分析维度：
+ *   1. 结构相似度 — 复用 RedundancyAnalyzer 的 4 维算法
+ *   2. 语义域覆盖 — category + trigger 是否落在已有 Recipe 管辖范围
+ *   3. 独立价值   — 内容长度、具体性、是否有独立 coreCode
+ */
+interface DatabaseLike {
+    prepare(sql: string): {
+        all(...params: unknown[]): Record<string, unknown>[];
+    };
+}
+/** 提交候选的必要字段 */
+export interface CandidateForConsolidation {
+    title: string;
+    description?: string;
+    doClause?: string;
+    dontClause?: string;
+    coreCode?: string;
+    category?: string;
+    trigger?: string;
+    whenClause?: string;
+    kind?: string;
+    content?: {
+        pattern?: string;
+        markdown?: string;
+        [key: string]: unknown;
+    };
+}
+/** 建议类型 */
+export type ConsolidationAction = 'create' | 'merge' | 'reorganize' | 'insufficient';
+/** 融合方向分析 — 描述候选能为已有 Recipe 补充什么 */
+export interface MergeDirection {
+    /** 候选提供的新维度（已有 Recipe 缺失的） */
+    addedDimensions: string[];
+    /** 融合建议摘要 */
+    summary: string;
+}
+/** 融合分析结果 */
+export interface ConsolidationAdvice {
+    action: ConsolidationAction;
+    confidence: number;
+    reason: string;
+    /** action=merge 时，将候选内容合并到的目标 Recipe */
+    targetRecipe?: {
+        id: string;
+        title: string;
+        similarity: number;
+    };
+    /** action=merge 时，候选能为目标 Recipe 补充的新维度 */
+    mergeDirection?: MergeDirection;
+    /** action=reorganize 时，需要重新组织的 Recipe 列表 */
+    reorganizeTargets?: {
+        id: string;
+        title: string;
+        similarity: number;
+    }[];
+    /** action=insufficient 时，已覆盖该领域的 Recipe */
+    coveredBy?: {
+        id: string;
+        title: string;
+        similarity: number;
+    }[];
+    /** 需要 Agent 关注的上下文 */
+    relatedRecipes?: {
+        id: string;
+        title: string;
+        similarity: number;
+    }[];
+}
+/** 批量分析结果 — 每个候选一条分析 + 批次内重叠检测 */
+export interface BatchConsolidationResult {
+    items: {
+        index: number;
+        advice: ConsolidationAdvice;
+    }[];
+    /** 批次内部候选之间的重叠 */
+    internalOverlaps: {
+        indexA: number;
+        indexB: number;
+        similarity: number;
+    }[];
+}
+export declare class ConsolidationAdvisor {
+    #private;
+    constructor(db: DatabaseLike);
+    /**
+     * 分析候选知识与现有知识库的关系，返回融合建议。
+     *
+     * @param candidate - 待提交的候选数据
+     * @returns ConsolidationAdvice — 建议 + 理由 + 上下文
+     */
+    analyze(candidate: CandidateForConsolidation): ConsolidationAdvice;
+    /**
+     * 批量分析候选知识与现有知识库的关系。
+     *
+     * 除了对每个候选独立运行 analyze() 外，
+     * 还检测批次内部候选之间的重叠（防止批量提交碎片化）。
+     *
+     * @param candidates - 待提交的候选数组
+     * @returns BatchConsolidationResult — 每条分析 + 批次内重叠
+     */
+    analyzeBatch(candidates: CandidateForConsolidation[]): BatchConsolidationResult;
+}
+export {};