dsh-continual-evolve 0.11.0 → 0.12.0

package/lib/runtime-commands.js

@@ -1,115 +0,0 @@
-import { loadUsage, getUsageCount } from "./usage.js";
-import { loadGateRuntime, saveGateRuntime } from "./runtime.js";
-import { loadTokenUsage, renderTokenUsageReport } from "./token-usage.js";
-import { success } from "./command-util.js";
-/** `/evolve pause|resume` — the runtime switch is independent of registration. */
-export function executePauseResumeCommand(engine, sub, runtime) {
-    const pausing = sub === "pause";
-    const defaultEnabled = runtime.autoReview ?? false;
-    const current = loadGateRuntime(engine.baseDir, defaultEnabled);
-    if (pausing && current.paused) {
-        return success("automatic Memory Agent is already paused (no change).");
-    }
-    if (!pausing && current.enabled && !current.paused) {
-        return success("automatic Memory Agent is already running (no change).");
-    }
-    saveGateRuntime(engine.baseDir, pausing, pausing ? current.enabled : true);
-    return success(pausing
-        ? "automatic Memory Agent paused: no automatic memory extraction calls until /evolve resume. Manual evolve_* tools and /evolve commands keep working."
-        : "automatic Memory Agent resumed: extraction moments (compaction / goal-blocked / session-close drain) are live again.");
-}
-/** `/evolve status` — listener wiring plus per-store entry counts and retention. */
-export function executeStatusCommand(engine, sessionId, projectKey, runtime) {
-    const configuredDefault = runtime.autoReview === undefined ? "unknown" : runtime.autoReview ? "on" : "off";
-    const current = loadGateRuntime(engine.baseDir, runtime.autoReview ?? false);
-    const effective = current.paused
-        ? "PAUSED (resume with /evolve resume)"
-        : current.enabled
-            ? "Memory Agent running"
-            : "Memory Agent off (enable with /evolve resume)";
-    const gateLine = `gate: moment-driven Memory Agent listener registered · config default ${configuredDefault} · runtime ${effective}`;
-    const countEntries = (state) => Object.values(state.entries).reduce((n, byKind) => n + Object.keys(byKind).length, 0);
-    const lines = [gateLine];
-    lines.push(`stores: global ${countEntries(engine.load("global", undefined))} entries · local(${sessionId}) ${countEntries(engine.load("local", sessionId))} entries`);
-    if (projectKey) {
-        try {
-            lines[lines.length - 1] += ` · project ${countEntries(engine.load("project", projectKey))} entries`;
-        }
-        catch {
-            lines[lines.length - 1] += " · project (unavailable)";
-        }
-    }
-    const retention = engine.retention;
-    if (retention) {
-        lines.push(`retention: snapshots ${retention.snapshots} · refinements ${retention.refinements} · reviews ${retention.reviews} · token usage ${retention.tokenUsage} (historyRetain)`);
-    }
-    return success(lines.join("\n"));
-}
-/**
- * `/evolve usage` — injection counts per entry across the stores the human
- * can see (global + this session + this project), plus the exact direct-call
- * token report. Counts are per-session since the v2 usage shape — "in how
- * many sessions did this entry surface".
- */
-export function executeUsageCommand(engine, sessionId, projectKey) {
-    const store = loadUsage(engine.baseDir);
-    const rows = [];
-    const seen = new Set();
-    const collect = (state) => {
-        for (const kind of Object.keys(state.entries)) {
-            for (const entry of Object.values(state.entries[kind])) {
-                const key = `${kind}:${entry.id}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const count = getUsageCount(store, kind, entry.id);
-                rows.push({
-                    key,
-                    title: entry.title,
-                    count,
-                    ...(store.lastSession?.[`${kind}:${entry.id}`] ? { lastSession: store.lastSession[`${kind}:${entry.id}`] } : {}),
-                });
-            }
-        }
-    };
-    collect(engine.load("global", undefined));
-    collect(engine.load("local", sessionId));
-    if (projectKey) {
-        try {
-            collect(engine.load("project", projectKey));
-        }
-        catch {
-            // project store unavailable here — global+local still report
-        }
-    }
-    const liveKeys = new Set(rows.map((r) => r.key));
-    const orphaned = Object.keys(store.counts).filter((k) => !liveKeys.has(k)).length;
-    const total = rows.reduce((n, r) => n + r.count, 0);
-    const injected = rows.filter((r) => r.count > 0).sort((a, b) => b.count - a.count || (a.key < b.key ? -1 : 1));
-    const stale = rows.filter((r) => r.count === 0).sort((a, b) => (a.key < b.key ? -1 : 1));
-    const lines = [`injected entries: ${total} injections across ${injected.length} of ${rows.length} stored entries${orphaned > 0 ? ` (+${orphaned} historical key(s) for deleted entries)` : ""}`];
-    if (injected.length > 0) {
-        lines.push("injected (top 15):");
-        for (const row of injected.slice(0, 15)) {
-            lines.push(`  ${row.key} — ${row.count}× · ${row.title}${row.lastSession ? ` (last in ${row.lastSession})` : ""}`);
-        }
-        if (injected.length > 15) {
-            lines.push(`  … and ${injected.length - 15} more`);
-        }
-    }
-    else {
-        lines.push("injected: (none yet — nothing has surfaced into a session prompt)");
-    }
-    if (stale.length > 0) {
-        lines.push(`never injected (${stale.length}):`);
-        for (const row of stale.slice(0, 20)) {
-            lines.push(`  ${row.key} · ${row.title}`);
-        }
-        if (stale.length > 20) {
-            lines.push(`  … and ${stale.length - 20} more`);
-        }
-    }
-    lines.push("", ...renderTokenUsageReport(loadTokenUsage(engine.baseDir), engine.retention.tokenUsage));
-    return success(lines.join("\n"));
-}
-//# sourceMappingURL=runtime-commands.js.map

package/lib/runtime.d.ts

@@ -1,24 +0,0 @@
-/** On-disk runtime gate state. Version 2 adds an explicit enable bit. */
-export interface GateRuntime {
-    version: 2;
-    /** Whether the human has enabled automatic review. */
-    enabled: boolean;
-    /** Whether the human has explicitly paused automatic review. */
-    paused: boolean;
-    /** ISO timestamp of the last pause/resume write. */
-    updatedAt: string;
-}
-/** Full path of the runtime switch file. */
-export declare function runtimePath(baseDir: string): string;
-/**
- * Load the runtime switch. Missing, malformed, or legacy content uses the
- * supplied configured default and never throws; this is a trigger-path read.
- */
-export declare function loadGateRuntime(baseDir: string, defaultEnabled?: boolean): GateRuntime;
-/** Persist the runtime switch atomically (temp file + rename). */
-export declare function saveGateRuntime(baseDir: string, paused: boolean, enabled?: boolean): string;
-/** True while the human paused the automatic review gate. */
-export declare function isGatePaused(baseDir: string): boolean;
-/** Effective automatic-review state, including the explicit enable bit. */
-export declare function isGateEnabled(baseDir: string, defaultEnabled?: boolean): boolean;
-//# sourceMappingURL=runtime.d.ts.map

package/lib/runtime.js

@@ -1,87 +0,0 @@
-/**
- * Runtime gate switch: a small human-owned file that enables or pauses the
- * automatic review listener without editing the profile or restarting DSH.
- *
- * - file: `<baseDir>/evolve/runtime.json` (`{version: 2, enabled, paused, updatedAt}`)
- * - the file is consulted at every trigger and before scheduler execution;
- * - `/evolve pause` sets `paused`, `/evolve resume` sets `enabled=true` and
- *   clears the pause, while manual tools and commands remain independent;
- * - a missing or malformed file uses the caller's configured default. A
- *   legacy v1 `{paused}` file is readable and preserves its pause state.
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
-import { EVOLVE_DIR } from "./store.js";
-const RUNTIME_FILE = "runtime.json";
-/** Full path of the runtime switch file. */
-export function runtimePath(baseDir) {
-    return join(baseDir, EVOLVE_DIR, RUNTIME_FILE);
-}
-function state(enabled, paused) {
-    return { version: 2, enabled, paused, updatedAt: new Date(0).toISOString() };
-}
-/**
- * Load the runtime switch. Missing, malformed, or legacy content uses the
- * supplied configured default and never throws; this is a trigger-path read.
- */
-export function loadGateRuntime(baseDir, defaultEnabled = false) {
-    const path = runtimePath(baseDir);
-    if (!existsSync(path))
-        return state(defaultEnabled, false);
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
-            return state(defaultEnabled, false);
-        const record = raw;
-        const paused = record["paused"] === true;
-        // v1 had no enable bit. Its only meaningful state was pause, so retain
-        // the configured default when it is not paused.
-        const enabled = typeof record["enabled"] === "boolean" ? record["enabled"] : defaultEnabled;
-        return {
-            version: 2,
-            enabled,
-            paused,
-            updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : new Date(0).toISOString(),
-        };
-    }
-    catch {
-        return state(defaultEnabled, false);
-    }
-}
-/** Persist the runtime switch atomically (temp file + rename). */
-export function saveGateRuntime(baseDir, paused, enabled = true) {
-    const path = runtimePath(baseDir);
-    mkdirSync(join(baseDir, EVOLVE_DIR), { recursive: true });
-    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    const payload = { version: 2, enabled, paused, updatedAt: new Date().toISOString() };
-    writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-    try {
-        renameSync(tempPath, path);
-    }
-    finally {
-        if (existsSync(tempPath))
-            unlinkSync(tempPath);
-    }
-    return path;
-}
-/** True while the human paused the automatic review gate. */
-export function isGatePaused(baseDir) {
-    try {
-        return loadGateRuntime(baseDir).paused;
-    }
-    catch {
-        return false;
-    }
-}
-/** Effective automatic-review state, including the explicit enable bit. */
-export function isGateEnabled(baseDir, defaultEnabled = false) {
-    try {
-        const current = loadGateRuntime(baseDir, defaultEnabled);
-        return current.enabled && !current.paused;
-    }
-    catch {
-        return defaultEnabled;
-    }
-}
-//# sourceMappingURL=runtime.js.map

package/lib/score.d.ts

@@ -1,64 +0,0 @@
-/**
- * Code-owned scoring: aggregation and acceptance decisions. The model only
- * produces per-cell raw scores; every average and every accept/reject call
- * happens here, in deterministic code.
- */
-import type { CellScore, EvaluationEntry } from "./benchmark.js";
-export interface AggregateOptions {
-    /** A cell is "passed" if its raw score is at least this threshold. */
-    passThreshold: number;
-    /** Per-case regression tolerance: candidate may drop below reference by at most this much. */
-    regressionTolerance: number;
-    /**
-     * Failure-cell protocol (gap A2): a round with more failed cells than
-     * this is rejected outright — failed cells are NEVER averaged in as
-     * zeros. Default 0 (any failure rejects the round).
-     */
-    maxFailedCells: number;
-}
-export declare const DEFAULT_AGGREGATE: AggregateOptions;
-export interface AggregateResult extends Record<string, number | null> {
-    overall: number | null;
-    /** Count of failed cells (excluded from every mean). */
-    failed: number;
-    /** Total cells considered (ok + failed). */
-    total: number;
-    /** Gap C3: total wall-clock duration of all cells in milliseconds. */
-    totalDurationMs: number;
-}
-/**
- * Aggregate raw cells into code-owned per-case means + overall mean.
- * Failure-cell protocol (gap A2): failed cells are EXCLUDED from means and
- * counted separately — a crashed unit can never silently drag the mean down
- * like a zero. A case whose cells all failed reports null (no mean).
- */
-export declare function aggregate(cells: readonly CellScore[]): AggregateResult;
-export declare function entryFromCells(label: string, cells: readonly CellScore[], refinementId?: string): EvaluationEntry;
-export interface Decision {
-    accepted: boolean;
-    reasons: string[];
-}
-/** Human-readable decision report with per-case before → after deltas. */
-export declare function decisionReport(reference: EvaluationEntry, candidate: EvaluationEntry, decision: Decision): string[];
-/**
- * Gap A3 (version_changed semantics): detect cells whose case material
- * changed between the reference and candidate evaluation runs. A candidate
- * cell whose `caseHash` differs from the reference cell of the SAME case
- * means the statement/rubric was edited between the two runs — its score is
- * not comparable to the baseline and must not count toward the decision.
- *
- * The check is conservative: cells without a hash on either side (pre-A3
- * data) and cells already failed are left untouched. Mismatched cells are
- * returned re-marked as `failed` with a reason in notes, so aggregation
- * excludes them and the acceptance rule can reject the round.
- */
-export declare function flagMaterialDrift(reference: EvaluationEntry, candidateCells: readonly CellScore[]): CellScore[];
-/**
- * Non-regressive acceptance rule (Self-Harness style):
- * the candidate is accepted iff its overall mean is STRICTLY higher than the
- * reference, no case regresses by more than `regressionTolerance` points,
- * and neither side has more failed cells than `maxFailedCells` (failure-cell
- * protocol, gap A2 — a partial/invalid round is never accepted).
- */
-export declare function decide(reference: EvaluationEntry, candidate: EvaluationEntry, opts: AggregateOptions): Decision;
-//# sourceMappingURL=score.d.ts.map

package/lib/score.js

@@ -1,191 +0,0 @@
-export const DEFAULT_AGGREGATE = {
-    passThreshold: 60,
-    regressionTolerance: 0,
-    maxFailedCells: 0,
-};
-/**
- * Aggregate raw cells into code-owned per-case means + overall mean.
- * Failure-cell protocol (gap A2): failed cells are EXCLUDED from means and
- * counted separately — a crashed unit can never silently drag the mean down
- * like a zero. A case whose cells all failed reports null (no mean).
- */
-export function aggregate(cells) {
-    const byCase = new Map();
-    let failed = 0;
-    for (const cell of cells) {
-        if (cell.status === "failed") {
-            failed += 1;
-            continue;
-        }
-        const list = byCase.get(cell.caseId) ?? [];
-        list.push(clampScore(cell.score));
-        byCase.set(cell.caseId, list);
-    }
-    const perCase = {};
-    for (const [caseId, scores] of byCase) {
-        perCase[caseId] = mean(scores);
-    }
-    const all = [...byCase.values()].flat();
-    let totalDurationMs = 0;
-    for (const cell of cells) {
-        if (cell.durationMs !== undefined && cell.durationMs >= 0) {
-            totalDurationMs += cell.durationMs;
-        }
-    }
-    return {
-        ...perCase,
-        overall: all.length > 0 ? mean(all) : null,
-        failed,
-        total: cells.length,
-        totalDurationMs,
-    };
-}
-export function entryFromCells(label, cells, refinementId) {
-    const aggr = aggregate(cells);
-    return {
-        label,
-        ...(refinementId ? { refinementId } : {}),
-        createdAt: new Date().toISOString(),
-        cells: [...cells],
-        aggregate: aggr,
-        overall: aggr.overall,
-    };
-}
-/** Human-readable decision report with per-case before → after deltas. */
-export function decisionReport(reference, candidate, decision) {
-    const lines = [`overall: ${reference.overall ?? "?"} → ${candidate.overall ?? "?"}`];
-    // Per-case deltas over the actual evaluated cases only (aggregate() mixes
-    // case means with metadata keys like totalDurationMs — never render those
-    // as cases).
-    for (const caseId of new Set(reference.cells.map((cell) => cell.caseId))) {
-        const refScore = reference.aggregate[caseId];
-        if (refScore === null || refScore === undefined)
-            continue;
-        const candScore = candidate.aggregate[caseId];
-        const failedMark = isCaseFailed(reference, caseId) || isCaseFailed(candidate, caseId) ? " (failed)" : "";
-        lines.push(`  ${caseId}: ${refScore} → ${candScore ?? "?"}${failedMark}`);
-    }
-    const refFailed = reference.aggregate.failed ?? 0;
-    const candFailed = candidate.aggregate.failed ?? 0;
-    if (refFailed > 0 || candFailed > 0) {
-        lines.push(`failed cells: reference ${refFailed}/${reference.aggregate.total ?? 0} · candidate ${candFailed}/${candidate.aggregate.total ?? 0}`);
-    }
-    // Gap C3: show duration summary when available.
-    const refDuration = reference.aggregate.totalDurationMs ?? 0;
-    const candDuration = candidate.aggregate.totalDurationMs ?? 0;
-    if (refDuration > 0 || candDuration > 0) {
-        lines.push(`duration: ${formatDuration(refDuration)} → ${formatDuration(candDuration)}`);
-    }
-    lines.push(decision.accepted
-        ? "DECISION: ACCEPTED — overall improved, no regression"
-        : `DECISION: REJECTED — ${decision.reasons.join("; ")}`);
-    return lines;
-}
-/**
- * Gap A3 (version_changed semantics): detect cells whose case material
- * changed between the reference and candidate evaluation runs. A candidate
- * cell whose `caseHash` differs from the reference cell of the SAME case
- * means the statement/rubric was edited between the two runs — its score is
- * not comparable to the baseline and must not count toward the decision.
- *
- * The check is conservative: cells without a hash on either side (pre-A3
- * data) and cells already failed are left untouched. Mismatched cells are
- * returned re-marked as `failed` with a reason in notes, so aggregation
- * excludes them and the acceptance rule can reject the round.
- */
-export function flagMaterialDrift(reference, candidateCells) {
-    const referenceHashes = new Map();
-    for (const cell of reference.cells) {
-        if (cell.status !== "failed" && cell.caseHash !== undefined && !referenceHashes.has(cell.caseId)) {
-            referenceHashes.set(cell.caseId, cell.caseHash);
-        }
-    }
-    if (referenceHashes.size === 0) {
-        return [...candidateCells];
-    }
-    return candidateCells.map((cell) => {
-        if (cell.status === "failed" || cell.caseHash === undefined) {
-            return cell;
-        }
-        const refHash = referenceHashes.get(cell.caseId);
-        if (refHash !== undefined && refHash !== cell.caseHash) {
-            return {
-                ...cell,
-                status: "failed",
-                passed: false,
-                notes: `materials changed: case ${cell.caseId} hash ${cell.caseHash} ≠ reference ${refHash} (re-run the reference or fix the material)`,
-            };
-        }
-        return cell;
-    });
-}
-function isCaseFailed(entry, caseId) {
-    return entry.cells.some((cell) => cell.caseId === caseId && cell.status === "failed");
-}
-/**
- * Non-regressive acceptance rule (Self-Harness style):
- * the candidate is accepted iff its overall mean is STRICTLY higher than the
- * reference, no case regresses by more than `regressionTolerance` points,
- * and neither side has more failed cells than `maxFailedCells` (failure-cell
- * protocol, gap A2 — a partial/invalid round is never accepted).
- */
-export function decide(reference, candidate, opts) {
-    const reasons = [];
-    if (reference.overall === null || candidate.overall === null) {
-        return { accepted: false, reasons: ["reference or candidate evaluation is incomplete"] };
-    }
-    const refFailed = reference.aggregate.failed ?? 0;
-    const candFailed = candidate.aggregate.failed ?? 0;
-    if (refFailed > opts.maxFailedCells) {
-        reasons.push(`reference has ${refFailed} failed cells (max ${opts.maxFailedCells})`);
-    }
-    if (candFailed > opts.maxFailedCells) {
-        reasons.push(`candidate has ${candFailed} failed cells (max ${opts.maxFailedCells})`);
-    }
-    if (reasons.length > 0) {
-        return { accepted: false, reasons };
-    }
-    if (candidate.overall <= reference.overall) {
-        reasons.push(`overall not improved: ${candidate.overall} <= ${reference.overall}`);
-    }
-    // Per-case regression is judged ONLY over the cases that actually exist in
-    // the evaluation — aggregate() mixes per-case means with metadata keys
-    // (failed/total/totalDurationMs), and iterating raw keys would (and did)
-    // treat totalDurationMs as a case score, rejecting a candidate whose run
-    // merely took longer. Derived from reference.cells, never from the
-    // aggregate key set.
-    for (const caseId of new Set(reference.cells.map((cell) => cell.caseId))) {
-        const refScore = reference.aggregate[caseId];
-        if (refScore === null || refScore === undefined) {
-            continue; // case had no comparable mean (all cells failed) — nothing to regress
-        }
-        const candScore = candidate.aggregate[caseId];
-        if (candScore === null || candScore === undefined) {
-            reasons.push(`candidate missing case ${caseId}`);
-            continue;
-        }
-        if (candScore < refScore - opts.regressionTolerance) {
-            reasons.push(`case ${caseId} regressed: ${candScore} < ${refScore} - ${opts.regressionTolerance}`);
-        }
-    }
-    return { accepted: reasons.length === 0, reasons };
-}
-function mean(values) {
-    const sum = values.reduce((acc, value) => acc + value, 0);
-    return round2(sum / values.length);
-}
-function clampScore(score) {
-    if (!Number.isFinite(score))
-        return 0;
-    return Math.min(100, Math.max(0, score));
-}
-function round2(value) {
-    return Math.round(value * 100) / 100;
-}
-/** Gap C3: human-readable duration (ms → "1.2s" or "340ms"). */
-function formatDuration(ms) {
-    if (ms < 1000)
-        return `${Math.round(ms)}ms`;
-    return `${(ms / 1000).toFixed(1)}s`;
-}
-//# sourceMappingURL=score.js.map

package/lib/search.d.ts

@@ -1,83 +0,0 @@
-/**
- * Retrieval primitives for injection ranking: CJK-aware tokenization plus a
- * dependency-free, field-weighted BM25 scorer (ADR
- * `implemented/feature/2026-08-24-cjk-bigram-bm25-retrieval.md`).
- *
- * Why this shape:
- * - the old scorer tokenized whole CJK runs as single tokens compared for
- *   exact equality, so any rewording of a Chinese query missed every entry
- *   (「检索升级」 never matched 「全文检索方案」); overlapping character
- *   bigrams — the standard cjk_bigram analyzer shape (Elasticsearch/
- *   OpenSearch) — fix recall while keeping English behavior identical;
- * - raw hit counts weighted common words and distinctive terms alike; BM25's
- *   IDF separates them. We use Lucene's non-negative variant
- *   `ln(1 + (N - df + 0.5) / (df + 0.5))` so EVERY matched token scores > 0
- *   and unmatched documents score exactly 0, preserving rankEntries'
- *   "relevant outranks recent-but-irrelevant" ordering invariant;
- * - the index lifetime is one ranking call. Stores hold tens~hundreds of
- *   entries (measured full rebuild + score: single-digit milliseconds), the
- *   JSON state files stay the single source of truth, and npm installers
- *   carry zero native/WASM baggage — better-sqlite3 FTS5, sql.js, MiniSearch,
- *   FlexSearch were all evaluated and rejected (see the ADR's alternatives).
- */
-import type { HarnessEntry } from "./types.js";
-/** BM25 term-saturation constant (Okapi k1). */
-export declare const BM25_K1 = 1.5;
-/** BM25 document-length normalization constant (Okapi b). */
-export declare const BM25_B = 0.75;
-/** Multiplier for title-field matches (title hits outweigh body hits 2:1). */
-export declare const TITLE_FIELD_WEIGHT = 2;
-/**
- * Tokenize text for relevance scoring: lowercase ASCII runs become word
- * tokens; CJK runs become overlapping character bigrams (a single-character
- * run stays a unigram). Deterministic and allocation-light — safe to call per
- * injection build.
- *
- * @param text Arbitrary entry or query text.
- * @returns Tokens in occurrence order (duplicates kept; consumers dedupe when
- *          order-independent weighting is wanted).
- */
-export declare function tokenize(text: string): string[];
-/** Per-field corpus statistics for one ranking pass. */
-interface FieldStats {
-    /** Term-frequency map per document, positioned like {@link RelevanceIndex.positions}. */
-    readonly tfs: ReadonlyArray<ReadonlyMap<string, number>>;
-    /** Token count per document (this field's dl for BM25 length normalization). */
-    readonly lengths: ReadonlyArray<number>;
-    /** Document frequency per distinct term across the corpus. */
-    readonly df: ReadonlyMap<string, number>;
-    /** Average token count across the corpus (0 when empty). */
-    readonly averageLength: number;
-}
-/** Precomputed corpus statistics backing {@link relevanceScore}. */
-export interface RelevanceIndex {
-    /** Number of documents in the corpus. */
-    readonly size: number;
-    /** Identity positions: the exact entry objects the index was built from. */
-    readonly positions: ReadonlyMap<object, number>;
-    readonly titles: FieldStats;
-    readonly bodies: FieldStats;
-}
-/**
- * Build the corpus statistics (per-field tf, df, average length) for one
- * ranking call. Pure: the index reads its input snapshot and never mutates
- * the entries.
- *
- * @param entries The candidate entries being ranked this call.
- * @returns An index that answers {@link relevanceScore} for exactly these
- *          entries (identity-keyed).
- */
-export declare function buildRelevanceIndex(entries: readonly HarnessEntry[]): RelevanceIndex;
-/**
- * Field-weighted BM25 score of `entry` against `query` within `index`:
- * `TITLE_FIELD_WEIGHT × bm25(title) + bm25(body)`. Query tokens are deduped,
- * so repeating a word adds no weight.
- *
- * @returns A score > 0 when at least one query token occurs in the entry
- *          (either field), and exactly 0 otherwise — the property rankEntries'
- *          relevance-first ordering relies on. Never throws; an entry outside
- *          the index simply scores 0.
- */
-export declare function relevanceScore(index: RelevanceIndex, entry: HarnessEntry, query: string): number;
-export {};
-//# sourceMappingURL=search.d.ts.map