autosnippet 3.2.21 → 3.3.2

package/dist/lib/infrastructure/signal/SignalAggregator.js

@@ -0,0 +1,84 @@
+/**
+ * SignalAggregator — 滑窗统计 + 异常检测
+ *
+ * 订阅可聚合的事实型信号，周期性写入 Report（统计）并在异常时发射 Signal。
+ *
+ * @module infrastructure/signal/SignalAggregator
+ */
+export class SignalAggregator {
+    #bus;
+    #reportStore;
+    #windows = new Map();
+    #intervalMs;
+    #windowMs;
+    #timer = null;
+    constructor(signalBus, reportStore, opts = {}) {
+        this.#bus = signalBus;
+        this.#reportStore = reportStore;
+        this.#intervalMs = opts.intervalMs ?? 60_000;
+        this.#windowMs = opts.windowMs ?? 300_000;
+        // 订阅可聚合的事实型信号
+        signalBus.subscribe('guard|search|usage|lifecycle|forge|decay|quality', (signal) => {
+            this.#record(signal);
+        });
+    }
+    start() {
+        if (this.#timer) {
+            return;
+        }
+        this.#timer = setInterval(() => {
+            void this.#flush();
+        }, this.#intervalMs);
+    }
+    stop() {
+        if (this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = null;
+        }
+    }
+    #record(signal) {
+        const key = signal.type;
+        if (!this.#windows.has(key)) {
+            this.#windows.set(key, { entries: [], baseline: 0 });
+        }
+        const win = this.#windows.get(key);
+        win.entries.push({ value: signal.value, ts: signal.timestamp });
+    }
+    async #flush() {
+        const now = Date.now();
+        for (const [type, win] of this.#windows) {
+            // 清理过期条目
+            win.entries = win.entries.filter((e) => now - e.ts < this.#windowMs);
+            if (win.entries.length === 0) {
+                continue;
+            }
+            const count = win.entries.length;
+            const avg = win.entries.reduce((s, e) => s + e.value, 0) / count;
+            const max = Math.max(...win.entries.map((e) => e.value));
+            const min = Math.min(...win.entries.map((e) => e.value));
+            // 周期统计 → Report
+            await this.#reportStore.write({
+                category: 'metrics',
+                type: `aggregate_${type}`,
+                producer: 'SignalAggregator',
+                data: {
+                    window: `${this.#windowMs / 1000}s`,
+                    count,
+                    avg,
+                    max,
+                    min,
+                    baseline: win.baseline,
+                },
+                timestamp: now,
+            });
+            // 异常检测 → Signal（信号量突增 3 倍）
+            if (win.baseline > 0 && count > win.baseline * 3) {
+                this.#bus.send('anomaly', `Aggregator.${type}`, 1, {
+                    metadata: { reason: 'spike', count, baseline: win.baseline },
+                });
+            }
+            // 更新 baseline（指数移动平均）
+            win.baseline = win.baseline === 0 ? count : win.baseline * 0.8 + count * 0.2;
+        }
+    }
+}

package/dist/lib/infrastructure/signal/SignalBridge.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SignalBridge — SignalBus → EventBus 单点桥接
+ *
+ * 将 SignalBus 信号转发到 EventBus，实现 SignalBus 纯内核化。
+ * HttpServer 等端口层只需监听 EventBus，不再直接消费 SignalBus。
+ *
+ * @module infrastructure/signal/SignalBridge
+ */
+import type { EventBus } from '../event/EventBus.js';
+import type { SignalBus } from './SignalBus.js';
+export declare class SignalBridge {
+    constructor(signalBus: SignalBus, eventBus: EventBus);
+}

package/dist/lib/infrastructure/signal/SignalBridge.js

@@ -0,0 +1,20 @@
+/**
+ * SignalBridge — SignalBus → EventBus 单点桥接
+ *
+ * 将 SignalBus 信号转发到 EventBus，实现 SignalBus 纯内核化。
+ * HttpServer 等端口层只需监听 EventBus，不再直接消费 SignalBus。
+ *
+ * @module infrastructure/signal/SignalBridge
+ */
+export class SignalBridge {
+    constructor(signalBus, eventBus) {
+        // 全量转发
+        signalBus.subscribe('*', (signal) => {
+            eventBus.emit('signal:event', signal);
+        });
+        // Guard 专用通道
+        signalBus.subscribe('guard', (signal) => {
+            eventBus.emit('guard:updated', signal);
+        });
+    }
+}

package/dist/lib/infrastructure/signal/SignalBus.d.ts

@@ -0,0 +1,63 @@
+/**
+ * SignalBus — 统一信号总线
+ *
+ * Phase 0 核心基础设施。所有子系统（Guard、Search、Agent、Governance）
+ * 通过 Signal Bus 发射和消费结构化信号，替代各自为政的事件分发。
+ *
+ * 设计公理：
+ *   - 同步分发，<0.1ms per emit（消费者自行决定是否 buffer）
+ *   - 支持精确类型订阅和通配符 '*'
+ *   - 支持 pattern 订阅 'guard|search|usage'
+ *
+ * @module infrastructure/signal/SignalBus
+ */
+/** 信号类型枚举 */
+export type SignalType = 'guard' | 'guard_blind_spot' | 'search' | 'usage' | 'lifecycle' | 'exploration' | 'quality' | 'panorama' | 'decay' | 'forge' | 'intent' | 'anomaly';
+/** 信号结构 */
+export interface Signal {
+    /** 信号类别 */
+    type: SignalType;
+    /** 产出模块标识 */
+    source: string;
+    /** 关联 Recipe/Module ID（可选） */
+    target: string | null;
+    /** 标准化信号值 0-1 */
+    value: number;
+    /** 原始数据载荷 */
+    metadata: Record<string, unknown>;
+    /** 信号产生时间戳（ms） */
+    timestamp: number;
+}
+/** 信号处理器 */
+export type SignalHandler = (signal: Signal) => void;
+export declare class SignalBus {
+    #private;
+    /**
+     * 发射信号。同步分发给所有匹配的订阅者。
+     *
+     * @param signal 完整的 Signal 对象
+     */
+    emit(signal: Signal): void;
+    /**
+     * 订阅信号。支持三种模式：
+     * - 精确类型: `subscribe('guard', handler)`
+     * - 多类型:   `subscribe('guard|search|usage', handler)`
+     * - 通配符:   `subscribe('*', handler)`
+     *
+     * @returns 取消订阅函数
+     */
+    subscribe(pattern: string, handler: SignalHandler): () => void;
+    /**
+     * 创建并发射信号的便捷方法。自动填充 timestamp。
+     */
+    send(type: SignalType, source: string, value: number, opts?: {
+        target?: string | null;
+        metadata?: Record<string, unknown>;
+    }): void;
+    /** 已发射的信号总数（诊断用） */
+    get emitCount(): number;
+    /** 活跃订阅者数量（诊断用） */
+    get listenerCount(): number;
+    /** 移除所有订阅者（测试用） */
+    clear(): void;
+}

package/dist/lib/infrastructure/signal/SignalBus.js

@@ -0,0 +1,106 @@
+/**
+ * SignalBus — 统一信号总线
+ *
+ * Phase 0 核心基础设施。所有子系统（Guard、Search、Agent、Governance）
+ * 通过 Signal Bus 发射和消费结构化信号，替代各自为政的事件分发。
+ *
+ * 设计公理：
+ *   - 同步分发，<0.1ms per emit（消费者自行决定是否 buffer）
+ *   - 支持精确类型订阅和通配符 '*'
+ *   - 支持 pattern 订阅 'guard|search|usage'
+ *
+ * @module infrastructure/signal/SignalBus
+ */
+/** 通配符常量 */
+const WILDCARD = '*';
+// ── SignalBus ───────────────────────────────────────
+export class SignalBus {
+    #listeners = new Map();
+    #emitCount = 0;
+    /**
+     * 发射信号。同步分发给所有匹配的订阅者。
+     *
+     * @param signal 完整的 Signal 对象
+     */
+    emit(signal) {
+        this.#emitCount++;
+        // 精确类型匹配
+        const exact = this.#listeners.get(signal.type);
+        if (exact) {
+            for (const handler of exact) {
+                try {
+                    handler(signal);
+                }
+                catch {
+                    // 消费者异常不阻断信号分发
+                }
+            }
+        }
+        // 通配符匹配
+        const wildcard = this.#listeners.get(WILDCARD);
+        if (wildcard) {
+            for (const handler of wildcard) {
+                try {
+                    handler(signal);
+                }
+                catch {
+                    // 消费者异常不阻断信号分发
+                }
+            }
+        }
+    }
+    /**
+     * 订阅信号。支持三种模式：
+     * - 精确类型: `subscribe('guard', handler)`
+     * - 多类型:   `subscribe('guard|search|usage', handler)`
+     * - 通配符:   `subscribe('*', handler)`
+     *
+     * @returns 取消订阅函数
+     */
+    subscribe(pattern, handler) {
+        const types = pattern === WILDCARD ? [WILDCARD] : pattern.split('|');
+        for (const type of types) {
+            let set = this.#listeners.get(type);
+            if (!set) {
+                set = new Set();
+                this.#listeners.set(type, set);
+            }
+            set.add(handler);
+        }
+        return () => {
+            for (const type of types) {
+                this.#listeners.get(type)?.delete(handler);
+            }
+        };
+    }
+    /**
+     * 创建并发射信号的便捷方法。自动填充 timestamp。
+     */
+    send(type, source, value, opts = {}) {
+        this.emit({
+            type,
+            source,
+            target: opts.target ?? null,
+            value: Math.max(0, Math.min(1, value)),
+            metadata: opts.metadata ?? {},
+            timestamp: Date.now(),
+        });
+    }
+    /** 已发射的信号总数（诊断用） */
+    get emitCount() {
+        return this.#emitCount;
+    }
+    /** 活跃订阅者数量（诊断用） */
+    get listenerCount() {
+        let count = 0;
+        for (const set of this.#listeners.values()) {
+            count += set.size;
+        }
+        return count;
+    }
+    /** 移除所有订阅者（测试用） */
+    clear() {
+        this.#listeners.clear();
+        this.#emitCount = 0;
+    }
+}

package/dist/lib/infrastructure/signal/SignalTraceWriter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SignalTraceWriter — 全类型信号 JSONL 留痕
+ *
+ * 订阅 SignalBus 全量信号，按类型分文件写入 JSONL。
+ * 替代 SignalModule 中 intent-only 的 JSONL 写入逻辑，统一处理全部类型。
+ *
+ * @module infrastructure/signal/SignalTraceWriter
+ */
+import type { Signal, SignalBus } from './SignalBus.js';
+export interface SignalTraceQueryOptions {
+    type?: string[];
+    source?: string;
+    target?: string;
+    from?: number;
+    to?: number;
+    limit?: number;
+    offset?: number;
+}
+export declare class SignalTraceWriter {
+    #private;
+    constructor(signalBus: SignalBus, baseDir: string);
+    /** 查询历史信号 */
+    query(opts?: SignalTraceQueryOptions): Promise<{
+        signals: Signal[];
+        total: number;
+    }>;
+    /** 统计信息 */
+    stats(opts?: {
+        from?: number;
+        to?: number;
+    }): Promise<{
+        total: number;
+        byType: Record<string, number>;
+        bySource: Record<string, number>;
+    }>;
+}

package/dist/lib/infrastructure/signal/SignalTraceWriter.js

@@ -0,0 +1,130 @@
+/**
+ * SignalTraceWriter — 全类型信号 JSONL 留痕
+ *
+ * 订阅 SignalBus 全量信号，按类型分文件写入 JSONL。
+ * 替代 SignalModule 中 intent-only 的 JSONL 写入逻辑，统一处理全部类型。
+ *
+ * @module infrastructure/signal/SignalTraceWriter
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+export class SignalTraceWriter {
+    #baseDir;
+    constructor(signalBus, baseDir) {
+        this.#baseDir = baseDir;
+        fs.mkdirSync(baseDir, { recursive: true });
+        signalBus.subscribe('*', (signal) => {
+            this.#write(signal);
+        });
+    }
+    #write(signal) {
+        try {
+            const fileName = this.#resolveFile(signal.type);
+            fs.appendFileSync(fileName, `${JSON.stringify({
+                type: signal.type,
+                source: signal.source,
+                value: signal.value,
+                target: signal.target,
+                metadata: signal.metadata,
+                timestamp: signal.timestamp,
+            })}\n`, 'utf8');
+        }
+        catch {
+            // 写入失败不阻断信号分发
+        }
+    }
+    /** 查询历史信号 */
+    async query(opts = {}) {
+        const types = opts.type?.length ? opts.type : this.#listTypes();
+        const all = [];
+        for (const t of types) {
+            const filePath = this.#resolveFile(t);
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            const entries = this.#readJsonl(filePath);
+            all.push(...entries);
+        }
+        // 过滤
+        let filtered = all;
+        if (opts.source) {
+            filtered = filtered.filter((s) => s.source === opts.source);
+        }
+        if (opts.target) {
+            filtered = filtered.filter((s) => s.target === opts.target);
+        }
+        if (opts.from) {
+            filtered = filtered.filter((s) => s.timestamp >= opts.from);
+        }
+        if (opts.to) {
+            filtered = filtered.filter((s) => s.timestamp <= opts.to);
+        }
+        // 按时间倒序
+        filtered.sort((a, b) => b.timestamp - a.timestamp);
+        const total = filtered.length;
+        const offset = opts.offset ?? 0;
+        const limit = opts.limit ?? 50;
+        const signals = filtered.slice(offset, offset + limit);
+        return { signals, total };
+    }
+    /** 统计信息 */
+    async stats(opts = {}) {
+        const types = this.#listTypes();
+        const byType = {};
+        const bySource = {};
+        let total = 0;
+        for (const t of types) {
+            const filePath = this.#resolveFile(t);
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            const entries = this.#readJsonl(filePath);
+            for (const e of entries) {
+                if (opts.from && e.timestamp < opts.from) {
+                    continue;
+                }
+                if (opts.to && e.timestamp > opts.to) {
+                    continue;
+                }
+                total++;
+                byType[e.type] = (byType[e.type] ?? 0) + 1;
+                bySource[e.source] = (bySource[e.source] ?? 0) + 1;
+            }
+        }
+        return { total, byType, bySource };
+    }
+    // ── Private ───────────────────────────────────────
+    #resolveFile(type) {
+        return path.join(this.#baseDir, `${type}.jsonl`);
+    }
+    #listTypes() {
+        try {
+            return fs
+                .readdirSync(this.#baseDir)
+                .filter((f) => f.endsWith('.jsonl'))
+                .map((f) => f.replace('.jsonl', ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    #readJsonl(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const lines = content.split('\n').filter((l) => l.trim());
+            const entries = [];
+            for (const line of lines) {
+                try {
+                    entries.push(JSON.parse(line));
+                }
+                catch {
+                    // 跳过损坏行
+                }
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/lib/injection/ServiceContainer.js

@@ -15,6 +15,8 @@ import * as GuardModule from './modules/GuardModule.js';
 // ─── DI Modules ──────────────────────────────────────
 import * as InfraModule from './modules/InfraModule.js';
 import * as KnowledgeModule from './modules/KnowledgeModule.js';
+import { PanoramaModule } from './modules/PanoramaModule.js';
+import * as SignalModule from './modules/SignalModule.js';
 import * as VectorModule from './modules/VectorModule.js';
 /**
  * DependencyInjection 容器
@@ -107,12 +109,16 @@ export class ServiceContainer {
             // ═══ 容器级语言偏好 ═══
             this.singletons._lang = null;
             // 注册模块 (顺序重要: AppModule 先注册 qualityScorer 等基础服务)
+            // SignalModule 优先注册并预热，确保后续模块可访问 signalBus
+            SignalModule.register(this);
+            this.get('signalBus'); // eager: 确保 singletons.signalBus 在后续工厂可用
             AppModule.register(this);
             KnowledgeModule.register(this);
             VectorModule.register(this);
             GuardModule.register(this);
             AgentModule.register(this);
             AiModule.register(this);
+            PanoramaModule.register(this);
             // v3.1: 初始化 Enhancement Pack 注册表（异步加载所有框架增强包）
             try {
                 await initEnhancementRegistry();

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

@@ -12,20 +12,17 @@ import type { KnowledgeSyncService } from '../cli/KnowledgeSyncService.js';
 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 { TaskIdGenerator } from '../domain/task/TaskIdGenerator.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 DatabaseConnection from '../infrastructure/database/DatabaseConnection.js';
 import type { EventBus } from '../infrastructure/event/EventBus.js';
 import type Logger from '../infrastructure/logging/Logger.js';
+import type { SignalBus } from '../infrastructure/signal/SignalBus.js';
 import type { IndexingPipeline } from '../infrastructure/vector/IndexingPipeline.js';
 import type { VectorStore } from '../infrastructure/vector/VectorStore.js';
-import type { SpmHelper } from '../platform/ios/spm/SpmHelper.js';
 import type { KnowledgeRepositoryImpl } from '../repository/knowledge/KnowledgeRepository.impl.js';
-import type { TaskRepositoryImpl } from '../repository/task/TaskRepository.impl.js';
 import type { TokenUsageStore } from '../repository/token/TokenUsageStore.js';
-import type { AutomationOrchestrator } from '../service/automation/AutomationOrchestrator.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';
@@ -43,18 +40,20 @@ import type { KnowledgeGraphService } from '../service/knowledge/KnowledgeGraphS
 import type { KnowledgeService } from '../service/knowledge/KnowledgeService.js';
 import type { RecipeExtractor } from '../service/knowledge/RecipeExtractor.js';
 import type { ModuleService } from '../service/module/ModuleService.js';
+import type { CouplingAnalyzer } from '../service/panorama/CouplingAnalyzer.js';
+import type { LayerInferrer } from '../service/panorama/LayerInferrer.js';
+import type { PanoramaAggregator } from '../service/panorama/PanoramaAggregator.js';
+import type { PanoramaService } from '../service/panorama/PanoramaService.js';
+import type { RoleRefiner } from '../service/panorama/RoleRefiner.js';
 import type { FeedbackCollector } from '../service/quality/FeedbackCollector.js';
 import type { QualityScorer } from '../service/quality/QualityScorer.js';
 import type { RecipeCandidateValidator } from '../service/recipe/RecipeCandidateValidator.js';
 import type { RecipeParser } from '../service/recipe/RecipeParser.js';
 import type { HybridRetriever } from '../service/search/HybridRetriever.js';
 import type SearchEngine from '../service/search/SearchEngine.js';
+import type { HitRecorder } from '../service/signal/HitRecorder.js';
 import type { SkillHooks } from '../service/skills/SkillHooks.js';
-import type { SnippetFactory } from '../service/snippet/SnippetFactory.js';
-import type { SnippetInstaller } from '../service/snippet/SnippetInstaller.js';
-import type { TaskGraphService } from '../service/task/TaskGraphService.js';
-import type { TaskKnowledgeBridge } from '../service/task/TaskKnowledgeBridge.js';
-import type { TaskReadyEngine } from '../service/task/TaskReadyEngine.js';
+import type { PrimeSearchPipeline } from '../service/task/PrimeSearchPipeline.js';
 import type { ContextualEnricher } from '../service/vector/ContextualEnricher.js';
 import type { VectorService } from '../service/vector/VectorService.js';
 import type { LanguageService } from '../shared/LanguageService.js';
@@ -75,24 +74,15 @@ export interface ServiceMap {
     knowledgeRepository: KnowledgeRepositoryImpl;
     knowledgeFileWriter: KnowledgeFileWriter;
     knowledgeSyncService: KnowledgeSyncService;
-    taskRepository: TaskRepositoryImpl;
     qualityScorer: QualityScorer;
     recipeParser: RecipeParser;
     recipeCandidateValidator: RecipeCandidateValidator;
     recipeExtractor: RecipeExtractor | null;
     feedbackCollector: FeedbackCollector;
     tokenUsageStore: TokenUsageStore;
-    snippetFactory: SnippetFactory;
-    snippetInstaller: SnippetInstaller;
-    vscodeSnippetInstaller: SnippetInstaller;
-    spmService: SpmHelper;
-    automationOrchestrator: AutomationOrchestrator;
     moduleService: ModuleService;
     cursorDeliveryPipeline: CursorDeliveryPipeline;
-    taskIdGenerator: TaskIdGenerator;
-    taskReadyEngine: TaskReadyEngine;
-    taskKnowledgeBridge: TaskKnowledgeBridge;
-    taskGraphService: TaskGraphService;
+    primeSearchPipeline: PrimeSearchPipeline;
     confidenceRouter: ConfidenceRouter;
     knowledgeService: KnowledgeService;
     knowledgeGraphService: KnowledgeGraphService;
@@ -120,4 +110,11 @@ export interface ServiceMap {
     toolRegistry: ToolRegistry;
     agentFactory: AgentFactory;
     skillHooks: SkillHooks;
+    signalBus: SignalBus;
+    hitRecorder: HitRecorder;
+    roleRefiner: RoleRefiner;
+    couplingAnalyzer: CouplingAnalyzer;
+    layerInferrer: LayerInferrer;
+    panoramaAggregator: PanoramaAggregator;
+    panoramaService: PanoramaService;
 }

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

@@ -2,7 +2,7 @@
  * AgentModule — Agent 架构服务注册
  *
  * 负责注册:
- *   - agentFactory, toolRegistry, skillHooks
+ *   - agentFactory, toolRegistry, toolForge, skillHooks
  *   - feedbackStore, recommendationPipeline, recommendationMetrics
  */
 import type { ServiceContainer } from '../ServiceContainer.js';

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

@@ -2,11 +2,12 @@
  * AgentModule — Agent 架构服务注册
  *
  * 负责注册:
- *   - agentFactory, toolRegistry, skillHooks
+ *   - agentFactory, toolRegistry, toolForge, skillHooks
  *   - feedbackStore, recommendationPipeline, recommendationMetrics
  */
 import { resolveProjectRoot } from '#shared/resolveProjectRoot.js';
 import { AgentFactory } from '../../agent/AgentFactory.js';
+import { ToolForge } from '../../agent/forge/ToolForge.js';
 import { ALL_TOOLS } from '../../agent/tools/index.js';
 import { ToolRegistry } from '../../agent/tools/ToolRegistry.js';
 import { AIRecallStrategy } from '../../service/skills/AIRecallStrategy.js';
@@ -21,6 +22,11 @@ export function register(c) {
         registry.registerAll(ALL_TOOLS);
         return registry;
     });
+    c.singleton('toolForge', (ct) => {
+        const registry = ct.get('toolRegistry');
+        const signalBus = ct.singletons.signalBus;
+        return new ToolForge(registry, { signalBus });
+    });
     c.singleton('agentFactory', (ct) => new AgentFactory({
         container: ct,
         toolRegistry: ct.get('toolRegistry'),

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

@@ -2,11 +2,10 @@
  * 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 type { ServiceContainer } from '../ServiceContainer.js';
 export declare function register(c: ServiceContainer): void;