@cue-dev/retrieval-core 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,673 @@
+import type { EnhancePromptInput, EnhancePromptOutput, EnhancePromptStyle, SearchContextInput, SearchContextOutput } from "@cue-dev/contracts";
+import { type CandidateScoreWeights, type IndexRepository, type QueryCache, type WorkspaceRecord } from "@cue-dev/data-plane";
+import { type Observability } from "@cue-dev/observability";
+import { type ChunkingStrategy } from "./chunking.js";
+type ContextRef = EnhancePromptOutput["context_refs"][number];
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_BASE_URL = "https://router.tumuer.me/v1";
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_MODEL = "Qwen/Qwen3-Embedding-4B";
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_DIMENSIONS = 2560;
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_TIMEOUT_MS = 10000;
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_BATCH_SIZE = 64;
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_MAX_RETRIES = 2;
+export declare const DEFAULT_OPENAI_COMPATIBLE_EMBEDDING_TRANSIENT_403_MAX_RETRIES = 4;
+export declare const DEFAULT_OPENAI_COMPATIBLE_RERANKER_BASE_URL = "https://router.tumuer.me/v1";
+export declare const DEFAULT_OPENAI_COMPATIBLE_RERANKER_MODEL = "Qwen/Qwen3-Reranker-4B";
+export declare const DEFAULT_OPENAI_COMPATIBLE_RERANKER_TIMEOUT_MS = 2500;
+export declare const DEFAULT_SEARCH_RERANKER_TOP_N = 30;
+export declare const DEFAULT_PROVIDER_MAX_REQUESTS_PER_MINUTE = 90;
+export declare const DEFAULT_PROVIDER_LIMIT_INDEX_MAX_WAIT_MS = 120000;
+export declare const DEFAULT_PROVIDER_LIMIT_QUERY_MAX_WAIT_MS = 1000;
+export declare const DEFAULT_PROVIDER_LIMIT_RERANK_MAX_WAIT_MS = 500;
+export declare const DEFAULT_CLAUDE_ENHANCER_MODEL = "claude-3-5-sonnet-latest";
+export interface RetrievalPathBiasConfig {
+    source_path_boost: number;
+    low_priority_prefix_penalty: number;
+    low_priority_substring_penalty: number;
+    low_priority_asset_penalty: number;
+    lockfile_penalty: number;
+    doc_intent_docs_boost: number;
+    doc_intent_markdown_boost: number;
+    docs_without_doc_intent_penalty: number;
+    non_doc_markdown_penalty: number;
+    code_intent_docs_penalty: number;
+    doc_intent_source_penalty: number;
+    workspace_manifest_root_boost: number;
+    workspace_manifest_nested_boost: number;
+    ui_component_tsx_boost: number;
+    ui_component_css_penalty: number;
+    docs_archive_penalty: number;
+    public_path_penalty: number;
+    test_path_penalty: number;
+    example_path_penalty: number;
+    declaration_file_penalty: number;
+    test_intent_test_boost: number;
+    example_intent_example_boost: number;
+    filename_token_match_boost: number;
+    negation_avoid_docs_penalty: number;
+    negation_avoid_tests_penalty: number;
+    negation_avoid_examples_penalty: number;
+    negation_avoid_archive_penalty: number;
+    security_trace_meta_penalty: number;
+    literal_path_boost: number;
+    literal_snippet_boost: number;
+    literal_max_boost: number;
+    min_total_bias: number;
+    max_total_bias: number;
+}
+export interface RetrievalRerankConfig {
+    low_information_penalty: number;
+    max_chunks_per_path_default: number;
+    max_chunks_per_path_file_lookup: number;
+    same_directory_penalty: number;
+    same_extension_penalty: number;
+    merge_overlapping_chunks_enabled: boolean;
+    merge_gap_lines: number;
+    merge_max_span_lines: number;
+    smart_cutoff_enabled: boolean;
+    smart_cutoff_min_k: number;
+    smart_cutoff_max_k: number;
+    smart_cutoff_min_score: number;
+    smart_cutoff_top_ratio: number;
+    smart_cutoff_delta_abs: number;
+}
+export interface RetrievalScoringConfig {
+    candidate_weights: CandidateScoreWeights;
+    path_bias: RetrievalPathBiasConfig;
+    rerank: RetrievalRerankConfig;
+}
+export interface RetrievalEnhancerConfig {
+    max_expansion_hints: number;
+    max_candidates_pre_rerank: number;
+    rerank_timeout_ms: number;
+}
+export type EnhancerToolMode = "none" | "read_only";
+export interface RetrievalEnhancerGenerationConfig {
+    timeout_ms: number;
+    max_retries: number;
+    tool_mode: EnhancerToolMode;
+    max_context_snippets: number;
+}
+export interface RetrievalChunkingConfig {
+    strategy: ChunkingStrategy;
+    fallback_strategy: "sliding";
+    target_chunk_tokens: number;
+    chunk_overlap_tokens: number;
+    budget_tokenizer: "ranking" | "lightweight";
+    boundary_strictness: "legacy" | "semantic_js_ts";
+    parse_timeout_ms: number;
+    enabled_languages: string[];
+    recursive_semantic_chunking_enabled: boolean;
+    semantic_merge_gap_lines: number;
+    semantic_merge_max_span_lines: number;
+    comment_forward_absorb_enabled: boolean;
+    embedding_context_prefix_enabled: boolean;
+}
+export interface RetrievalContextPackingConfig {
+    enabled: boolean;
+    max_spans_per_result: number;
+    max_gap_lines: number;
+    max_snippet_chars: number;
+    enhancer_snippet_char_limit: number;
+}
+export interface RetrievalSnippetIntegrityConfig {
+    enabled: boolean;
+    target_languages: string[];
+    max_contiguous_gap_lines: number;
+    marker_template_version: "v1";
+    repair_enabled: boolean;
+    repair_max_envelope_lines: number;
+    repair_max_snippet_chars: number;
+}
+export type RetrievalScoringConfigInput = Partial<{
+    candidate_weights: Partial<CandidateScoreWeights>;
+    path_bias: Partial<RetrievalPathBiasConfig>;
+    rerank: Partial<RetrievalRerankConfig>;
+}>;
+export type RetrievalEnhancerConfigInput = Partial<RetrievalEnhancerConfig>;
+export type RetrievalEnhancerGenerationConfigInput = Partial<RetrievalEnhancerGenerationConfig>;
+export type RetrievalChunkingConfigInput = Partial<{
+    strategy: ChunkingStrategy;
+    fallback_strategy: "sliding";
+    target_chunk_tokens: number;
+    chunk_overlap_tokens: number;
+    budget_tokenizer: "ranking" | "lightweight";
+    boundary_strictness: "legacy" | "semantic_js_ts";
+    parse_timeout_ms: number;
+    enabled_languages: string[];
+    recursive_semantic_chunking_enabled: boolean;
+    semantic_merge_gap_lines: number;
+    semantic_merge_max_span_lines: number;
+    comment_forward_absorb_enabled: boolean;
+    embedding_context_prefix_enabled: boolean;
+}>;
+export type RetrievalContextPackingConfigInput = Partial<RetrievalContextPackingConfig>;
+export type RetrievalSnippetIntegrityConfigInput = Partial<{
+    enabled: boolean;
+    target_languages: string[];
+    max_contiguous_gap_lines: number;
+    marker_template_version: "v1";
+    repair_enabled: boolean;
+    repair_max_envelope_lines: number;
+    repair_max_snippet_chars: number;
+}>;
+export declare const BASELINE_RETRIEVAL_SCORING_CONFIG: RetrievalScoringConfig;
+export declare const CONSERVATIVE_RETRIEVAL_SCORING_CONFIG: RetrievalScoringConfig;
+export declare const DEFAULT_RETRIEVAL_ENHANCER_CONFIG: RetrievalEnhancerConfig;
+export declare const DEFAULT_RETRIEVAL_ENHANCER_GENERATION_CONFIG: RetrievalEnhancerGenerationConfig;
+export declare const DEFAULT_RETRIEVAL_CHUNKING_CONFIG: RetrievalChunkingConfig;
+export declare const DEFAULT_RETRIEVAL_CONTEXT_PACKING_CONFIG: RetrievalContextPackingConfig;
+export declare const DEFAULT_RETRIEVAL_SNIPPET_INTEGRITY_CONFIG: RetrievalSnippetIntegrityConfig;
+declare const BUILTIN_RETRIEVAL_SCORING_PROFILES: {
+    readonly baseline: RetrievalScoringConfig;
+    readonly conservative: RetrievalScoringConfig;
+};
+export type BuiltinRetrievalScoringProfileId = keyof typeof BUILTIN_RETRIEVAL_SCORING_PROFILES;
+export declare function resolveRetrievalScoringProfile(profile_id: string | undefined): {
+    profile_id: BuiltinRetrievalScoringProfileId;
+    config: RetrievalScoringConfig;
+};
+export declare function mergeRetrievalScoringConfig(base: RetrievalScoringConfig, overrides?: RetrievalScoringConfigInput): RetrievalScoringConfig;
+export declare function mergeRetrievalEnhancerConfig(base: RetrievalEnhancerConfig, overrides?: RetrievalEnhancerConfigInput): RetrievalEnhancerConfig;
+export declare function mergeRetrievalEnhancerGenerationConfig(base: RetrievalEnhancerGenerationConfig, overrides?: RetrievalEnhancerGenerationConfigInput): RetrievalEnhancerGenerationConfig;
+export declare function mergeRetrievalChunkingConfig(base: RetrievalChunkingConfig, overrides?: RetrievalChunkingConfigInput): RetrievalChunkingConfig;
+export declare function mergeRetrievalContextPackingConfig(base: RetrievalContextPackingConfig, overrides?: RetrievalContextPackingConfigInput): RetrievalContextPackingConfig;
+export declare function mergeRetrievalSnippetIntegrityConfig(base: RetrievalSnippetIntegrityConfig, overrides?: RetrievalSnippetIntegrityConfigInput): RetrievalSnippetIntegrityConfig;
+declare const REASON_STRINGS: readonly ["semantic match", "exact literal match", "path token overlap", "recently modified relevant module"];
+export type RetrievalReason = (typeof REASON_STRINGS)[number];
+export declare class RetrievalError extends Error {
+    readonly code: "INVALID_ARGUMENT" | "NOT_FOUND" | "RATE_LIMITED" | "UPSTREAM_FAILURE";
+    constructor(code: "INVALID_ARGUMENT" | "NOT_FOUND" | "RATE_LIMITED" | "UPSTREAM_FAILURE", message: string);
+}
+export interface RawFile {
+    path: string;
+    content: string;
+    language?: string;
+    updated_at?: string;
+    generated?: boolean;
+    binary?: boolean;
+}
+export interface IndexUploadArtifact {
+    tenant_id: string;
+    workspace_id: string;
+    index_version: string;
+    files: RawFile[];
+    manifest?: {
+        object_key: string;
+        checksum: string;
+    };
+}
+export interface IndexDeltaArtifact {
+    tenant_id: string;
+    workspace_id: string;
+    index_version: string;
+    base_index_version?: string;
+    upsert_files: RawFile[];
+    deleted_paths: string[];
+}
+interface ReadyIndex {
+    index_id: string;
+    tenant_id: string;
+    workspace_id: string;
+    index_version: string;
+    status: "indexing" | "ready" | "failed";
+    created_at: string;
+    updated_at: string;
+}
+interface PersistedFile {
+    file_id: string;
+    repo_path: string;
+    content_hash: string;
+    language?: string;
+}
+export interface IndexingWarning {
+    path: string;
+    reason: string;
+    category: "secret_exclusion" | "filter_exclusion";
+}
+export interface IndexingReport {
+    workspace_id: string;
+    index_version: string;
+    status: "ready";
+    counts: {
+        added: number;
+        modified: number;
+        deleted: number;
+        unchanged: number;
+        skipped: number;
+    };
+    skipped_files: Array<{
+        path: string;
+        reason: string;
+    }>;
+    warnings: IndexingWarning[];
+}
+export interface RetrievalCoreOptions {
+    cacheTtlSeconds?: number;
+    internalCandidateDepth?: number;
+    indexPrepConcurrency?: number;
+    indexPrepWindowSize?: number;
+    embeddingProvider?: EmbeddingProvider;
+    embeddingDescriptor?: EmbeddingDescriptor;
+    rerankerProvider?: RerankerProvider;
+    rerankerTopN?: number;
+    enhancerProvider?: EnhancerGenerationProvider;
+    observability?: Observability;
+    scoringProfile?: BuiltinRetrievalScoringProfileId;
+    scoringProfileId?: string;
+    scoringConfig?: RetrievalScoringConfigInput;
+    enhancerConfig?: RetrievalEnhancerConfigInput;
+    enhancerGenerationConfig?: RetrievalEnhancerGenerationConfigInput;
+    chunkingConfig?: RetrievalChunkingConfigInput;
+    contextPackingConfig?: RetrievalContextPackingConfigInput;
+    snippetIntegrityConfig?: RetrievalSnippetIntegrityConfigInput;
+    enhancerDecisionTraceEnabled?: boolean;
+}
+export interface EmbeddingDescriptor {
+    provider: string;
+    model?: string;
+    dimensions: number;
+    version?: string;
+}
+export type EmbeddingPurpose = "index" | "query";
+export interface EmbeddingProvider {
+    embed(input: {
+        texts: string[];
+        purpose: EmbeddingPurpose;
+    }): Promise<number[][]>;
+    describe?(): EmbeddingDescriptor;
+}
+export interface RerankerDescriptor {
+    provider: string;
+    model?: string;
+}
+export interface RerankerResult {
+    index: number;
+    relevance_score: number;
+}
+export interface RerankerProvider {
+    rerank(input: {
+        query: string;
+        documents: string[];
+        top_n: number;
+    }): Promise<RerankerResult[]>;
+    describe?(): RerankerDescriptor;
+}
+export type EnhancerIntent = "bugfix" | "feature" | "refactor" | "docs" | "tests" | "unknown";
+export type EnhancerOutputLanguage = "en" | "es" | "zh";
+type ResolvedEnhancerPromptStyle = Exclude<EnhancePromptStyle, "auto">;
+export interface EnhancerContextSnippet {
+    path: string;
+    start_line: number;
+    end_line: number;
+    reason: string;
+    snippet: string;
+    score: number;
+}
+export interface EnhancerGenerationRequest {
+    trace_id: string;
+    tenant_id: string;
+    workspace_id?: string;
+    request: EnhancePromptInput;
+    style_requested: EnhancePromptStyle;
+    style_resolved: ResolvedEnhancerPromptStyle;
+    intent: EnhancerIntent;
+    query_intent: "symbol-heavy" | "impl-focused" | "conceptual";
+    language: EnhancerOutputLanguage;
+    context_refs: ContextRef[];
+    context_snippets: EnhancerContextSnippet[];
+    warnings: string[];
+    questions: string[];
+    tool_mode: EnhancerToolMode;
+    abort_signal?: AbortSignal;
+    on_progress?: () => void;
+}
+export interface EnhancerGenerationResult {
+    enhanced_prompt: string;
+}
+export interface EnhancerProviderDescriptor {
+    provider: string;
+    model?: string;
+}
+export interface EnhancerGenerationProvider {
+    generate(input: EnhancerGenerationRequest): Promise<EnhancerGenerationResult>;
+    describe?(): EnhancerProviderDescriptor;
+}
+export interface DeterministicEmbeddingProviderOptions {
+    dimensions?: number;
+    model?: string;
+    version?: string;
+}
+export interface OpenAICompatibleEmbeddingProviderOptions {
+    base_url: string;
+    api_key: string;
+    model?: string;
+    dimensions?: number;
+    timeout_ms?: number;
+    batch_size?: number;
+    max_retries?: number;
+    transient_forbidden_max_retries?: number;
+    request_limiter?: ProviderRequestLimiter;
+    request_limit_scope_id?: string;
+    max_requests_per_minute?: number;
+    index_max_wait_ms?: number;
+    query_max_wait_ms?: number;
+    observability?: Observability;
+}
+export interface OpenAICompatibleRerankerProviderOptions {
+    base_url: string;
+    api_key: string;
+    model?: string;
+    timeout_ms?: number;
+    request_limiter?: ProviderRequestLimiter;
+    request_limit_scope_id?: string;
+    max_requests_per_minute?: number;
+    rerank_max_wait_ms?: number;
+    observability?: Observability;
+}
+export interface ClaudeAgentEnhancerProviderOptions {
+    api_key: string;
+    model?: string;
+    base_url?: string;
+    max_tokens?: number;
+    path_to_claude_code_executable?: string;
+    permission_mode?: ClaudeCodePermissionMode;
+}
+export type ClaudeCodePermissionMode = "default" | "acceptEdits" | "bypassPermissions" | "plan";
+export interface ProviderRateLimitAcquireInput {
+    scope: string;
+    max_requests_per_minute: number;
+    max_wait_ms: number;
+}
+export interface ProviderRateLimitAcquireResult {
+    wait_ms: number;
+}
+export interface ProviderRequestLimiter {
+    readonly mode?: "local" | "redis" | "custom";
+    acquire(input: ProviderRateLimitAcquireInput): Promise<ProviderRateLimitAcquireResult>;
+}
+export interface RedisProviderRequestLimiterClient {
+    eval(script: string, numKeys: number, ...args: Array<string | number>): Promise<unknown>;
+}
+export interface RedisProviderRequestLimiterOptions {
+    redis: RedisProviderRequestLimiterClient;
+    key_prefix?: string;
+    window_ms?: number;
+    now?: () => number;
+    sleeper?: (ms: number) => Promise<void>;
+}
+export declare class ProviderRateLimitExceededError extends Error {
+    readonly retry_after_ms: number;
+    constructor(message: string, retry_after_ms: number);
+}
+export declare class LocalProviderRequestLimiter implements ProviderRequestLimiter {
+    readonly mode: "local";
+    private readonly buckets;
+    private readonly now;
+    private readonly sleeper;
+    constructor(options?: {
+        now?: () => number;
+        sleeper?: (ms: number) => Promise<void>;
+    });
+    acquire(input: ProviderRateLimitAcquireInput): Promise<ProviderRateLimitAcquireResult>;
+}
+export declare class RedisProviderRequestLimiter implements ProviderRequestLimiter {
+    readonly mode: "redis";
+    private readonly redis;
+    private readonly keyPrefix;
+    private readonly windowMs;
+    private readonly now;
+    private readonly sleeper;
+    constructor(options: RedisProviderRequestLimiterOptions);
+    acquire(input: ProviderRateLimitAcquireInput): Promise<ProviderRateLimitAcquireResult>;
+    private reserveAttempt;
+}
+export declare class DeterministicEmbeddingProvider implements EmbeddingProvider {
+    private readonly dimensions;
+    private readonly model;
+    private readonly version;
+    constructor(options?: DeterministicEmbeddingProviderOptions);
+    embed(input: {
+        texts: string[];
+        purpose: EmbeddingPurpose;
+    }): Promise<number[][]>;
+    describe(): EmbeddingDescriptor;
+}
+export declare class OpenAICompatibleEmbeddingProvider implements EmbeddingProvider {
+    private readonly baseUrl;
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly model;
+    private readonly dimensions;
+    private readonly timeoutMs;
+    private readonly batchSize;
+    private readonly maxRetries;
+    private readonly transientForbiddenMaxRetries;
+    private readonly requestLimiter?;
+    private readonly requestLimitScope;
+    private readonly maxRequestsPerMinute;
+    private readonly indexMaxWaitMs;
+    private readonly queryMaxWaitMs;
+    private readonly observability;
+    constructor(options: OpenAICompatibleEmbeddingProviderOptions);
+    describe(): EmbeddingDescriptor;
+    embed(input: {
+        texts: string[];
+        purpose: EmbeddingPurpose;
+    }): Promise<number[][]>;
+    private embedBatchWithRetries;
+    private enforceRequestLimit;
+    private embedBatchOnce;
+    private maxRetriesForReason;
+    private retryDelayMs;
+    private isTransientForbidden;
+    private toProviderFailure;
+}
+export declare class OpenAICompatibleRerankerProvider implements RerankerProvider {
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly model;
+    private readonly timeoutMs;
+    private readonly requestLimiter?;
+    private readonly requestLimitScope;
+    private readonly maxRequestsPerMinute;
+    private readonly rerankMaxWaitMs;
+    private readonly observability;
+    constructor(options: OpenAICompatibleRerankerProviderOptions);
+    describe(): RerankerDescriptor;
+    rerank(input: {
+        query: string;
+        documents: string[];
+        top_n: number;
+    }): Promise<RerankerResult[]>;
+    private enforceRequestLimit;
+}
+export declare class ClaudeAgentEnhancerProvider implements EnhancerGenerationProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxTokens;
+    private readonly baseUrl?;
+    private readonly pathToClaudeCodeExecutable?;
+    private readonly permissionMode;
+    constructor(options: ClaudeAgentEnhancerProviderOptions);
+    describe(): EnhancerProviderDescriptor;
+    generate(input: EnhancerGenerationRequest): Promise<EnhancerGenerationResult>;
+}
+export declare function __applySmartCutoffCandidatesForTests(input: {
+    candidates: SearchContextOutput["results"];
+    config: RetrievalRerankConfig;
+}): SearchContextOutput["results"];
+export declare class InMemoryIndexStore implements IndexRepository {
+    private readonly workspaces;
+    private readonly workspacesByPath;
+    private readonly indexes;
+    private readonly workspaceIndexes;
+    private readonly filesByIndex;
+    private readonly chunksByFile;
+    private readonly indexMetadata;
+    migrate(): Promise<void>;
+    upsertWorkspace(input: WorkspaceRecord): Promise<void>;
+    resolveWorkspaceByProjectRoot(tenant_id: string, project_root_path: string): Promise<WorkspaceRecord | undefined>;
+    resolveWorkspaceByWorkspaceId(tenant_id: string, workspace_id: string): Promise<WorkspaceRecord | undefined>;
+    createIndexVersion(input: {
+        tenant_id: string;
+        workspace_id: string;
+        index_version: string;
+        status?: "indexing" | "ready" | "failed";
+    }): Promise<ReadyIndex>;
+    markIndexStatus(input: {
+        tenant_id: string;
+        workspace_id: string;
+        index_id: string;
+        status: "indexing" | "ready" | "failed";
+    }): Promise<void>;
+    getIndexByVersion(input: {
+        tenant_id: string;
+        workspace_id: string;
+        index_version: string;
+    }): Promise<ReadyIndex | undefined>;
+    resetIndexContent(input: {
+        tenant_id: string;
+        index_id: string;
+    }): Promise<void>;
+    getLatestReadyIndex(input: {
+        tenant_id: string;
+        workspace_id: string;
+    }): Promise<ReadyIndex | undefined>;
+    getFilesByIndex(input: {
+        tenant_id: string;
+        index_id: string;
+    }): Promise<PersistedFile[]>;
+    copyFileFromIndex(input: {
+        tenant_id: string;
+        source_index_id: string;
+        target_index_id: string;
+        repo_path: string;
+    }): Promise<void>;
+    upsertFile(input: {
+        tenant_id: string;
+        index_id: string;
+        repo_path: string;
+        content_hash: string;
+        size_bytes: number;
+        language?: string;
+    }): Promise<{
+        file_id: string;
+    }>;
+    replaceFileChunks(input: {
+        tenant_id: string;
+        file_id: string;
+        repo_path: string;
+        chunks: Array<{
+            start_line: number;
+            end_line: number;
+            snippet: string;
+            embedding: number[];
+            generated?: boolean;
+            updated_at?: string;
+        }>;
+    }): Promise<void>;
+    saveManifest(): Promise<void>;
+    saveIndexMetadata(input: {
+        tenant_id: string;
+        index_id: string;
+        embedding_provider: string;
+        embedding_model?: string;
+        embedding_dimensions: number;
+        embedding_version?: string;
+        chunking_strategy: "language_aware" | "sliding";
+        chunking_fallback_strategy: "sliding";
+    }): Promise<void>;
+    getIndexMetadata(input: {
+        tenant_id: string;
+        index_id: string;
+    }): Promise<{
+        embedding_provider: string;
+        embedding_model?: string;
+        embedding_dimensions: number;
+        embedding_version?: string;
+        chunking_strategy: "language_aware" | "sliding";
+        chunking_fallback_strategy: "sliding";
+        created_at: string;
+    } | undefined>;
+    listChunksByIndex(input: {
+        tenant_id: string;
+        index_id: string;
+        filters?: {
+            language?: string;
+            path_prefix?: string;
+            glob?: string;
+        };
+    }): Promise<Array<{
+        chunk_id: string;
+        file_id: string;
+        path: string;
+        start_line: number;
+        end_line: number;
+        snippet: string;
+        language?: string;
+        generated?: boolean;
+        updated_at: string;
+        embedding: number[];
+    }>>;
+}
+export declare class RetrievalCore {
+    private readonly store;
+    private readonly cache;
+    private readonly cacheTtlSeconds;
+    private readonly internalCandidateDepth;
+    private readonly embeddingProvider;
+    private readonly embeddingDescriptor;
+    private readonly rerankerProvider?;
+    private readonly rerankerDescriptor?;
+    private readonly rerankerTopN;
+    private readonly rerankerCacheVariant;
+    private readonly observability;
+    private readonly scoringConfig;
+    private readonly scoringProfileId;
+    private readonly scoringConfigChecksum;
+    private readonly enhancerProvider?;
+    private readonly enhancerProviderDescriptor?;
+    private readonly enhancerConfig;
+    private readonly enhancerGenerationConfig;
+    private readonly chunkingConfig;
+    private readonly contextPackingConfig;
+    private readonly snippetIntegrityConfig;
+    private readonly enhancerDecisionTraceEnabled;
+    private readonly indexPrepConcurrency;
+    private readonly indexPrepWindowSize;
+    private cacheHits;
+    private cacheMisses;
+    constructor(store: IndexRepository, cache: QueryCache, options?: RetrievalCoreOptions);
+    private prepareFileForIndexing;
+    private prepareFilesForIndexing;
+    indexArtifact(artifact: IndexUploadArtifact): Promise<IndexingReport>;
+    indexArtifactDelta(artifact: IndexDeltaArtifact): Promise<IndexingReport>;
+    getIndexVersion(input: {
+        tenant_id: string;
+        workspace_id: string;
+        index_version: string;
+    }): Promise<{
+        index_id: string;
+        status: "indexing" | "ready" | "failed";
+    } | undefined>;
+    private applyLearnedReranker;
+    searchContext(input: {
+        trace_id: string;
+        tenant_id: string;
+        workspace_id: string;
+        request: SearchContextInput;
+    }): Promise<SearchContextOutput>;
+    private enhancerProviderLabels;
+    private buildEnhancerContextSnippets;
+    private generateEnhancedPrompt;
+    enhancePrompt(input: {
+        trace_id: string;
+        tenant_id: string;
+        workspace_id?: string;
+        request: EnhancePromptInput;
+    }): Promise<EnhancePromptOutput>;
+}
+export declare function createDefaultRetrievalCore(): RetrievalCore;
+export declare function seedWorkspaceIndex(core: RetrievalCore, artifact: IndexUploadArtifact): Promise<IndexingReport>;
+export * from "./remote-sync.js";
+export * from "./indexing-ignore.js";