codesearch-mcp 0.2.3-alpha → 0.3.0-alpha

package/dist/src/interfaces/ICorpusInspector.d.ts

@@ -0,0 +1,7 @@
+export interface ICorpusInspector {
+    headCommit(root: string): Promise<string>;
+    trackedChanges(root: string): Promise<string[]>;
+    untrackedFiles(root: string, skipDirs: readonly string[]): Promise<string[]>;
+    listFiles(dir: string): Promise<string[]>;
+    readFile(absPath: string): Promise<Buffer | null>;
+}

package/dist/src/interfaces/ICorpusInspector.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/interfaces/IDatabase.d.ts

@@ -1,44 +1,24 @@
 import type { DrizzleDb, DrizzleTx } from '../services/DatabaseService';
-/** Single-row record of which embedding model built the current index. */
 export interface IndexMeta {
     provider: string;
     model: string;
     dimensions: number;
 }
-/**
- * Database abstraction — services depend on this interface
- * rather than the concrete DatabaseService.
- */
 export interface IDatabase {
     readonly orm: DrizzleDb;
     query<T = any>(sql: string, params?: any[]): Promise<T>;
+    queryWithLocalSettings<T = any>(settings: Record<string, string | number>, sql: string, params?: any[]): Promise<T>;
+    pgvectorVersion(): Promise<string | null>;
     transaction<T>(fn: (tx: DrizzleTx) => Promise<T>): Promise<T>;
     initDb(): Promise<void>;
     initDbWithSchema(): Promise<void>;
     destroy(): Promise<void>;
-    /** Read the single `index_meta` row, or null when absent (table missing → null). */
     readIndexMeta(): Promise<IndexMeta | null>;
-    /** Upsert the single `index_meta` row. */
     writeIndexMeta(meta: IndexMeta): Promise<void>;
-    /** Create `code_chunk` (+ HNSW/service indexes) at `dimensions` if absent. */
     ensureChunkTable(dimensions: number): Promise<void>;
-    /** Drop and recreate `code_chunk` at `dimensions` (dimension change). */
     recreateChunkTable(dimensions: number): Promise<void>;
-    /**
-     * Return all file paths referenced in any of the four index tables for `project`.
-     * Union of code_chunk.filePath, code_symbol.filePath, code_call.fromFile,
-     * code_dependency.fromFile. calleeFile and toFile are excluded (may belong to other projects).
-     */
     listKnownFiles(project: string): Promise<string[]>;
-    /**
-     * Delete rows for `filePaths` from all four index tables in one transaction.
-     * code_call rows where the file is either fromFile OR calleeFile are removed.
-     * code_dependency rows where the file is either fromFile OR toFile are removed.
-     * No-op when `filePaths` is empty.
-     */
     deleteFiles(project: string, filePaths: string[]): Promise<void>;
-    /** Return all project names referenced in any of the four index tables. */
     listIndexedProjects(): Promise<string[]>;
-    /** Delete all rows for `name` from the four index tables in one transaction. */
     deleteProject(name: string): Promise<void>;
 }

package/dist/src/interfaces/IEmbedder.d.ts

@@ -1,16 +1,7 @@
 export type InputType = 'query' | 'document';
 export interface IEmbedder {
-    /**
-     * The vector width this embedder produces, when known without a probe:
-     * `embedding.dimensions` override → model registry, else `0` for models whose
-     * width is only knowable by embedding once (see `resolveDimension`). Read by
-     * `SearcherService.assertIndexMatches` to catch a dimension change on the
-     * search side (skipped when `0`). Indexing resolves the true width via
-     * `resolveDimension` (which probes when needed), not this field.
-     */
     readonly dimensions: number;
     embed(text: string, inputType?: InputType): Promise<number[]>;
-    /** One vector per input, in input order. The indexing path. */
     embedBatch(texts: string[], inputType?: InputType): Promise<number[][]>;
     rerank?(query: string, documents: string[], topN: number): Promise<number[]>;
     listModels?(): Promise<string[]>;

package/dist/src/interfaces/ILogger.d.ts

@@ -1,17 +1,7 @@
-/**
- * Logger abstraction — allows services to depend on a contract
- * rather than the concrete pino-based LoggerService.
- */
 export interface ILogger {
     debug(msg: string, data?: Record<string, unknown>): void;
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;
     error(msg: string, data?: Record<string, unknown>): void;
-    /**
-     * Structured telemetry emitted at `info` **independent of the configured log
-     * level** — so an operator can collect it in production without the full
-     * `debug` firehose. No-op when file logging is disabled (never writes to
-     * stdout, which the MCP transport owns).
-     */
-    metric(msg: string, data?: Record<string, unknown>): void;
+    withContext<T>(context: Record<string, unknown>, fn: () => Promise<T>): Promise<T>;
 }

package/dist/src/interfaces/IMcpToolHandler.d.ts

@@ -1,8 +1,3 @@
-/**
- * MCP Tool Handler interface — each tool implements this contract.
- * Follows the Open/Closed Principle: new tools are added by implementing
- * this interface and registering them, not by modifying McpServer.
- */
 export interface ToolDefinition {
     name: string;
     description: string;

package/dist/src/interfaces/IMonorepoResolver.d.ts

@@ -1,33 +1,11 @@
-/**
- * Represents a discovered project within a monorepo workspace.
- */
 export interface MonorepoProject {
-    /** Project name (e.g. "my-app", "shared-utils") */
     name: string;
-    /** Absolute path to the project root */
     path: string;
-    /** npm scope + package name (e.g. "@scope/my-app") — null if no package.json or no name */
     packageName: string | null;
-    /** "app" | "lib" — derived from project.json or directory convention */
     type: 'app' | 'lib';
 }
-/**
- * Monorepo resolver — detects and resolves workspace structure.
- * Implementations handle specific monorepo tooling (Nx, Turborepo, etc.)
- */
 export interface IMonorepoResolver {
-    /**
-     * Detect whether the given root directory is a monorepo workspace.
-     */
     isMonorepo(rootDir: string): boolean;
-    /**
-     * Discover all projects (apps + libs) in the monorepo.
-     */
     discoverProjects(rootDir: string): MonorepoProject[];
-    /**
-     * Get the root tsconfig path that contains workspace-wide path aliases.
-     * For Nx this is typically tsconfig.base.json at the workspace root.
-     * The AST parser uses this to resolve cross-project imports (@scope/*).
-     */
     getRootTsConfigPath(rootDir: string): string | null;
 }

package/dist/src/interfaces/IProjectDiscovery.d.ts

@@ -1,28 +1,11 @@
 export interface DiscoveredProject {
     name: string;
     path: string;
-    /** npm scope + package name (e.g. "@scope/my-app") — only set for monorepo projects */
     packageName?: string | null;
-    /** "app" | "lib" — only set for monorepo projects */
     type?: 'app' | 'lib';
-    /**
-     * Path to the workspace-wide tsconfig (e.g. tsconfig.base.json) that holds
-     * cross-project path aliases. Set for monorepo projects; undefined for flat
-     * workspaces (where each project uses its own local tsconfig.json).
-     */
     rootTsConfigPath?: string | null;
-    /**
-     * When a top-level directory is itself a nested monorepo (e.g. an Nx repo
-     * under a flat workspaceRoot), this holds its expanded sub-projects. The
-     * repo stays a single selectable unit; `toLeafProjects` expands `children`
-     * into the actual projects to index. Absent/undefined for ordinary projects.
-     */
     children?: DiscoveredProject[];
 }
-/**
- * Project discovery abstraction — decouples project enumeration
- * from the indexing service (Single Responsibility Principle).
- */
 export interface IProjectDiscovery {
     discover(rootDir: string): DiscoveredProject[];
 }

package/dist/src/interfaces/IRetrievalEvaluator.d.ts

@@ -1,3 +1,5 @@
+import type { StageName } from './ISearcher';
+export type { StageName };
 export type EvalCategory = 'identifier' | 'behaviour' | 'concept';
 export interface ExpectedAnswer {
     file: string;
@@ -10,20 +12,38 @@ export interface EvalCase {
     query: string;
     expect: ExpectedAnswer[];
     threshold?: number;
+    corpus?: string | null;
+}
+export interface CorpusRef {
+    root: string;
+    commit: string;
 }
 export interface EvalSuite {
     version: 1;
+    corpus?: CorpusRef;
     cases: EvalCase[];
 }
 export interface SearchHit {
     filePath: string;
     ownerPath: string | null;
 }
-export type SearchFn = (query: string, limit: number, project: string | null, threshold?: number) => Promise<SearchHit[]>;
-/** Index-inspection callbacks used to validate a case's expected answers before scoring. */
+export interface StagedHits {
+    pool: SearchHit[];
+    stages: {
+        vector: SearchHit[];
+    } & Partial<Record<StageName, SearchHit[]>>;
+    rerankFailed: boolean;
+    fetchLimit: number;
+    indexParams: {
+        efSearch: number | null;
+        iterativeScan: string;
+    };
+}
+export type SearchFn = (query: string, limit: number, project: string | null, threshold?: number) => Promise<StagedHits>;
 export interface IndexInspector {
     isFileIndexed(project: string, file: string): Promise<boolean>;
     ownerPathsOfFile(project: string, file: string): Promise<string[]>;
+    projectDir(project: string): Promise<string | null>;
 }
 export interface Metrics {
     count: number;
@@ -31,14 +51,20 @@ export interface Metrics {
     hit5: number;
     mrr10: number;
 }
+export interface StageRank {
+    rank: number | null;
+    matched: SearchHit | null;
+}
 export interface CaseResult {
     id: string;
     project: string;
     category: EvalCategory;
     query: string;
-    /** 1-based position of the first matching result within the top 10, null when unranked. */
-    rank: number | null;
-    matched: SearchHit | null;
+    stages: Partial<Record<StageName, StageRank>>;
+    poolRank: number | null;
+    poolSize: number;
+    rerankFailed: boolean;
+    corpus: string | null;
 }
 export interface InvalidCase {
     id: string;
@@ -49,17 +75,82 @@ export interface PartialWarning {
     id: string;
     droppedExpects: ExpectedAnswer[];
 }
+export interface StageMetrics {
+    overall: Metrics;
+    byCategory: Partial<Record<EvalCategory, Metrics>>;
+}
+export interface PoolMetrics {
+    count: number;
+    recall: number;
+    short: number;
+}
+export interface PairCounts {
+    improved: number;
+    worsened: number;
+    unchanged: number;
+    signTestP: number;
+}
+export interface PairedChange {
+    overall: PairCounts;
+    byCategory: Partial<Record<EvalCategory, PairCounts>>;
+    hit5Gained: string[];
+    hit5Lost: string[];
+}
+export interface StageChange {
+    from: StageName;
+    to: StageName;
+    change: PairedChange;
+}
 export interface EvalRunResult {
     cases: CaseResult[];
     invalid: InvalidCase[];
     warnings: PartialWarning[];
-    metrics: {
-        overall: Metrics;
-        byCategory: Partial<Record<EvalCategory, Metrics>>;
+    stages: StageName[];
+    metrics: Partial<Record<StageName, StageMetrics>>;
+    pool: {
+        overall: PoolMetrics;
+        byCategory: Partial<Record<EvalCategory, PoolMetrics>>;
+    };
+    stageChanges: StageChange[];
+    rerankFailures: number;
+    byCorpus: Record<string, CorpusRunMetrics>;
+}
+export interface CorpusRunMetrics {
+    cases: number;
+    metrics: Partial<Record<StageName, StageMetrics>>;
+    pool: {
+        overall: PoolMetrics;
+        byCategory: Partial<Record<EvalCategory, PoolMetrics>>;
     };
+    stageChanges: StageChange[];
+}
+export interface ObservedSearchParams {
+    fetchLimit: number[];
+    efSearch: (number | null)[];
+    iterativeScan: string[];
+}
+export interface EvalOutcome {
+    run: EvalRunResult;
+    observed: ObservedSearchParams;
+}
+export interface CaseProgress {
+    index: number;
+    total: number;
+    id: string;
+    result: CaseResult | null;
+    invalid: InvalidCase | null;
+    ms: number;
 }
 export interface IRetrievalEvaluator {
-    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector): Promise<EvalRunResult>;
+    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector, onCase?: (p: CaseProgress) => void): Promise<EvalOutcome>;
+}
+export interface SearchConditions {
+    similarityThreshold: number;
+    overfetch: number;
+    candidateFloor: number;
+    fetchLimit: number[];
+    efSearch: (number | null)[];
+    iterativeScan: string[];
 }
 export interface ResultMetadata {
     suitePath: string;
@@ -74,10 +165,21 @@ export interface ResultMetadata {
     } | null;
     gitCommit: string;
     timestamp: string;
+    conditions: SearchConditions | null;
+    corpora: CorpusRecord[];
+    liveCases: number;
+}
+export interface CorpusRecord {
+    root: string;
+    commit: string;
+    projects: string[];
+    chunks: number;
+    fingerprint: string;
 }
 export interface EvalResultFile {
     metadata: ResultMetadata;
     run: EvalRunResult;
+    legacy?: true;
 }
 export interface MetricDelta {
     baseline: number;
@@ -85,10 +187,30 @@ export interface MetricDelta {
     delta: number;
 }
 export type MetricsDelta = Record<keyof Metrics, MetricDelta>;
-export interface CompareResult {
+export interface StageComparison {
+    stage: StageName;
     overall: MetricsDelta;
     byCategory: Partial<Record<EvalCategory, MetricsDelta>>;
-    hit5Gained: string[];
-    hit5Lost: string[];
+    change: PairedChange;
+}
+export interface PoolValueDelta {
+    baseline: number | null;
+    current: number;
+    delta: number | null;
+}
+export interface PoolDelta {
+    recall: PoolValueDelta;
+    short: PoolValueDelta;
+}
+export interface CompareResult {
+    stages: StageComparison[];
+    unmatchedStages: {
+        stage: StageName;
+        side: 'baseline' | 'current';
+    }[];
+    pool: {
+        overall: PoolDelta;
+        byCategory: Partial<Record<EvalCategory, PoolDelta>>;
+    };
     conditionWarnings: string[];
 }

package/dist/src/interfaces/ISearcher.d.ts

@@ -1,8 +1,18 @@
 import type { SearchResult, NeighborResult, GraphContext, DependencyRow, ProjectRow, SymbolKind, SymbolHit, CallerRow, FileRangeResult, ListFilesResult, GrepSymbolResult, ResolvedToolPath, PathFailure } from '../services/SearcherService';
-/**
- * Searcher abstraction — McpServer depends on this interface
- * rather than the concrete SearcherService.
- */
+export type StageName = 'vector' | 'reranked';
+export interface StagedSearchResult {
+    pool: SearchResult[];
+    stages: {
+        vector: SearchResult[];
+        reranked?: SearchResult[];
+    };
+    rerankFailed: boolean;
+    fetchLimit: number;
+    indexParams: {
+        efSearch: number | null;
+        iterativeScan: string;
+    };
+}
 export interface ISearcher {
     prepareQuery(raw: string): Promise<{
         query: string;
@@ -14,7 +24,8 @@ export interface ISearcher {
         from: string;
         to: string;
     }[]>;
-    searchChunks(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean): Promise<SearchResult[]>;
+    searchChunks(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<SearchResult[]>;
+    searchChunksWithStages(query: string, limit: number, project: string | null, threshold?: number, rerankOverride?: boolean, perFile?: number): Promise<StagedSearchResult>;
     fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
     fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
     getDependencies(filePath: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;

package/dist/src/interrupt.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupInterrupt = setupInterrupt;
-// Graceful interruption for long-running CLI operations.
-// Caller creates the AbortController; this function wires stdin and returns a cleanup function.
 function setupInterrupt(controller) {
     if (!process.stdin.isTTY)
         return () => { };

package/dist/src/owner-path.d.ts

@@ -1,10 +1,9 @@
-import type { OwnerRange } from './interfaces/IAstParser';
-/**
- * Resolve the owning declaration for a chunk given its 1-based start line and a
- * flat list of candidate ranges (top-level symbols + method ranges). The
- * deepest range containing the start line wins (smallest `endLine - line` span),
- * so a method beats its enclosing class. Returns `Container.name` for methods
- * (via `container`) or `name` for top-level declarations, and `null` when the
- * start line lies outside every range (imports / module-scope gaps).
- */
-export declare function resolveOwnerPath(startLine: number, ranges: OwnerRange[]): string | null;
+import type { DeclarationTree } from './declarations/DeclarationTree';
+import type { SourceLines } from './declarations/SourceLines';
+interface LineSpan {
+    startLine: number;
+    endLine: number;
+}
+export declare function ownedLines(piece: LineSpan, declarations: DeclarationTree, lines: SourceLines): number[];
+export declare function ownerOf(piece: LineSpan, declarations: DeclarationTree, lines: SourceLines): string | null;
+export {};

package/dist/src/owner-path.js

@@ -1,27 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveOwnerPath = resolveOwnerPath;
-/**
- * Resolve the owning declaration for a chunk given its 1-based start line and a
- * flat list of candidate ranges (top-level symbols + method ranges). The
- * deepest range containing the start line wins (smallest `endLine - line` span),
- * so a method beats its enclosing class. Returns `Container.name` for methods
- * (via `container`) or `name` for top-level declarations, and `null` when the
- * start line lies outside every range (imports / module-scope gaps).
- */
-function resolveOwnerPath(startLine, ranges) {
-    let best = null;
-    let bestSpan = Infinity;
-    for (const r of ranges) {
-        if (r.line <= startLine && startLine <= r.endLine) {
-            const span = r.endLine - r.line;
-            if (span < bestSpan) {
-                bestSpan = span;
-                best = r;
-            }
-        }
+exports.ownedLines = ownedLines;
+exports.ownerOf = ownerOf;
+function ownedLines(piece, declarations, lines) {
+    const owned = [];
+    for (let n = piece.startLine; n <= piece.endLine; n++) {
+        if (lines.isSignificant(n) && declarations.contains(n))
+            owned.push(n);
     }
-    if (!best)
-        return null;
-    return best.container ? `${best.container}.${best.name}` : best.name;
+    return owned;
+}
+function ownerOf(piece, declarations, lines) {
+    return declarations.smallestContaining(ownedLines(piece, declarations, lines))?.qualifiedName ?? null;
 }

package/dist/src/project-scope.d.ts

@@ -3,17 +3,5 @@ export interface ResolveProjectNamesResult {
     targets: DiscoveredProject[];
     notFound: string[];
 }
-/**
- * Resolve one or more `--project`-style names against discovered units: a
- * unit name expands to all of its children, a leaf name resolves to itself.
- * Units are tried before leaves so a top-level project named the same as a
- * nested-monorepo child's bare name can never shadow it. Targets are
- * deduplicated by leaf name and ordered by first-resolving input name.
- */
 export declare function resolveProjectNames(names: string[], units: DiscoveredProject[]): ResolveProjectNamesResult;
-/**
- * Every name `--project` would accept as a match, in discovery order: each
- * unit's own name, immediately followed by its expanded leaf names (an
- * ordinary project — no children — contributes only its own name once).
- */
 export declare function listAvailableNames(units: DiscoveredProject[]): string[];

package/dist/src/project-scope.js

@@ -3,13 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveProjectNames = resolveProjectNames;
 exports.listAvailableNames = listAvailableNames;
 const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
-/**
- * Resolve one or more `--project`-style names against discovered units: a
- * unit name expands to all of its children, a leaf name resolves to itself.
- * Units are tried before leaves so a top-level project named the same as a
- * nested-monorepo child's bare name can never shadow it. Targets are
- * deduplicated by leaf name and ordered by first-resolving input name.
- */
 function resolveProjectNames(names, units) {
     const leaves = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(units);
     const targets = [];
@@ -31,11 +24,6 @@ function resolveProjectNames(names, units) {
     }
     return { targets, notFound };
 }
-/**
- * Every name `--project` would accept as a match, in discovery order: each
- * unit's own name, immediately followed by its expanded leaf names (an
- * ordinary project — no children — contributes only its own name once).
- */
 function listAvailableNames(units) {
     const names = [];
     for (const unit of units) {

package/dist/src/project-selector.d.ts

@@ -2,11 +2,6 @@ export interface Project {
     name: string;
     path: string;
 }
-/**
- * One-off single-choice prompt for `--project` with no name — distinct from
- * the multi-select `checkbox` flow: it reads/writes nothing persisted.
- * Resolves to `undefined` if the user cancels (e.g. Ctrl+C).
- */
 export declare function selectSingleProject(units: Project[]): Promise<string | undefined>;
 export declare class ProjectSelector {
     private readonly workspaceDir;

package/dist/src/project-selector.js

@@ -38,11 +38,6 @@ exports.selectSingleProject = selectSingleProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const prompts_1 = require("@inquirer/prompts");
-/**
- * One-off single-choice prompt for `--project` with no name — distinct from
- * the multi-select `checkbox` flow: it reads/writes nothing persisted.
- * Resolves to `undefined` if the user cancels (e.g. Ctrl+C).
- */
 async function selectSingleProject(units) {
     try {
         return await (0, prompts_1.select)({
@@ -66,9 +61,6 @@ async function loadLines(filePath) {
         return new Set();
     }
 }
-// Write the set if non-empty, otherwise delete the file so state is deterministic.
-// Previously .ragskip could be left stale (last entry removed but file not rewritten);
-// treating both files the same way avoids that drift.
 async function saveLines(filePath, names) {
     if (names.size > 0) {
         await fs.promises.writeFile(filePath, [...names].sort().join('\n') + '\n');
@@ -94,13 +86,10 @@ class ProjectSelector {
         await this.load();
         const newProjects = allProjects.filter(p => !this.included.has(p.name) && !this.skipped.has(p.name));
         const previouslySelected = allProjects.filter(p => this.included.has(p.name));
-        // Nothing new and something already selected — return silently
         if (newProjects.length === 0 && !forceSelect && previouslySelected.length > 0) {
             return previouslySelected;
         }
-        // No previous selection — treat as implicit --select so the user picks projects now
         const autoSelect = !forceSelect && previouslySelected.length === 0;
-        // In --select / auto-select mode show all non-skipped projects; otherwise only new ones
         const toShow = (forceSelect || autoSelect)
             ? allProjects.filter(p => !this.skipped.has(p.name))
             : newProjects;

package/dist/src/retrieval-eval.d.ts

@@ -1,16 +1,24 @@
-import type { EvalSuite, SearchFn, IndexInspector, IRetrievalEvaluator, EvalRunResult, EvalResultFile, CompareResult } from './interfaces/IRetrievalEvaluator';
-/** Thrown by `parseSuite` before any search runs — names the offending case and field. */
+import type { EvalSuite, EvalCase, EvalCategory, CorpusRef, SearchFn, IndexInspector, IRetrievalEvaluator, EvalOutcome, StageName, PairedChange, CaseProgress, EvalResultFile, CompareResult } from './interfaces/IRetrievalEvaluator';
+export declare const STAGE_ORDER: readonly StageName[];
 export declare class EvalSuiteError extends Error {
     readonly caseId: string | null;
     readonly field: string | null;
     constructor(message: string, caseId: string | null, field: string | null);
 }
-/** Validates a loaded suite object against the schema; rejects before any search runs. */
 export declare function parseSuite(raw: unknown): EvalSuite;
-/** Merges several suites (already parsed) into one; case ids must be unique across all of them. */
+export declare function corporaOf(suites: EvalSuite[]): CorpusRef[];
+export declare function isUnderRoot(dir: string, root: string): boolean;
+export declare function checkCaseCorpora(cases: EvalCase[], projectDir: (project: string) => Promise<string | null>): Promise<void>;
 export declare function mergeSuites(suites: EvalSuite[]): EvalSuite;
+export declare function signTest(improved: number, worsened: number): number;
+export interface RankedCase {
+    id: string;
+    category: EvalCategory;
+    rank: number | null;
+}
+export declare function pairedChange(from: RankedCase[], to: RankedCase[]): PairedChange;
+export declare const LIVE_GROUP = "live";
 export declare class RetrievalEvaluator implements IRetrievalEvaluator {
-    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector): Promise<EvalRunResult>;
+    evaluate(suite: EvalSuite, search: SearchFn, inspect: IndexInspector, onCase?: (p: CaseProgress) => void): Promise<EvalOutcome>;
 }
-/** Pure comparison of two result files; prints a warning (never refuses) on mismatched conditions. */
 export declare function compare(baseline: EvalResultFile, current: EvalResultFile): CompareResult;