autosnippet 3.2.22 → 3.3.2

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

@@ -2,18 +2,13 @@
  * AppModule — 应用层杂项服务注册
  *
  * 负责注册:
- *   - recipeParser, recipeCandidateValidator, snippetFactory, snippetInstaller
+ *   - recipeParser, recipeCandidateValidator
  *   - qualityScorer, feedbackCollector, tokenUsageStore, recipeExtractor
- *   - spmService, automationOrchestrator, moduleService
- *   - cursorDeliveryPipeline
- *   - taskIdGenerator, taskReadyEngine, taskKnowledgeBridge, taskGraphService
+ *   - moduleService, cursorDeliveryPipeline
+ *   - primeSearchPipeline (for prime multi-query search — no DB dependency)
  */
 import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
-import { TaskIdGenerator } from '../../domain/task/TaskIdGenerator.js';
-import { XcodeCodec } from '../../platform/ios/snippet/XcodeCodec.js';
-import { SpmHelper } from '../../platform/ios/spm/SpmHelper.js';
 import { TokenUsageStore } from '../../repository/token/TokenUsageStore.js';
-import { AutomationOrchestrator } from '../../service/automation/AutomationOrchestrator.js';
 import { CursorDeliveryPipeline } from '../../service/delivery/CursorDeliveryPipeline.js';
 import { RecipeExtractor } from '../../service/knowledge/RecipeExtractor.js';
 import { ModuleService } from '../../service/module/ModuleService.js';
@@ -21,12 +16,7 @@ import { FeedbackCollector } from '../../service/quality/FeedbackCollector.js';
 import { QualityScorer } from '../../service/quality/QualityScorer.js';
 import { RecipeCandidateValidator } from '../../service/recipe/RecipeCandidateValidator.js';
 import { RecipeParser } from '../../service/recipe/RecipeParser.js';
-import { VSCodeCodec } from '../../service/snippet/codecs/VSCodeCodec.js';
-import { SnippetFactory } from '../../service/snippet/SnippetFactory.js';
-import { SnippetInstaller } from '../../service/snippet/SnippetInstaller.js';
-import { TaskGraphService } from '../../service/task/TaskGraphService.js';
-import { TaskKnowledgeBridge } from '../../service/task/TaskKnowledgeBridge.js';
-import { TaskReadyEngine } from '../../service/task/TaskReadyEngine.js';
+import { PrimeSearchPipeline } from '../../service/task/PrimeSearchPipeline.js';
 export function register(c) {
     // ═══ Quality + Recipe ═══
     c.singleton('qualityScorer', () => new QualityScorer());
@@ -41,27 +31,7 @@ export function register(c) {
         const db = ct.get('database');
         return new TokenUsageStore(db.getDb(), db.getDrizzle());
     });
-    // ═══ Snippet ═══
-    c.singleton('snippetFactory', (ct) => {
-        const factory = new SnippetFactory(ct.get('knowledgeRepository'));
-        factory.registerCodec(new XcodeCodec());
-        factory.registerCodec(new VSCodeCodec());
-        return factory;
-    });
-    c.singleton('snippetInstaller', (ct) => {
-        const factory = ct.get('snippetFactory');
-        return new SnippetInstaller({ codec: factory.getCodec('xcode'), snippetFactory: factory });
-    });
-    c.singleton('vscodeSnippetInstaller', (ct) => {
-        const factory = ct.get('snippetFactory');
-        return new SnippetInstaller({ codec: factory.getCodec('vscode'), snippetFactory: factory });
-    });
-    // ═══ Platform + Automation ═══
-    c.singleton('spmService', (ct) => {
-        const projectRoot = resolveProjectRoot(ct);
-        return new SpmHelper(projectRoot);
-    });
-    c.singleton('automationOrchestrator', () => new AutomationOrchestrator());
+    // ═══ Module ═══
     c.singleton('moduleService', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
         return new ModuleService(projectRoot, {
@@ -79,14 +49,8 @@ export function register(c) {
         database: ct.get('database'),
         logger: ct.logger,
     }));
-    // ═══ TaskGraph ═══
-    c.singleton('taskIdGenerator', (ct) => {
-        const db = ct.get('database');
-        return new TaskIdGenerator(db.getDb(), db.getDrizzle());
-    });
-    c.singleton('taskReadyEngine', (ct) => new TaskReadyEngine(ct.get('database').getDb()));
-    c.singleton('taskKnowledgeBridge', (ct) => new TaskKnowledgeBridge(ct.get('searchEngine')));
-    c.singleton('taskGraphService', (ct) => new TaskGraphService(ct.get('taskRepository'), ct.get('taskReadyEngine'), ct.get('taskKnowledgeBridge'), ct.get('auditLogger'), ct.get('taskIdGenerator')));
+    // ═══ PrimeSearchPipeline (for prime multi-query search) ═══
+    c.singleton('primeSearchPipeline', (ct) => new PrimeSearchPipeline(ct.get('searchEngine')));
 }
 /** 初始化 RecipeExtractor 实例 (在 initialize 期间调用) */
 export function initRecipeExtractor(c) {

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

@@ -10,10 +10,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import { ComplianceReporter } from '../../service/guard/ComplianceReporter.js';
+import { CoverageAnalyzer } from '../../service/guard/CoverageAnalyzer.js';
 import { ExclusionManager } from '../../service/guard/ExclusionManager.js';
 import { GuardCheckEngine } from '../../service/guard/GuardCheckEngine.js';
 import { GuardFeedbackLoop } from '../../service/guard/GuardFeedbackLoop.js';
 import { GuardService } from '../../service/guard/GuardService.js';
+import { ReverseGuard } from '../../service/guard/ReverseGuard.js';
 import { RuleLearner } from '../../service/guard/RuleLearner.js';
 import { ViolationsStore } from '../../service/guard/ViolationsStore.js';
 export function register(c) {
@@ -61,7 +63,10 @@ export function register(c) {
             const proj = Array.isArray(projectGuard.disabledRules) ? projectGuard.disabledRules : [];
             merged.disabledRules = [...new Set([...base, ...proj])];
         }
-        return new GuardCheckEngine(ct.get('database'), { guardConfig: merged });
+        return new GuardCheckEngine(ct.get('database'), {
+            guardConfig: merged,
+            signalBus: ct.singletons.signalBus || undefined,
+        });
     });
     c.singleton('exclusionManager', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
@@ -69,7 +74,9 @@ export function register(c) {
     });
     c.singleton('ruleLearner', (ct) => {
         const projectRoot = resolveProjectRoot(ct);
-        return new RuleLearner(projectRoot);
+        return new RuleLearner(projectRoot, {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
     });
     c.singleton('violationsStore', (ct) => {
         const db = ct.get('database');
@@ -81,5 +88,23 @@ export function register(c) {
     });
     c.singleton('guardFeedbackLoop', (ct) => new GuardFeedbackLoop(ct.get('violationsStore'), ct.get('feedbackCollector'), {
         guardCheckEngine: ct.get('guardCheckEngine'),
+        signalBus: ct.singletons.signalBus || undefined,
     }));
+    c.singleton('reverseGuard', (ct) => {
+        const db = ct.get('database');
+        return new ReverseGuard(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('coverageAnalyzer', (ct) => {
+        const db = ct.get('database');
+        let ruleLearner;
+        try {
+            ruleLearner = { ruleLearner: ct.get('ruleLearner') };
+        }
+        catch {
+            /* ruleLearner not yet available */
+        }
+        return new CoverageAnalyzer(db.getDb(), ruleLearner);
+    });
 }

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

@@ -5,7 +5,6 @@
  *   - database, logger, auditStore, auditLogger
  *   - gateway, eventBus, bootstrapTaskManager
  *   - knowledgeRepository, knowledgeFileWriter, knowledgeSyncService
- *   - taskRepository
  */
 import type { ServiceContainer } from '../ServiceContainer.js';
 export declare function register(c: ServiceContainer): void;

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

@@ -5,8 +5,8 @@
  *   - database, logger, auditStore, auditLogger
  *   - gateway, eventBus, bootstrapTaskManager
  *   - knowledgeRepository, knowledgeFileWriter, knowledgeSyncService
- *   - taskRepository
  */
+import path from 'node:path';
 import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import { KnowledgeSyncService } from '../../cli/KnowledgeSyncService.js';
 import Gateway from '../../core/gateway/Gateway.js';
@@ -15,8 +15,8 @@ import AuditStore from '../../infrastructure/audit/AuditStore.js';
 import { EventBus } from '../../infrastructure/event/EventBus.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getRealtimeService as _getRealtimeService } from '../../infrastructure/realtime/RealtimeService.js';
+import { ReportStore } from '../../infrastructure/report/ReportStore.js';
 import { KnowledgeRepositoryImpl } from '../../repository/knowledge/KnowledgeRepository.impl.js';
-import { TaskRepositoryImpl } from '../../repository/task/TaskRepository.impl.js';
 import { BootstrapTaskManager } from '../../service/bootstrap/BootstrapTaskManager.js';
 import { KnowledgeFileWriter } from '../../service/knowledge/KnowledgeFileWriter.js';
 export function register(c) {
@@ -33,7 +33,9 @@ export function register(c) {
         const drizzle = db.getDrizzle();
         return new AuditStore(db, drizzle);
     });
-    c.singleton('auditLogger', (ct) => new AuditLogger(ct.get('auditStore')));
+    c.singleton('auditLogger', (ct) => new AuditLogger(ct.get('auditStore'), ct.services.eventBus
+        ? ct.get('eventBus')
+        : null));
     c.singleton('gateway', () => new Gateway());
     c.singleton('eventBus', () => new EventBus({ maxListeners: 30 }));
     c.singleton('bootstrapTaskManager', (ct) => {
@@ -65,9 +67,9 @@ export function register(c) {
         const projectRoot = resolveProjectRoot(ct);
         return new KnowledgeSyncService(projectRoot);
     });
-    c.singleton('taskRepository', (ct) => {
-        const db = ct.get('database');
-        const drizzle = db.getDrizzle();
-        return new TaskRepositoryImpl(db, drizzle);
+    // ═══ ReportStore ═══
+    c.singleton('reportStore', (ct) => {
+        const projectRoot = resolveProjectRoot(ct);
+        return new ReportStore(path.join(projectRoot, '.autosnippet', 'logs', 'reports'));
     });
 }

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

@@ -14,6 +14,13 @@ import { HnswVectorAdapter } from '../../infrastructure/vector/HnswVectorAdapter
 import { IndexingPipeline } from '../../infrastructure/vector/IndexingPipeline.js';
 import { JsonVectorAdapter } from '../../infrastructure/vector/JsonVectorAdapter.js';
 import { DimensionCopy } from '../../service/bootstrap/DimensionCopyRegistry.js';
+import { ConsolidationAdvisor } from '../../service/evolution/ConsolidationAdvisor.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 { RedundancyAnalyzer } from '../../service/evolution/RedundancyAnalyzer.js';
+import { StagingManager } from '../../service/evolution/StagingManager.js';
 import { CodeEntityGraph } from '../../service/knowledge/CodeEntityGraph.js';
 import { ConfidenceRouter } from '../../service/knowledge/ConfidenceRouter.js';
 import { KnowledgeGraphService } from '../../service/knowledge/KnowledgeGraphService.js';
@@ -50,6 +57,7 @@ export function register(c) {
             // is sufficient for knowledge-base scale (hundreds~thousands of entries).
             // Re-enable when document scale grows to 10k+ or external noisy sources are integrated.
             crossEncoderReranker: null,
+            signalBus: ct.singletons.signalBus || null,
         });
     }, { aiDependent: true });
     c.singleton('vectorStore', (ct) => {
@@ -120,4 +128,47 @@ export function register(c) {
     c.register('constitution', () => c.singletons.constitution || null);
     c.register('aiProvider', () => c.singletons.aiProvider || null);
     c.register('projectGraph', () => c.singletons.projectGraph || null);
+    // ═══ Governance / Evolution ═══
+    c.singleton('stagingManager', (ct) => {
+        const db = ct.get('database');
+        return new StagingManager(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('decayDetector', (ct) => {
+        const db = ct.get('database');
+        return new DecayDetector(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('contradictionDetector', (ct) => {
+        const db = ct.get('database');
+        return new ContradictionDetector(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('redundancyAnalyzer', (ct) => {
+        const db = ct.get('database');
+        return new RedundancyAnalyzer(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('enhancementSuggester', (ct) => {
+        const db = ct.get('database');
+        return new EnhancementSuggester(db.getDb(), {
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('knowledgeMetabolism', (ct) => {
+        return new KnowledgeMetabolism({
+            contradictionDetector: ct.get('contradictionDetector'),
+            redundancyAnalyzer: ct.get('redundancyAnalyzer'),
+            decayDetector: ct.get('decayDetector'),
+            signalBus: ct.singletons.signalBus || undefined,
+        });
+    });
+    c.singleton('consolidationAdvisor', (ct) => {
+        const db = ct.get('database');
+        return new ConsolidationAdvisor(db.getDb());
+    });
 }

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

@@ -0,0 +1,18 @@
+/**
+ * PanoramaModule — DI 注册
+ *
+ * 注册全景服务到 ServiceContainer:
+ *   - moduleDiscoverer
+ *   - roleRefiner
+ *   - couplingAnalyzer
+ *   - layerInferrer
+ *   - panoramaAggregator
+ *   - panoramaScanner
+ *   - panoramaService
+ *
+ * @module PanoramaModule
+ */
+import type { ServiceContainer } from '../ServiceContainer.js';
+export declare const PanoramaModule: {
+    register(container: ServiceContainer): void;
+};

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

@@ -0,0 +1,76 @@
+/**
+ * PanoramaModule — DI 注册
+ *
+ * 注册全景服务到 ServiceContainer:
+ *   - moduleDiscoverer
+ *   - roleRefiner
+ *   - couplingAnalyzer
+ *   - layerInferrer
+ *   - panoramaAggregator
+ *   - panoramaScanner
+ *   - panoramaService
+ *
+ * @module PanoramaModule
+ */
+import { CouplingAnalyzer } from '../../service/panorama/CouplingAnalyzer.js';
+import { DimensionAnalyzer } from '../../service/panorama/DimensionAnalyzer.js';
+import { LayerInferrer } from '../../service/panorama/LayerInferrer.js';
+import { ModuleDiscoverer } from '../../service/panorama/ModuleDiscoverer.js';
+import { PanoramaAggregator } from '../../service/panorama/PanoramaAggregator.js';
+import { PanoramaScanner } from '../../service/panorama/PanoramaScanner.js';
+import { PanoramaService } from '../../service/panorama/PanoramaService.js';
+import { RoleRefiner } from '../../service/panorama/RoleRefiner.js';
+export const PanoramaModule = {
+    register(container) {
+        const ct = container;
+        const getDb = () => {
+            const db = ct.singletons.database;
+            return (db?.getDb ? db.getDb() : db);
+        };
+        const getProjectRoot = () => ct.config?.projectRoot ?? process.cwd();
+        ct.singleton('moduleDiscoverer', () => new ModuleDiscoverer(getDb(), getProjectRoot()));
+        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('panoramaAggregator', (c) => {
+            const sc = c;
+            const roleRefiner = sc.get('roleRefiner');
+            const couplingAnalyzer = sc.get('couplingAnalyzer');
+            const layerInferrer = sc.get('layerInferrer');
+            const dimensionAnalyzer = sc.get('dimensionAnalyzer');
+            return new PanoramaAggregator({
+                roleRefiner,
+                couplingAnalyzer,
+                layerInferrer,
+                db: getDb(),
+                projectRoot: getProjectRoot(),
+                dimensionAnalyzer,
+            });
+        });
+        ct.singleton('panoramaScanner', () => {
+            const logger = (ct.singletons.logger ?? {
+                info() { },
+                warn() { },
+            });
+            return new PanoramaScanner({
+                projectRoot: getProjectRoot(),
+                container: container,
+                logger,
+            });
+        });
+        ct.singleton('panoramaService', (c) => {
+            const sc = c;
+            const aggregator = sc.get('panoramaAggregator');
+            const scanner = sc.get('panoramaScanner');
+            const moduleDiscoverer = sc.get('moduleDiscoverer');
+            return new PanoramaService({
+                aggregator,
+                db: getDb(),
+                projectRoot: getProjectRoot(),
+                scanner,
+                moduleDiscoverer,
+            });
+        });
+    },
+};

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

@@ -0,0 +1,10 @@
+/**
+ * SignalModule — Phase 0 信号基础设施注册
+ *
+ * 注册:
+ *   - signalBus:   统一信号总线（基础设施层）
+ *   - hitRecorder:  批量使用信号采集器（服务层）
+ *   - intent JSONL persistence subscriber
+ */
+import type { ServiceContainer } from '../ServiceContainer.js';
+export declare function register(c: ServiceContainer): void;

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

@@ -0,0 +1,84 @@
+/**
+ * SignalModule — Phase 0 信号基础设施注册
+ *
+ * 注册:
+ *   - signalBus:   统一信号总线（基础设施层）
+ *   - hitRecorder:  批量使用信号采集器（服务层）
+ *   - intent JSONL persistence subscriber
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { SignalAggregator } from '../../infrastructure/signal/SignalAggregator.js';
+import { SignalBridge } from '../../infrastructure/signal/SignalBridge.js';
+import { SignalBus } from '../../infrastructure/signal/SignalBus.js';
+import { SignalTraceWriter } from '../../infrastructure/signal/SignalTraceWriter.js';
+import { HitRecorder } from '../../service/signal/HitRecorder.js';
+import { resolveProjectRoot } from '../../shared/resolveProjectRoot.js';
+import { shutdown } from '../../shared/shutdown.js';
+/**
+ * Register intent signal subscriber for JSONL persistence.
+ * Replaces standalone SignalLogger — writes IntentChainRecord to .autosnippet/logs/signals/YYYY-MM-DD.jsonl.
+ */
+function registerIntentPersistence(signalBus, projectRoot) {
+    signalBus.subscribe('intent', (signal) => {
+        try {
+            const chain = signal.metadata?.chain;
+            if (!chain) {
+                return;
+            }
+            const dir = path.join(projectRoot, '.autosnippet', 'logs', 'signals');
+            fs.mkdirSync(dir, { recursive: true });
+            const d = new Date(signal.timestamp);
+            const dateStr = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+            const filePath = path.join(dir, `${dateStr}.jsonl`);
+            fs.appendFileSync(filePath, `${JSON.stringify(chain)}\n`, 'utf8');
+        }
+        catch {
+            // Write failure is non-blocking
+        }
+    });
+}
+export function register(c) {
+    // ═══ Infrastructure ═══
+    c.singleton('signalBus', () => new SignalBus());
+    // ═══ Service ═══
+    c.singleton('hitRecorder', (ct) => {
+        const bus = ct.get('signalBus');
+        const db = ct.get('database');
+        const recorder = new HitRecorder(bus, db);
+        recorder.start();
+        // shutdown hook: 在 DB close 之前 flush buffer
+        shutdown.register(async () => {
+            await recorder.stop();
+        }, 'hitRecorder');
+        return recorder;
+    });
+    // ═══ Intent Signal Persistence ═══
+    // Register after signalBus is created — subscribe for JSONL persistence
+    const signalBus = c.get('signalBus');
+    const projectRoot = resolveProjectRoot(c);
+    registerIntentPersistence(signalBus, projectRoot);
+    // ═══ SignalBridge — SignalBus → EventBus 桥接 ═══
+    c.singleton('signalBridge', (ct) => {
+        const bus = ct.get('signalBus');
+        const eventBus = ct.get('eventBus');
+        return new SignalBridge(bus, eventBus);
+    });
+    // ═══ SignalTraceWriter — 全类型信号 JSONL 留痕 ═══
+    c.singleton('signalTraceWriter', (ct) => {
+        const bus = ct.get('signalBus');
+        const root = resolveProjectRoot(ct);
+        return new SignalTraceWriter(bus, path.join(root, '.autosnippet', 'logs', 'signals'));
+    });
+    // ═══ SignalAggregator — 滑窗统计 + 异常检测 ═══
+    c.singleton('signalAggregator', (ct) => {
+        const bus = ct.get('signalBus');
+        const reportStore = ct.get('reportStore');
+        const agg = new SignalAggregator(bus, reportStore);
+        agg.start();
+        shutdown.register(async () => {
+            agg.stop();
+        }, 'signalAggregator');
+        return agg;
+    });
+}

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

@@ -169,6 +169,7 @@ export declare class KnowledgeRepositoryImpl extends BaseRepository {
         updatedAt: number;
         publishedAt: number | null;
         publishedBy: string | null;
+        staging_deadline: number | null;
     };
     /**
      * 覆写 BaseRepository 的 _mapRowToEntity

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/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',
             '',