quarry_eval.py

#!/usr/bin/env python3
"""Evaluate a SentenceTransformers retriever on Quarry.

This reuses the localizer dev-eval representation: child and parent-summary texts are
encoded independently, then each corpus vector is
``normalize(alpha * child + (1 - alpha) * parent)``.
"""
from __future__ import annotations

import argparse
from collections import defaultdict
from contextlib import nullcontext
from dataclasses import dataclass, replace
import gc
import hashlib
import json
import multiprocessing as mp
import os
from pathlib import Path
from queue import Empty
import shutil
import sqlite3
import sys
import time
from typing import Iterable

import numpy as np

HARNESS_ROOT = Path(__file__).resolve().parent / "harness"
if str(HARNESS_ROOT) not in sys.path:
    sys.path.insert(0, str(HARNESS_ROOT))

from localize_sft_core import (  # noqa: E402
    swerank_document_text as swerank_document_text,
    swerank_method_parent as swerank_method_parent,
)

from eval_nano_local import (  # noqa: E402
    bucketed_encode,
    collect_components,
    compose_parent_matrix,
)

PATCHPOINT_RETRIEVAL_INSTRUCTION = (
    "Given a github issue, identify the code that needs to be changed to fix the issue."
)
BGE_CODE_TOKENIZER_CONTRACT = "bge-code-eos-fix-v1"


@dataclass(frozen=True)
class QueryWork:
    repo: str
    revision: str
    task_id: str
    query_id: str
    query: str
    language: str
    gold_chunks: frozenset[int]
    gold_files: frozenset[str]


@dataclass(frozen=True)
class DocumentVectors:
    """One logical document matrix backed by a base cache and optional appended rows."""

    base: np.ndarray
    overlay: np.ndarray | None = None

    @property
    def shape(self) -> tuple[int, int]:
        overlay_rows = 0 if self.overlay is None else int(self.overlay.shape[0])
        return int(self.base.shape[0]) + overlay_rows, int(self.base.shape[1])

    def take(self, rows: np.ndarray) -> np.ndarray:
        if self.overlay is None:
            return self.base[rows]
        base_rows = int(self.base.shape[0])
        output = np.empty((len(rows), self.shape[1]), dtype=np.float32)
        from_base = rows < base_rows
        if np.any(from_base):
            output[from_base] = self.base[rows[from_base]]
        if np.any(~from_base):
            output[~from_base] = self.overlay[rows[~from_base] - base_rows]
        return output


def read_jsonl(path: Path) -> list[dict]:
    with path.open(encoding="utf-8") as handle:
        return [json.loads(line) for line in handle if line.strip()]


def row_key(row: dict) -> tuple[str, str, str]:
    return str(row["repo"]), str(row["task_id"]), str(row["query_id"])


def validate_cuda_runtime(devices: list[str], expected_gpu_uuid: str | None) -> None:
    cuda_devices = [device for device in devices if device.startswith("cuda")]
    if not cuda_devices:
        return
    import torch

    if not torch.cuda.is_available():
        raise RuntimeError("CUDA devices were requested but torch cannot access the NVIDIA driver")
    expected_uuids = (
        [value.strip() for value in expected_gpu_uuid.split(",") if value.strip()]
        if expected_gpu_uuid
        else []
    )
    if expected_uuids and len(expected_uuids) != len(cuda_devices):
        raise RuntimeError(
            f"expected {len(cuda_devices)} GPU UUIDs for {cuda_devices}, got {expected_uuids}"
        )
    visible: list[dict[str, object]] = []
    for position, device in enumerate(cuda_devices):
        index = int(device.partition(":")[2] or 0)
        if index >= torch.cuda.device_count():
            raise RuntimeError(
                f"requested {device}, but only {torch.cuda.device_count()} CUDA devices are visible"
            )
        properties = torch.cuda.get_device_properties(index)
        actual_uuid = f"GPU-{properties.uuid}"
        visible.append(
            {
                "device": device,
                "name": properties.name,
                "uuid": actual_uuid,
                "memory_bytes": properties.total_memory,
            }
        )
        expected_uuid = expected_uuids[position] if expected_uuids else None
        if expected_uuid and actual_uuid.lower() != expected_uuid.lower():
            raise RuntimeError(
                f"{device} maps to {actual_uuid}, expected UUID {expected_uuid}"
            )
    print(json.dumps({"event": "cuda_preflight", "visible": visible}), flush=True)


def _model_loading_encode_worker(
    device: str,
    model_path: str,
    max_seq_length: int,
    model_profile: str,
    hf_instruct_family: str | None,
    truncate_dim: int | None,
    input_queue,
    output_queue,
    ready_queue,
) -> None:
    from sentence_transformers import SentenceTransformer

    try:
        model, event, _query_prompt, _document_prompt = _load_pool_worker_model(
            device,
            model_path,
            max_seq_length,
            model_profile,
            hf_instruct_family,
            truncate_dim,
        )
    except BaseException as exc:
        ready_queue.put(
            {
                "event": "pool_worker_error",
                "device": device,
                "error_type": exc.__class__.__name__,
                "error": str(exc),
            }
        )
        raise
    ready_queue.put(event)
    encode_worker = getattr(SentenceTransformer, "_encode_multi_process_worker", None)
    if encode_worker is None:
        encode_worker = getattr(SentenceTransformer, "_multi_process_worker")
    encode_worker(device, model, input_queue, output_queue)


def start_model_loading_pool(
    model_path: str,
    max_seq_length: int,
    devices: list[str],
    model_profile: str,
    hf_instruct_family: str | None,
    truncate_dim: int | None,
    expected_query_prompt: str | None,
    expected_document_prompt: str | None,
) -> dict:
    context = mp.get_context("spawn")
    input_queue = context.Queue()
    output_queue = context.Queue()
    ready_queue = context.Queue()
    processes = []
    for device in devices:
        process = context.Process(
            target=_model_loading_encode_worker,
            args=(
                device,
                model_path,
                max_seq_length,
                model_profile,
                hf_instruct_family,
                truncate_dim,
                input_queue,
                output_queue,
                ready_queue,
            ),
            daemon=True,
        )
        process.start()
        processes.append(process)
        try:
            event = ready_queue.get(timeout=300)
        except Empty as exc:
            for running in processes:
                running.terminate()
            raise RuntimeError(f"model worker on {device} did not report ready") from exc
        try:
            validate_pool_worker_profile_event(
                event,
                expected_device=device,
                expected_query_prompt=expected_query_prompt,
                expected_document_prompt=expected_document_prompt,
            )
        except Exception:
            for running in processes:
                running.terminate()
            raise
        print(json.dumps(event), flush=True)
        print(json.dumps({"event": "model_worker_ready", "device": device}), flush=True)
    return {"input": input_queue, "output": output_queue, "processes": processes}


def resolve_gold_chunks(
    db_dir: Path, query_rows: list[dict], gold_rows: list[dict], tasks: list[dict]
) -> tuple[list[QueryWork], dict]:
    if [row_key(row) for row in query_rows] != [row_key(row) for row in gold_rows]:
        raise ValueError("queries and preimage gold rows are not exactly aligned")
    language_by_task = {str(row["task_id"]): str(row["language"]) for row in tasks}
    pairs_by_repo: dict[str, list[tuple[str, dict, dict]]] = defaultdict(list)
    for query, gold in zip(query_rows, gold_rows, strict=True):
        if str(query["revision"]) != str(gold["revision"]):
            raise ValueError(f"revision mismatch for {row_key(query)}")
        pairs_by_repo[str(query["repo"])].append((str(query["revision"]), query, gold))

    resolved: list[QueryWork] = []
    canonical_units = 0
    for repo, pairs in sorted(pairs_by_repo.items()):
        db_path = db_dir / repo / "embeddings.db"
        if not db_path.is_file():
            raise FileNotFoundError(f"missing PatchPoint DB: {db_path}")
        connection = sqlite3.connect(db_path)
        try:
            requested_ids = sorted(
                {
                    int(chunk_id)
                    for _revision, _query, gold in pairs
                    for chunk_id in gold.get("positive_chunk_ids", [])
                }
            )
            connection.execute("CREATE TEMP TABLE requested_gold (chunk_id INTEGER PRIMARY KEY)")
            connection.executemany(
                "INSERT INTO requested_gold (chunk_id) VALUES (?)",
                ((chunk_id,) for chunk_id in requested_ids),
            )
            rows = connection.execute(
                """SELECT c.chunk_id, c.revision, c.path, c.codeunit_name
                   FROM chunks c JOIN requested_gold r ON r.chunk_id = c.chunk_id"""
            )
            chunks = {
                int(chunk_id): (str(chunk_revision), str(path), str(fqmn))
                for chunk_id, chunk_revision, path, fqmn in rows
            }
        finally:
            connection.close()

        for revision, query, gold in pairs:
            gold_chunks = {int(chunk_id) for chunk_id in gold.get("positive_chunk_ids", [])}
            if not gold_chunks:
                raise ValueError(f"query {query['query_id']} has no canonical corpus-chunk gold")
            missing = sorted(gold_chunks - chunks.keys())
            if missing:
                raise ValueError(f"query {query['query_id']} references missing chunk IDs {missing[:10]}")
            wrong_revisions = sorted(
                chunk_id for chunk_id in gold_chunks if chunks[chunk_id][0] != revision
            )
            if wrong_revisions:
                raise ValueError(
                    f"query {query['query_id']} has chunk IDs from another revision: "
                    f"{wrong_revisions[:10]}"
                )
            for unit in gold.get("positive_units", []):
                fqmn = str(unit.get("fqmn") or "")
                unit_chunks = {int(chunk_id) for chunk_id in unit.get("chunk_ids", [])}
                if not fqmn or not unit_chunks:
                    raise ValueError(
                        f"query {query['query_id']} has a gold unit without FQMN/chunk IDs"
                    )
                if not unit_chunks <= gold_chunks:
                    raise ValueError(
                        f"query {query['query_id']} unit chunk IDs are absent from positive_chunk_ids"
                    )
                mismatched = sorted(
                    chunk_id
                    for chunk_id in unit_chunks
                    if chunks[chunk_id][2] != fqmn or chunks[chunk_id][1] != str(unit["path"])
                )
                if mismatched:
                    raise ValueError(
                        f"query {query['query_id']} has chunk/FQMN/path mismatch: {mismatched[:10]}"
                    )
                canonical_units += 1
            task_id = str(query["task_id"])
            resolved.append(
                QueryWork(
                    repo=repo,
                    revision=revision,
                    task_id=task_id,
                    query_id=str(query["query_id"]),
                    query=str(query["query"]),
                    language=language_by_task[task_id],
                    gold_chunks=frozenset(gold_chunks),
                    gold_files=frozenset(chunks[chunk_id][1] for chunk_id in gold_chunks),
                )
            )
    return resolved, {
        "queries": len(resolved),
        "canonical_units": canonical_units,
        "missing_chunk_ids": 0,
        "fqmn_mismatches": 0,
    }


def retain_function_retrievable_queries(
    work: list[QueryWork], db_dir: Path
) -> tuple[list[QueryWork], dict]:
    ids_by_repo: dict[str, set[int]] = defaultdict(set)
    for item in work:
        ids_by_repo[item.repo].update(item.gold_chunks)
    metadata: dict[tuple[str, int], tuple[str, str]] = {}
    for repo, chunk_ids in sorted(ids_by_repo.items()):
        connection = sqlite3.connect(db_dir / repo / "embeddings.db")
        try:
            ordered = sorted(chunk_ids)
            for start in range(0, len(ordered), 500):
                page = ordered[start : start + 500]
                placeholders = ",".join("?" for _ in page)
                rows = connection.execute(
                    f"""SELECT chunk_id, path, codeunit_name FROM chunks
                        WHERE chunk_id IN ({placeholders})""",
                    page,
                )
                for chunk_id, path, codeunit_name in rows:
                    metadata[(repo, int(chunk_id))] = (str(path), str(codeunit_name))
        finally:
            connection.close()
    retained: list[QueryWork] = []
    mixed_queries = 0
    dropped_queries = 0
    removed_gold_ids: set[tuple[str, int]] = set()
    for item in work:
        function_chunks = frozenset(
            chunk_id
            for chunk_id in item.gold_chunks
            if metadata[(item.repo, chunk_id)][1] != "__chunkless_file_summary__"
        )
        removed = item.gold_chunks - function_chunks
        removed_gold_ids.update((item.repo, chunk_id) for chunk_id in removed)
        if not function_chunks:
            dropped_queries += 1
            continue
        if removed:
            mixed_queries += 1
        retained.append(
            replace(
                item,
                gold_chunks=function_chunks,
                gold_files=frozenset(
                    metadata[(item.repo, chunk_id)][0] for chunk_id in function_chunks
                ),
            )
        )
    audit = {
        "input_queries": len(work),
        "retained_queries": len(retained),
        "dropped_chunkless_only_queries": dropped_queries,
        "mixed_queries_with_chunkless_gold_removed": mixed_queries,
        "distinct_chunkless_gold_ids_removed": len(removed_gold_ids),
    }
    print(json.dumps({"event": "function_retrievable_slice", **audit}), flush=True)
    return retained, audit


def cache_digest(args: argparse.Namespace, work: list[QueryWork]) -> str:
    payload = {
        "version": 6,
        "model": str(Path(args.model).resolve()) if Path(args.model).exists() else args.model,
        "model_profile": args.model_profile,
        "hf_instruct_family": (
            args.hf_instruct_family if args.model_profile == "hf-instruct" else None
        ),
        "max_seq_length": args.max_seq_length,
        "truncate_dim": args.truncate_dim,
        "document_shape": args.document_shape,
        "function_retrievable_only": args.function_retrievable_only,
        "tokenizer_contract": tokenizer_contract_marker(args),
        "db_dir": str(args.db_dir.resolve()),
        "final_dir": str(args.final_dir.resolve()),
        "query_keys": [(item.repo, item.query_id, item.revision) for item in work],
    }
    return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()[:24]


def document_cache_identity(args: argparse.Namespace) -> str:
    payload = {
        "model": str(Path(args.model).resolve()) if Path(args.model).exists() else args.model,
        "model_profile": args.model_profile,
        "hf_instruct_family": (
            args.hf_instruct_family if args.model_profile == "hf-instruct" else None
        ),
        "max_seq_length": args.max_seq_length,
        "truncate_dim": args.truncate_dim,
        "document_shape": args.document_shape,
        "tokenizer_contract": tokenizer_contract_marker(args),
    }
    return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()[:24]


def tokenizer_contract_marker(args: argparse.Namespace) -> str | None:
    if args.model_profile == "hf-instruct" and args.hf_instruct_family == "bge-code":
        return BGE_CODE_TOKENIZER_CONTRACT
    return None


def find_pooling_module(model):
    for module in model:
        if module.__class__.__name__ == "Pooling":
            return module
    raise ValueError("hf-instruct profile expected a SentenceTransformers Pooling module")


def pooling_audit(pooling) -> dict[str, object]:
    pooling_mode = getattr(pooling, "pooling_mode", None)
    return {
        "pooling_mode": pooling_mode,
        "cls": bool(getattr(pooling, "pooling_mode_cls_token", False))
        or pooling_mode == "cls",
        "mean": bool(getattr(pooling, "pooling_mode_mean_tokens", False))
        or pooling_mode == "mean",
        "max": bool(getattr(pooling, "pooling_mode_max_tokens", False))
        or pooling_mode == "max",
        "mean_sqrt_len": bool(
            getattr(pooling, "pooling_mode_mean_sqrt_len_tokens", False)
        )
        or pooling_mode == "mean_sqrt_len_tokens",
        "weightedmean": bool(
            getattr(pooling, "pooling_mode_weightedmean_tokens", False)
        )
        or pooling_mode == "weightedmean",
        "lasttoken": bool(getattr(pooling, "pooling_mode_lasttoken", False))
        or pooling_mode == "lasttoken",
        "include_prompt": bool(getattr(pooling, "include_prompt", False)),
        "word_embedding_dimension": (
            getattr(pooling, "word_embedding_dimension", None)
            or getattr(pooling, "pooling_output_dimension", None)
        ),
    }


def require_last_token_pooling(model, family: str) -> dict[str, object]:
    pooling = find_pooling_module(model)
    actual = pooling_audit(pooling)
    expected_enabled = {
        "cls": False,
        "mean": False,
        "max": False,
        "mean_sqrt_len": False,
        "weightedmean": False,
        "lasttoken": True,
        "include_prompt": True,
    }
    mismatches = {
        key: actual[key]
        for key, expected in expected_enabled.items()
        if actual[key] != expected
    }
    if mismatches:
        raise ValueError(
            f"hf-instruct {family} profile expected last-token-only pooling with "
            f"include_prompt=true; actual={actual!r}"
        )
    return actual


def resolve_hf_instruct_profile(
    model, family: str, attn_implementation: str
) -> tuple[str, None]:
    bundled_prompts = dict(model.prompts)
    pooling = require_last_token_pooling(model, family)
    tokenizer_contract = None
    if family == "qwen3":
        expected_bundled_prompts = {
            "query": (
                "Instruct: Given a web search query, retrieve relevant passages that "
                "answer the query\nQuery:"
            ),
            "document": "",
        }
        if bundled_prompts != expected_bundled_prompts:
            raise ValueError(
                "hf-instruct qwen3 prompt mismatch: "
                f"expected={expected_bundled_prompts!r}, actual={bundled_prompts!r}"
            )
        query_prompt_text = f"Instruct: {PATCHPOINT_RETRIEVAL_INSTRUCTION}\nQuery:"
    elif family == "bge-code":
        tokenizer_contract = apply_bge_code_tokenizer_contract(model.tokenizer)
        non_empty_prompts = {
            name: prompt for name, prompt in bundled_prompts.items() if prompt
        }
        if non_empty_prompts:
            raise ValueError(
                "hf-instruct bge-code expects empty bundled ST prompts; "
                f"actual={bundled_prompts!r}"
            )
        query_prompt_text = f"<instruct>{PATCHPOINT_RETRIEVAL_INSTRUCTION}\n<query>"
    else:
        raise ValueError(f"unknown hf-instruct family {family!r}")
    model.prompts["query"] = query_prompt_text
    print(
        json.dumps(
            {
                "event": "hf_instruct_profile_resolved",
                "family": family,
                "bundled_prompts": bundled_prompts,
                "query_prompt": model.prompts["query"],
                "document_prompt": None,
                "pooling": pooling,
                "padding_side": getattr(model.tokenizer, "padding_side", None),
                "tokenizer_contract": tokenizer_contract,
                "attn_implementation": attn_implementation,
            }
        ),
        flush=True,
    )
    return "query", None


def apply_bge_code_tokenizer_contract(tokenizer) -> dict[str, object]:
    eos_token_id = getattr(tokenizer, "eos_token_id", None)
    if eos_token_id is None:
        raise ValueError("hf-instruct bge-code tokenizer must define eos_token_id")

    tokenizer.add_eos_token = True
    update_post_processor = getattr(tokenizer, "update_post_processor", None)
    if callable(update_post_processor):
        update_post_processor()
    tokenizer.padding_side = "left"

    examples = [
        "hello world",
        "def f(x): return x + 1",
        "SELECT * FROM users WHERE id = 1",
    ]
    observed_last_ids = []
    for example in examples:
        input_ids = tokenizer(example, add_special_tokens=True)["input_ids"]
        if not input_ids or input_ids[-1] != eos_token_id:
            raise ValueError(
                "hf-instruct bge-code tokenizer failed to append eos: "
                f"text={example!r}, tail={input_ids[-5:]}"
            )
        observed_last_ids.append(input_ids[-1])

    truncation_length = 5
    truncated_ids = tokenizer(
        " ".join(["token"] * 64),
        add_special_tokens=True,
        truncation=True,
        max_length=truncation_length,
    )["input_ids"]
    if len(truncated_ids) != truncation_length or truncated_ids[-1] != eos_token_id:
        raise ValueError(
            "hf-instruct bge-code tokenizer truncation must preserve final eos: "
            f"max_length={truncation_length}, ids={truncated_ids}"
        )

    return {
        "marker": BGE_CODE_TOKENIZER_CONTRACT,
        "class": tokenizer.__class__.__name__,
        "module": tokenizer.__class__.__module__,
        "eos_token_id": eos_token_id,
        "add_eos_token": bool(getattr(tokenizer, "add_eos_token", False)),
        "padding_side": getattr(tokenizer, "padding_side", None),
        "observed_last_ids": observed_last_ids,
        "truncated_length": len(truncated_ids),
        "truncated_last_id": truncated_ids[-1],
    }


def configure_model_profile(
    model,
    model_profile: str,
    hf_instruct_family: str | None,
    attn_implementation: str | None,
) -> tuple[str, str | None]:
    if model_profile == "voyage":
        expected = {
            "query": "Represent the query for retrieving supporting documents: ",
            "document": "Represent the document for retrieval: ",
        }
        actual = {name: model.prompts.get(name) for name in expected}
        if actual != expected:
            raise ValueError(f"Voyage prompt mismatch: expected={expected!r}, actual={actual!r}")
        return "query", "document"
    if model_profile == "swerank-small":
        expected_query = "Represent this query for searching relevant code: "
        if model.prompts.get("query") != expected_query:
            raise ValueError(
                f"SweRank-small query prompt mismatch: expected={expected_query!r}, "
                f"actual={model.prompts.get('query')!r}"
            )
        return "query", None
    if model_profile == "granite":
        expected = {
            "query": "Given a GitHub issue, retrieve code that must be changed to fix it.\nQuery: ",
            "document": "Passage: Code chunk from repository.\n",
        }
        actual = {name: model.prompts.get(name) for name in expected}
        if actual != expected:
            raise ValueError(f"Granite prompt mismatch: expected={expected!r}, actual={actual!r}")
        return "query", "document"
    if model_profile == "nemotron-embed":
        # Nemotron-3-Embed ships e5-style prefixes in its ST config; verify and use
        # them as-is (mean pooling, L2-normalized output are checkpoint-configured).
        expected = {"query": "query: ", "document": "passage: "}
        actual = {name: model.prompts.get(name) for name in expected}
        if actual != expected:
            raise ValueError(
                f"Nemotron prompt mismatch: expected={expected!r}, actual={actual!r}"
            )
        return "query", "document"
    if model_profile == "hf-instruct":
        if hf_instruct_family is None:
            raise ValueError("--model-profile hf-instruct requires --hf-instruct-family")
        if attn_implementation is None:
            raise ValueError("hf-instruct requires an explicit attention implementation")
        return resolve_hf_instruct_profile(model, hf_instruct_family, attn_implementation)
    expected_query = (
        "Instruct: Given a github issue, identify the code that needs to be changed "
        "to fix the issue.\nQuery: "
    )
    if model.prompts.get("query") != expected_query:
        raise ValueError(
            f"SweRank-large query prompt mismatch: expected={expected_query!r}, "
            f"actual={model.prompts.get('query')!r}"
        )
    return "query", None


def _model_load_kwargs(
    profile: str,
    family: str | None,
    truncate_dim: int | None,
    device: str | None,
    torch_module,
) -> tuple[dict[str, object], str | None]:
    model_kwargs: dict[str, object] = {"torch_dtype": torch_module.bfloat16}
    attn_implementation = None
    if profile in {"swerank-large", "hf-instruct"}:
        attn_implementation = "sdpa"
        model_kwargs["attn_implementation"] = attn_implementation
    sentence_transformer_kwargs = {
        # BGE-Code's remote tokenizer is still transformers-5-incompatible after
        # aliasing the removed qwen2 fast module; repair the stock tokenizer below.
        "trust_remote_code": not is_bge_code_hf_instruct_profile(profile, family),
        "model_kwargs": model_kwargs,
        "truncate_dim": truncate_dim,
    }
    if device is not None:
        sentence_transformer_kwargs["device"] = device
    return sentence_transformer_kwargs, attn_implementation


def _build_profiled_model_with_constructor(
    sentence_transformer_cls,
    torch_module,
    model_path: str,
    profile: str,
    family: str | None,
    max_seq_length: int,
    device: str | None,
    truncate_dim: int | None,
):
    sentence_transformer_kwargs, attn_implementation = _model_load_kwargs(
        profile, family, truncate_dim, device, torch_module
    )
    model = sentence_transformer_cls(model_path, **sentence_transformer_kwargs)
    model.max_seq_length = max_seq_length
    if profile == "swerank-large" and model.tokenizer.padding_side != "left":
        raise ValueError(
            "SweRank-large requires the official tokenizer's left-padding contract, "
            f"got {model.tokenizer.padding_side!r}"
        )
    query_prompt, document_prompt = configure_model_profile(
        model, profile, family, attn_implementation
    )
    return model, query_prompt, document_prompt


def build_profiled_model(
    model_path: str,
    profile: str,
    family: str | None,
    max_seq_length: int,
    device: str | None,
    truncate_dim: int | None,
):
    import torch
    from sentence_transformers import SentenceTransformer

    return _build_profiled_model_with_constructor(
        SentenceTransformer,
        torch,
        model_path,
        profile,
        family,
        max_seq_length,
        device,
        truncate_dim,
    )


def load_sentence_transformer(args: argparse.Namespace):
    device = "cpu" if args.load_per_worker_pool else None
    return build_profiled_model(
        args.model,
        args.model_profile,
        args.hf_instruct_family,
        args.max_seq_length,
        device,
        args.truncate_dim,
    )


def is_bge_code_hf_instruct_profile(profile: str, family: str | None) -> bool:
    return profile == "hf-instruct" and family == "bge-code"


def is_bge_code_hf_instruct(args: argparse.Namespace) -> bool:
    return is_bge_code_hf_instruct_profile(args.model_profile, args.hf_instruct_family)


def resolved_prompt_text(model, prompt_name: str | None) -> str | None:
    if prompt_name is None:
        return None
    return model.prompts.get(prompt_name)


def bge_code_eos_last_token_id_ok(model) -> bool:
    eos_token_id = getattr(model.tokenizer, "eos_token_id", None)
    if eos_token_id is None:
        return False
    input_ids = model.tokenizer("pool eos probe", add_special_tokens=True)["input_ids"]
    return bool(input_ids) and input_ids[-1] == eos_token_id


def pool_worker_profile_event(
    model,
    device: str,
    query_prompt_name: str | None,
    document_prompt_name: str | None,
    profile: str,
    family: str | None,
) -> dict[str, object]:
    eos_last_token_id_ok = (
        bge_code_eos_last_token_id_ok(model)
        if is_bge_code_hf_instruct_profile(profile, family)
        else None
    )
    return {
        "event": "pool_worker_profile",
        "device": device,
        "query_prompt": resolved_prompt_text(model, query_prompt_name),
        "document_prompt": resolved_prompt_text(model, document_prompt_name),
        "eos_last_token_id_ok": eos_last_token_id_ok,
    }


def validate_pool_worker_profile_event(
    event: dict[str, object],
    *,
    expected_device: str,
    expected_query_prompt: str | None,
    expected_document_prompt: str | None,
) -> None:
    if event.get("event") == "pool_worker_error":
        raise RuntimeError(
            f"model worker {event.get('device')} failed during load: "
            f"{event.get('error_type')}: {event.get('error')}"
        )
    if event.get("event") != "pool_worker_profile":
        raise RuntimeError(f"unexpected model worker readiness event: {event!r}")
    if event.get("device") != expected_device:
        raise RuntimeError(
            f"model worker readiness mismatch: expected {expected_device}, "
            f"got {event.get('device')}"
        )
    if event.get("query_prompt") != expected_query_prompt:
        raise RuntimeError(
            "pool worker query prompt differs from main process: "
            f"expected={expected_query_prompt!r}, actual={event.get('query_prompt')!r}, "
            f"device={expected_device}"
        )
    if event.get("document_prompt") != expected_document_prompt:
        raise RuntimeError(
            "pool worker document prompt differs from main process: "
            f"expected={expected_document_prompt!r}, "
            f"actual={event.get('document_prompt')!r}, device={expected_device}"
        )
    if event.get("eos_last_token_id_ok") is False:
        raise RuntimeError(
            f"pool worker bge-code EOS contract failed on {expected_device}: {event!r}"
        )


def _load_pool_worker_model(
    device: str,
    model_path: str,
    max_seq_length: int,
    model_profile: str,
    hf_instruct_family: str | None,
    truncate_dim: int | None,
    *,
    sentence_transformer_cls=None,
    torch_module=None,
):
    if sentence_transformer_cls is None or torch_module is None:
        import torch
        from sentence_transformers import SentenceTransformer

        if sentence_transformer_cls is None:
            sentence_transformer_cls = SentenceTransformer
        if torch_module is None:
            torch_module = torch
    # Construct on CPU: without an explicit device, SentenceTransformers places the
    # full model on cuda:0 before .to(device) moves it, so every pool worker
    # transiently double-occupies GPU 0 -- fatal once resident + transient copies
    # exceed the card (observed on 32GB: worker 2 OOMs against worker 0's weights).
    model, query_prompt, document_prompt = _build_profiled_model_with_constructor(
        sentence_transformer_cls,
        torch_module,
        model_path,
        model_profile,
        hf_instruct_family,
        max_seq_length,
        "cpu",
        truncate_dim,
    )
    model.to(device)
    event = pool_worker_profile_event(
        model,
        device,
        query_prompt,
        document_prompt,
        model_profile,
        hf_instruct_family,
    )
    return model, event, query_prompt, document_prompt


def encode_smoke(args: argparse.Namespace) -> int:
    model, query_prompt, document_prompt = load_sentence_transformer(args)
    target_device = args.direct_device or args.devices.split(",")[0]
    query_texts = ["Issue: the parser ignores quoted values in config files."]
    document_texts = ["src/config.py\ndef parse_value(raw):\n    return raw.strip()"]
    pool = None
    if args.load_per_worker_pool:
        import torch

        model.to("cpu")
        torch.cuda.empty_cache()
        pool = start_model_loading_pool(
            args.model,
            args.max_seq_length,
            args.devices.split(","),
            args.model_profile,
            args.hf_instruct_family,
            args.truncate_dim,
            resolved_prompt_text(model, query_prompt),
            resolved_prompt_text(model, document_prompt),
        )
        try:
            query_vector = bucketed_encode(model, pool, query_texts, query_prompt)
            document_vector = bucketed_encode(model, pool, document_texts, document_prompt)
        finally:
            model.stop_multi_process_pool(pool)
    else:
        model.to(target_device)
        query_vector = model.encode(
            query_texts,
            prompt_name=query_prompt,
            batch_size=1,
            normalize_embeddings=True,
            show_progress_bar=False,
        )
        document_vector = model.encode(
            document_texts,
            prompt_name=document_prompt,
            batch_size=1,
            normalize_embeddings=True,
            show_progress_bar=False,
        )
    print(
        json.dumps(
            {
                "event": "encode_smoke_complete",
                "device": target_device,
                "query_prompt_name": query_prompt,
                "document_prompt_name": document_prompt,
                "query_shape": list(query_vector.shape),
                "document_shape": list(document_vector.shape),
                "query_norm": float(np.linalg.norm(query_vector[0])),
                "document_norm": float(np.linalg.norm(document_vector[0])),
            }
        ),
        flush=True,
    )
    return 0


def collect_swerank_components(
    work: list[QueryWork], db_dir: Path
) -> tuple[list[str], dict[tuple[str, str], int], list, dict]:
    revisions_by_repo: dict[str, set[str]] = defaultdict(set)
    for item in work:
        revisions_by_repo[item.repo].add(item.revision)
    texts: dict[str, int] = {}
    unique_texts: list[str] = []
    text_index: dict[tuple[str, str], int] = {}
    composes: list[tuple[str, str, str, str]] = []
    methods = 0
    top_level = 0
    for repo, revisions in sorted(revisions_by_repo.items()):
        connection = sqlite3.connect(db_dir / repo / "embeddings.db")
        try:
            placeholders = ",".join("?" for _ in revisions)
            rows = connection.execute(
                f"""SELECT vector_key, path, codeunit_name, text, parent_text
                    FROM chunks WHERE revision IN ({placeholders})""",
                sorted(revisions),
            )
            seen: set[str] = set()
            for vector_key, path, codeunit_name, source_text, parent_text in rows:
                vector_key = str(vector_key)
                if vector_key in seen:
                    continue
                seen.add(vector_key)
                if str(codeunit_name) == "__chunkless_file_summary__":
                    continue
                document, is_method = swerank_document_text(
                    str(path), str(codeunit_name), str(source_text), str(parent_text)
                )
                if is_method:
                    methods += 1
                else:
                    top_level += 1
                document_key = "swerank-v1:" + hashlib.sha256(
                    document.encode("utf-8")
                ).hexdigest()
                row = texts.get(document)
                if row is None:
                    row = len(unique_texts)
                    texts[document] = row
                    unique_texts.append(document)
                text_index[(repo, document_key)] = row
                composes.append((repo, vector_key, document_key, document_key))
        finally:
            connection.close()
    audit = {
        "format": "swerank-find_py_or_non_dict_with_path",
        "unique_texts": len(unique_texts),
        "vectors": len(composes),
        "class_methods": methods,
        "top_level_functions": top_level,
    }
    print(json.dumps({"event": "swerank_documents_collected", **audit}), flush=True)
    return unique_texts, text_index, composes, audit


def save_cache(path: Path, doc_vectors: np.ndarray, text_index: dict, query_vectors: np.ndarray, work: list[QueryWork]) -> None:
    temporary = path.with_name(path.name + ".tmp")
    if temporary.exists():
        shutil.rmtree(temporary)
    temporary.mkdir(parents=True)
    np.save(temporary / "documents.npy", doc_vectors)
    np.save(temporary / "queries.npy", query_vectors)
    (temporary / "document-keys.json").write_text(
        json.dumps([[repo, key, row] for (repo, key), row in text_index.items()]), encoding="utf-8"
    )
    (temporary / "query-keys.json").write_text(
        json.dumps([[item.repo, item.query_id] for item in work]), encoding="utf-8"
    )
    if path.exists():
        shutil.rmtree(path)
    temporary.rename(path)


def load_cache(
    path: Path, composes: list, work: list[QueryWork]
) -> tuple[DocumentVectors, dict, np.ndarray] | None:
    files = [path / "documents.npy", path / "queries.npy", path / "document-keys.json", path / "query-keys.json"]
    if not all(file.is_file() for file in files):
        overlay_files = [
            path / "overlay-documents.npy",
            path / "base-cache.json",
            path / "queries.npy",
            path / "document-keys.json",
            path / "query-keys.json",
        ]
        if not all(file.is_file() for file in overlay_files):
            return None
        base_manifest = json.loads((path / "base-cache.json").read_text(encoding="utf-8"))
        base_path = Path(str(base_manifest["path"]))
        base_documents_path = base_path / "documents.npy"
        if not base_documents_path.is_file():
            return None
        base_documents = np.load(base_documents_path, mmap_mode="r")
        overlay_documents = np.load(path / "overlay-documents.npy", mmap_mode="r")
        if (
            list(base_documents.shape) != base_manifest["shape"]
            or int(base_documents.shape[1]) != int(overlay_documents.shape[1])
        ):
            return None
        documents = DocumentVectors(base_documents, overlay_documents)
    else:
        documents = DocumentVectors(np.load(path / "documents.npy", mmap_mode="r"))
    query_keys = json.loads((path / "query-keys.json").read_text(encoding="utf-8"))
    if query_keys != [[item.repo, item.query_id] for item in work]:
        return None
    text_index = {
        (str(repo), str(key)): int(row)
        for repo, key, row in json.loads((path / "document-keys.json").read_text(encoding="utf-8"))
    }
    if any((repo, child) not in text_index or (repo, parent) not in text_index for repo, _vector, child, parent in composes):
        return None
    return (
        documents,
        text_index,
        np.load(path / "queries.npy", mmap_mode="r"),
    )


def reused_document_layout(
    reuse_path: Path,
    component_texts: list[str],
    text_index: dict[tuple[str, str], int],
    *,
    reuse_below_tokens: int | None = None,
    tokenizer=None,
    tokenization_batch_size: int = 1024,
) -> tuple[DocumentVectors, dict[tuple[str, str], int], list[str], dict]:
    base_documents_path = reuse_path / "documents.npy"
    base_keys_path = reuse_path / "document-keys.json"
    if not base_documents_path.is_file() or not base_keys_path.is_file():
        raise ValueError(f"reuse cache is incomplete: {reuse_path}")
    base_documents = np.load(base_documents_path, mmap_mode="r")
    base_index = {
        (str(repo), str(key)): int(row)
        for repo, key, row in json.loads(base_keys_path.read_text(encoding="utf-8"))
    }
    excluded_rows: set[int] = set()
    length_audit: dict[str, object] = {}
    if reuse_below_tokens is not None:
        if tokenizer is None:
            raise ValueError("reuse_below_tokens requires a tokenizer")
        if reuse_below_tokens < 0:
            raise ValueError("reuse_below_tokens must be non-negative")
        length_start = time.monotonic()
        tokenization_candidates = [
            (row, text)
            for row, text in enumerate(component_texts)
            if len(text) > reuse_below_tokens
        ]
        for start in range(0, len(tokenization_candidates), tokenization_batch_size):
            batch = tokenization_candidates[start : start + tokenization_batch_size]
            encoded = tokenizer(
                [text for _row, text in batch],
                add_special_tokens=True,
                padding=False,
                truncation=False,
                return_length=True,
            )
            lengths = encoded.get("length")
            if lengths is None:
                lengths = [len(ids) for ids in encoded["input_ids"]]
            for (row, _text), length in zip(batch, lengths, strict=True):
                if int(length) > reuse_below_tokens:
                    excluded_rows.add(row)
        length_audit = {
            "reuse_below_tokens": reuse_below_tokens,
            "char_safe_current_rows": len(component_texts)
            - len(tokenization_candidates),
            "char_prefilter_candidate_rows": len(tokenization_candidates),
            "token_excluded_current_rows": len(excluded_rows),
            "length_classification_seconds": time.monotonic() - length_start,
            "tokenization_batch_size": tokenization_batch_size,
        }
    current_to_base: dict[int, int] = {}
    for key, current_row in text_index.items():
        if current_row in excluded_rows:
            continue
        base_row = base_index.get(key)
        if base_row is not None:
            current_to_base.setdefault(current_row, base_row)
    missing_rows = [
        row for row in range(len(component_texts)) if row not in current_to_base
    ]
    missing_position = {row: position for position, row in enumerate(missing_rows)}
    base_rows = int(base_documents.shape[0])
    remapped = {
        key: (
            current_to_base[current_row]
            if current_row in current_to_base
            else base_rows + missing_position[current_row]
        )
        for key, current_row in text_index.items()
    }
    audit = {
        "base_cache": str(reuse_path.resolve()),
        "base_rows": base_rows,
        "reused_current_rows": len(component_texts) - len(missing_rows),
        "missing_current_rows": len(missing_rows),
    }
    audit.update(length_audit)
    return (
        DocumentVectors(base_documents),
        remapped,
        [component_texts[row] for row in missing_rows],
        audit,
    )


def save_overlay_cache(
    path: Path,
    base_path: Path,
    base_documents: np.ndarray,
    overlay_documents: np.ndarray,
    text_index: dict,
    query_vectors: np.ndarray,
    work: list[QueryWork],
) -> None:
    temporary = path.with_name(path.name + ".tmp")
    if temporary.exists():
        shutil.rmtree(temporary)
    temporary.mkdir(parents=True)
    np.save(temporary / "overlay-documents.npy", overlay_documents)
    np.save(temporary / "queries.npy", query_vectors)
    (temporary / "base-cache.json").write_text(
        json.dumps(
            {"path": str(base_path.resolve()), "shape": list(base_documents.shape)},
            sort_keys=True,
        ),
        encoding="utf-8",
    )
    (temporary / "document-keys.json").write_text(
        json.dumps([[repo, key, row] for (repo, key), row in text_index.items()]),
        encoding="utf-8",
    )
    (temporary / "query-keys.json").write_text(
        json.dumps([[item.repo, item.query_id] for item in work]), encoding="utf-8"
    )
    if path.exists():
        shutil.rmtree(path)
    temporary.rename(path)


def update_document_store(
    path: Path,
    documents: DocumentVectors,
    text_index: dict[tuple[str, str], int],
) -> None:
    current_items = list(text_index.items())
    if not current_items:
        return
    existing_documents_path = path / "documents.npy"
    existing_keys_path = path / "document-keys.json"
    existing_documents = None
    existing_entries: list[tuple[str, str, int]] = []
    if existing_documents_path.is_file() and existing_keys_path.is_file():
        existing_documents = np.load(existing_documents_path, mmap_mode="r")
        existing_entries = [
            (str(repo), str(key), int(row))
            for repo, key, row in json.loads(
                existing_keys_path.read_text(encoding="utf-8")
            )
        ]
        if int(existing_documents.shape[1]) != documents.shape[1]:
            raise ValueError(
                f"docstore dimension mismatch: existing={existing_documents.shape[1]}, "
                f"current={documents.shape[1]}"
            )

    rows: list[tuple[str, str, int]] = []
    seen: set[tuple[str, str]] = set()
    existing_sources: list[int] = []
    for repo, key, source_row in sorted(existing_entries, key=lambda item: item[2]):
        cache_key = (repo, key)
        if cache_key in seen:
            continue
        if existing_documents is None or not 0 <= source_row < int(
            existing_documents.shape[0]
        ):
            raise ValueError(
                f"docstore key row out of bounds: {(repo, key, source_row)!r}"
            )
        seen.add(cache_key)
        existing_sources.append(source_row)
        rows.append((repo, key, len(rows)))

    current_sources: list[int] = []
    for (repo, key), source_row in current_items:
        cache_key = (str(repo), str(key))
        if cache_key in seen:
            continue
        seen.add(cache_key)
        current_sources.append(int(source_row))
        rows.append((cache_key[0], cache_key[1], len(rows)))

    temporary = path.with_name(f"{path.name}.tmp-{os.getpid()}-{time.time_ns()}")
    if temporary.exists():
        shutil.rmtree(temporary)
    temporary.parent.mkdir(parents=True, exist_ok=True)
    temporary.mkdir()
    try:
        dtype = (
            existing_documents.dtype
            if existing_documents is not None
            else documents.base.dtype
        )
        output = np.lib.format.open_memmap(
            temporary / "documents.npy",
            mode="w+",
            dtype=dtype,
            shape=(len(rows), documents.shape[1]),
        )
        cursor = 0
        if existing_documents is not None and existing_sources:
            existing_rows = np.asarray(existing_sources, dtype=np.int64)
            output[cursor : cursor + len(existing_sources)] = existing_documents[
                existing_rows
            ]
            cursor += len(existing_sources)
        if current_sources:
            current_rows = np.asarray(current_sources, dtype=np.int64)
            output[cursor : cursor + len(current_sources)] = documents.take(
                current_rows
            )
        output.flush()
        (temporary / "document-keys.json").write_text(
            json.dumps([[repo, key, row] for repo, key, row in rows]),
            encoding="utf-8",
        )
        old_path: Path | None = None
        if path.exists():
            old_path = path.with_name(
                f"{path.name}.old-{os.getpid()}-{time.time_ns()}"
            )
            if old_path.exists():
                shutil.rmtree(old_path)
            path.rename(old_path)
        try:
            temporary.rename(path)
        except Exception:
            if old_path is not None and old_path.exists() and not path.exists():
                old_path.rename(path)
            raise
        else:
            if old_path is not None:
                shutil.rmtree(old_path)
    except Exception:
        if temporary.exists():
            shutil.rmtree(temporary)
        raise


def materialize_current_document_layout(
    documents: DocumentVectors,
    text_index: dict[tuple[str, str], int],
) -> tuple[np.ndarray, dict[tuple[str, str], int]]:
    source_rows = sorted(set(text_index.values()))
    row_remap = {source_row: row for row, source_row in enumerate(source_rows)}
    materialized = documents.take(np.asarray(source_rows, dtype=np.int64))
    remapped = {key: row_remap[source_row] for key, source_row in text_index.items()}
    return materialized, remapped


def derive_truncated_cache(
    source_path: Path,
    target_path: Path,
    composes: list,
    work: list[QueryWork],
    truncate_dim: int,
    *,
    block_size: int = 8192,
) -> None:
    source = load_cache(source_path, composes, work)
    if source is None:
        raise ValueError(
            "truncation source must be a complete cache with identical document/query keys"
        )
    documents, text_index, queries = source
    if documents.overlay is not None:
        raise ValueError("truncation source cannot be an overlay cache")
    if not 0 < truncate_dim < documents.shape[1]:
        raise ValueError(
            f"truncate_dim must be below source dimension {documents.shape[1]}"
        )
    temporary = target_path.with_name(target_path.name + ".tmp")
    if temporary.exists():
        shutil.rmtree(temporary)
    temporary.mkdir(parents=True)

    def truncate(source_vectors: np.ndarray, output_path: Path) -> None:
        output = np.lib.format.open_memmap(
            output_path,
            mode="w+",
            dtype=np.float32,
            shape=(int(source_vectors.shape[0]), truncate_dim),
        )
        for start in range(0, len(source_vectors), block_size):
            stop = min(start + block_size, len(source_vectors))
            block = np.array(
                source_vectors[start:stop, :truncate_dim],
                dtype=np.float32,
                copy=True,
            )
            norms = np.linalg.norm(block, axis=1)
            nonzero = norms > 0
            block[nonzero] /= norms[nonzero, None]
            output[start:stop] = block
        output.flush()

    truncate(documents.base, temporary / "documents.npy")
    truncate(queries, temporary / "queries.npy")
    (temporary / "document-keys.json").write_text(
        json.dumps([[repo, key, row] for (repo, key), row in text_index.items()]),
        encoding="utf-8",
    )
    (temporary / "query-keys.json").write_text(
        json.dumps([[item.repo, item.query_id] for item in work]), encoding="utf-8"
    )
    if target_path.exists():
        shutil.rmtree(target_path)
    temporary.rename(target_path)


def compose_document_matrix(
    documents: DocumentVectors,
    text_index: dict[tuple[str, str], int],
    composes: list[tuple[str, str, str, str]],
    alpha: float,
    *,
    workers: int,
    block_size: int = 1024,
) -> tuple[np.ndarray, dict[tuple[str, str], int]]:
    if documents.overlay is None:
        return compose_parent_matrix(
            documents.base, text_index, composes, alpha, workers=workers
        )
    child_rows = np.fromiter(
        (
            text_index[(repo, child_key)]
            for repo, _vector_key, child_key, _parent_key in composes
        ),
        dtype=np.int64,
        count=len(composes),
    )
    parent_rows = np.fromiter(
        (
            text_index[(repo, parent_key)]
            for repo, _vector_key, _child_key, parent_key in composes
        ),
        dtype=np.int64,
        count=len(composes),
    )
    output = np.empty((len(composes), documents.shape[1]), dtype=np.float32)
    row_by_key = {
        (repo, vector_key): row
        for row, (repo, vector_key, _child, _parent) in enumerate(composes)
    }
    ranges = [
        (start, min(start + block_size, len(composes)))
        for start in range(0, len(composes), block_size)
    ]

    def compose_block(bounds: tuple[int, int]) -> None:
        start, stop = bounds
        target = output[start:stop]
        np.multiply(documents.take(child_rows[start:stop]), alpha, out=target)
        target += documents.take(parent_rows[start:stop]) * (1.0 - alpha)
        norms = np.linalg.norm(target, axis=1)
        nonzero = norms > 0
        target[nonzero] /= norms[nonzero, None]

    from concurrent.futures import ThreadPoolExecutor

    with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
        list(pool.map(compose_block, ranges))
    return output, row_by_key


def reciprocal_rank(ranked: list[int], gold: frozenset[int]) -> float:
    return next((1.0 / rank for rank, chunk_id in enumerate(ranked, 1) if chunk_id in gold), 0.0)


def mean_dict(rows: Iterable[dict[str, float]], keys: list[str]) -> dict[str, float]:
    materialized = list(rows)
    return {key: sum(row[key] for row in materialized) / len(materialized) for key in keys}


def nested_macro(query_rows: list[dict], keys: list[str]) -> tuple[dict, dict]:
    by_task: dict[tuple[str, str], list[dict]] = defaultdict(list)
    for row in query_rows:
        by_task[(row["repo"], row["task_id"])].append(row)
    task_rows = [
        {"repo": rows[0]["repo"], "language": rows[0]["language"], **mean_dict(rows, keys)}
        for rows in by_task.values()
    ]
    by_repo: dict[str, list[dict]] = defaultdict(list)
    for row in task_rows:
        by_repo[row["repo"]].append(row)
    repo_rows = [
        {"repo": repo, "language": rows[0]["language"], **mean_dict(rows, keys)}
        for repo, rows in sorted(by_repo.items())
    ]
    by_language: dict[str, list[dict]] = defaultdict(list)
    for row in repo_rows:
        by_language[row["language"]].append(row)
    language_rows = {
        language: mean_dict(rows, keys) for language, rows in sorted(by_language.items())
    }
    return mean_dict(language_rows.values(), keys), {"languages": language_rows, "repositories": repo_rows}


def build_evaluation_row(
    item: QueryWork,
    ranked_chunks: list[int],
    ranked_files: list[str],
    ks: tuple[int, ...],
) -> dict:
    row: dict[str, object] = {
        "repo": item.repo,
        "revision": item.revision,
        "language": item.language,
        "task_id": item.task_id,
        "query_id": item.query_id,
        "gold_chunks": sorted(item.gold_chunks),
        "gold_files": sorted(item.gold_files),
        "mrr": reciprocal_rank(ranked_chunks, item.gold_chunks),
        "file_mrr": next(
            (
                1.0 / rank
                for rank, path in enumerate(ranked_files, 1)
                if path in item.gold_files
            ),
            0.0,
        ),
        "ranked_chunks_top50": ranked_chunks[:50],
        "ranked_files_top50": ranked_files[:50],
    }
    for k in ks:
        top_chunks = set(ranked_chunks[:k])
        top_files = set(ranked_files[:k])
        row[f"acc@{k}"] = float(bool(top_chunks & item.gold_chunks))
        row[f"recall@{k}"] = len(top_chunks & item.gold_chunks) / len(item.gold_chunks)
        row[f"file_acc@{k}"] = float(bool(top_files & item.gold_files))
        row[f"file_recall@{k}"] = len(top_files & item.gold_files) / len(item.gold_files)
    return row


def score(
    work: list[QueryWork],
    db_dir: Path,
    composed: np.ndarray,
    composed_rows: dict[tuple[str, str], int],
    query_vectors: np.ndarray,
    ks: tuple[int, ...],
    workers: int,
    *,
    include_chunkless: bool,
) -> list[dict]:
    from concurrent.futures import ThreadPoolExecutor

    work_by_revision: dict[tuple[str, str], list[tuple[int, QueryWork]]] = defaultdict(list)
    for index, item in enumerate(work):
        work_by_revision[(item.repo, item.revision)].append((index, item))

    # Loading one revision at a time causes thousands of SQLite opens and small
    # indexed queries. Read every requested revision in one pass per repository.
    revisions_by_repo: dict[str, set[str]] = defaultdict(set)
    for repo, revision in work_by_revision:
        revisions_by_repo[repo].add(revision)
    layouts: dict[tuple[str, str], tuple[np.ndarray, list[str], list[str]]] = {}
    layout_start = time.monotonic()
    for repo, revisions in sorted(revisions_by_repo.items()):
        ordered_revisions = sorted(revisions)
        placeholders = ",".join("?" for _ in ordered_revisions)
        connection = sqlite3.connect(db_dir / repo / "embeddings.db")
        try:
            chunkless_clause = (
                "" if include_chunkless else "AND codeunit_name != '__chunkless_file_summary__'"
            )
            rows = connection.execute(
                f"""SELECT revision, chunk_id, vector_key, path FROM chunks
                    WHERE revision IN ({placeholders})
                    {chunkless_clause}
                    ORDER BY revision, path, codeunit_name, chunk_id""",
                ordered_revisions,
            )
            grouped: dict[str, list[tuple[int, str, str]]] = defaultdict(list)
            for revision, chunk_id, vector_key, path in rows:
                grouped[str(revision)].append((int(chunk_id), str(vector_key), str(path)))
        finally:
            connection.close()
        for revision in ordered_revisions:
            entries = grouped.get(revision)
            if not entries:
                raise ValueError(f"no corpus chunks for {repo}@{revision}")
            layouts[(repo, revision)] = (
                np.asarray([row[0] for row in entries], dtype=np.int64),
                [row[1] for row in entries],
                [row[2] for row in entries],
            )
    print(
        json.dumps(
            {
                "event": "scoring_layouts_loaded",
                "repositories": len(revisions_by_repo),
                "revisions": len(layouts),
                "seconds": time.monotonic() - layout_start,
            }
        ),
        flush=True,
    )

    def score_revision(group: tuple[tuple[str, str], list[tuple[int, QueryWork]]]) -> list[dict]:
        (repo, revision), items = group
        chunk_ids, vector_keys, paths = layouts[(repo, revision)]
        matrix = composed[[composed_rows[(repo, vector_key)] for vector_key in vector_keys]]
        results: list[dict] = []
        for query_index, item in items:
            order = np.argsort(matrix @ query_vectors[query_index])[::-1]
            ranked_chunks = [int(chunk_ids[index]) for index in order]
            ranked_files: list[str] = []
            seen_files: set[str] = set()
            for index in order:
                path = paths[int(index)]
                if path not in seen_files:
                    seen_files.add(path)
                    ranked_files.append(path)
            results.append(build_evaluation_row(item, ranked_chunks, ranked_files, ks))
        return results

    try:
        from threadpoolctl import threadpool_limits

        blas_context = threadpool_limits(limits=1, user_api="blas")
    except ImportError:
        blas_context = nullcontext()
    with blas_context:
        with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
            groups = pool.map(score_revision, sorted(work_by_revision.items()))
            return [row for group in groups for row in group]


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    here = Path(__file__).resolve().parent
    parser.add_argument("--model", required=True)
    parser.add_argument(
        "--model-profile",
        choices=(
            "voyage",
            "swerank-small",
            "swerank-large",
            "granite",
            "hf-instruct",
            "nemotron-embed",
        ),
        required=True,
    )
    parser.add_argument("--hf-instruct-family", choices=("qwen3", "bge-code"))
    parser.add_argument("--model-tag", required=True)
    parser.add_argument("--final-dir", type=Path, default=here / "final")
    parser.add_argument("--db-dir", type=Path, default=here / "production-db")
    parser.add_argument("--output-dir", type=Path, default=here / "eval")
    parser.add_argument("--vector-cache", type=Path, default=here / "eval-vector-cache")
    parser.add_argument(
        "--derive-truncated-cache",
        type=Path,
        help="Derive this run's vectors by truncating and renormalizing an identical wider cache",
    )
    parser.add_argument(
        "--document-shape",
        choices=("parent-composed", "swerank"),
        default="swerank",
    )
    parser.add_argument("--devices", default="cuda:0")
    parser.add_argument("--expected-gpu-uuid")
    parser.add_argument(
        "--direct-device",
        help="Encode in the main process on this device instead of using a multiprocessing pool",
    )
    parser.add_argument(
        "--load-per-worker-pool",
        action="store_true",
        help="Have each legacy SentenceTransformers worker load the model instead of sharing it",
    )
    parser.add_argument("--max-seq-length", type=int, default=8192)
    parser.add_argument("--truncate-dim", type=int)
    parser.add_argument(
        "--checkpoint-dispatch-texts",
        type=int,
        default=20_000,
        help="Texts per atomic embedding checkpoint inside each length bucket",
    )
    parser.add_argument("--checkpoint-shard-index", type=int, default=0)
    parser.add_argument("--checkpoint-shard-count", type=int, default=1)
    parser.add_argument(
        "--documents-shard-only",
        action="store_true",
        help="Encode this document checkpoint shard and exit before queries/finalization",
    )
    parser.add_argument(
        "--documents-shard-stop-after-batch-size",
        type=int,
        help="Stop a documents-only shard after processing this logical length bucket",
    )
    parser.add_argument("--alpha", type=float, default=1.0)
    parser.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 1) // 2))
    parser.add_argument("--preflight-only", action="store_true")
    parser.add_argument(
        "--encode-smoke-only",
        action="store_true",
        help="Load the selected embedding model, resolve prompts, encode one query/document, and exit",
    )
    parser.add_argument(
        "--documents-preflight-only",
        action="store_true",
        help="Resolve gold and collect document texts without loading an embedding model",
    )
    parser.add_argument(
        "--function-retrievable-only",
        action="store_true",
        help="Drop chunkless-only queries and remove chunkless gold from mixed queries",
    )
    args = parser.parse_args()
    if not 0.0 <= args.alpha <= 1.0:
        parser.error("--alpha must be between zero and one")
    if args.document_shape == "swerank" and args.alpha != 1.0:
        parser.error("--document-shape swerank requires --alpha 1.0")
    if args.model_profile == "hf-instruct":
        if args.hf_instruct_family is None:
            parser.error("--model-profile hf-instruct requires --hf-instruct-family")
        if args.truncate_dim is not None:
            parser.error("--model-profile hf-instruct leaves truncate_dim native; omit --truncate-dim")
    elif args.hf_instruct_family is not None:
        parser.error("--hf-instruct-family is only valid with --model-profile hf-instruct")
    if args.derive_truncated_cache is not None and args.truncate_dim is None:
        parser.error("--derive-truncated-cache requires --truncate-dim")
    if args.checkpoint_shard_count < 1:
        parser.error("--checkpoint-shard-count must be positive")
    if not 0 <= args.checkpoint_shard_index < args.checkpoint_shard_count:
        parser.error(
            "--checkpoint-shard-index must be between zero and --checkpoint-shard-count"
        )
    if args.checkpoint_shard_count > 1 and not args.documents_shard_only:
        parser.error("--checkpoint sharding requires --documents-shard-only")
    if (
        args.documents_shard_stop_after_batch_size is not None
        and not args.documents_shard_only
    ):
        parser.error(
            "--documents-shard-stop-after-batch-size requires --documents-shard-only"
        )
    validate_cuda_runtime(args.devices.split(","), args.expected_gpu_uuid)
    if args.encode_smoke_only:
        if args.direct_device and args.load_per_worker_pool:
            parser.error("--direct-device and --load-per-worker-pool are mutually exclusive")
        return encode_smoke(args)

    task_rows = read_jsonl(args.final_dir / "tasks.jsonl")
    query_rows = read_jsonl(args.final_dir / "queries.jsonl")
    gold_rows = read_jsonl(args.final_dir / "gold-preimage.jsonl")
    work, gold_audit = resolve_gold_chunks(args.db_dir, query_rows, gold_rows, task_rows)
    print(json.dumps({"event": "gold_resolved", **gold_audit}), flush=True)
    slice_audit = None
    if args.function_retrievable_only:
        work, slice_audit = retain_function_retrievable_queries(work, args.db_dir)
    if args.preflight_only:
        return 0

    document_shape_audit = None
    if args.document_shape == "swerank":
        component_texts, text_index, composes, document_shape_audit = (
            collect_swerank_components(work, args.db_dir)
        )
    else:
        component_texts, text_index, composes = collect_components(work, args.db_dir)
    if args.documents_preflight_only:
        print(
            json.dumps(
                {
                    "event": "documents_preflight_complete",
                    "document_shape": args.document_shape,
                    "unique_texts": len(component_texts),
                    "document_keys": len(text_index),
                    "vectors": len(composes),
                    "document_shape_audit": document_shape_audit,
                }
            ),
            flush=True,
        )
        return 0
    digest = cache_digest(args, work)
    cache_path = args.vector_cache / digest
    docstore_identity = document_cache_identity(args)
    docstore_path = args.vector_cache / "docstore" / docstore_identity
    cached = load_cache(cache_path, composes, work)
    if cached is None and args.derive_truncated_cache is not None:
        derive_truncated_cache(
            args.derive_truncated_cache,
            cache_path,
            composes,
            work,
            args.truncate_dim,
        )
        print(
            json.dumps(
                {
                    "event": "vector_cache_derived",
                    "source": str(args.derive_truncated_cache),
                    "path": str(cache_path),
                    "truncate_dim": args.truncate_dim,
                }
            ),
            flush=True,
        )
        cached = load_cache(cache_path, composes, work)
        if cached is None:
            raise RuntimeError("derived vector cache failed its completeness check")
    if cached is None:
        import torch

        reused_documents = None
        reused_text_index = None
        missing_component_texts = component_texts
        if (
            (docstore_path / "documents.npy").is_file()
            and (docstore_path / "document-keys.json").is_file()
        ):
            (
                reused_documents,
                reused_text_index,
                missing_component_texts,
                docstore_audit,
            ) = reused_document_layout(
                docstore_path,
                component_texts,
                text_index,
                reuse_below_tokens=None,
            )
        else:
            docstore_audit = {
                "base_cache": str(docstore_path.resolve()),
                "base_rows": 0,
                "reused_current_rows": 0,
                "missing_current_rows": len(component_texts),
            }
        print(
            json.dumps(
                {
                    "event": "docstore_reuse",
                    "identity": docstore_identity,
                    "reused": docstore_audit["reused_current_rows"],
                    "missing": docstore_audit["missing_current_rows"],
                    "base_rows": docstore_audit["base_rows"],
                }
            ),
            flush=True,
        )
        print(
            json.dumps(
                {
                    "event": "model_load",
                    "model": args.model,
                    "devices": args.devices.split(","),
                }
            ),
            flush=True,
        )
        model, query_prompt, document_prompt = load_sentence_transformer(args)

        pool = None
        if args.direct_device and args.load_per_worker_pool:
            parser.error("--direct-device and --load-per-worker-pool are mutually exclusive")
        if args.direct_device:
            model.to(args.direct_device)
        elif args.load_per_worker_pool:
            model.to("cpu")
            torch.cuda.empty_cache()
            pool = start_model_loading_pool(
                args.model,
                args.max_seq_length,
                args.devices.split(","),
                args.model_profile,
                args.hf_instruct_family,
                args.truncate_dim,
                resolved_prompt_text(model, query_prompt),
                resolved_prompt_text(model, document_prompt),
            )
        else:
            pool = model.start_multi_process_pool(target_devices=args.devices.split(","))
        try:
            encoded_documents = bucketed_encode(
                model,
                pool,
                missing_component_texts,
                document_prompt,
                cache_path / "partial-documents",
                checkpoint_dispatch_texts=args.checkpoint_dispatch_texts,
                checkpoint_shard_index=args.checkpoint_shard_index,
                checkpoint_shard_count=args.checkpoint_shard_count,
                checkpoint_stop_after_batch_size=(
                    args.documents_shard_stop_after_batch_size
                ),
            )
            if not args.documents_shard_only:
                queries = bucketed_encode(
                    model,
                    pool,
                    [item.query for item in work],
                    query_prompt,
                    cache_path / "partial-queries",
                    checkpoint_dispatch_texts=args.checkpoint_dispatch_texts,
                )
        finally:
            if pool is not None:
                model.stop_multi_process_pool(pool)
        if args.documents_shard_only:
            print(
                json.dumps(
                    {
                        "event": "document_shard_complete",
                        "shard_index": args.checkpoint_shard_index,
                        "shard_count": args.checkpoint_shard_count,
                    }
                ),
                flush=True,
            )
            return 0
        del model
        gc.collect()
        if reused_documents is None:
            documents = DocumentVectors(encoded_documents)
        else:
            documents = DocumentVectors(reused_documents.base, encoded_documents)
            text_index = reused_text_index
        encoded_documents, text_index = materialize_current_document_layout(
            documents, text_index
        )
        documents = DocumentVectors(encoded_documents)
        save_cache(cache_path, encoded_documents, text_index, queries, work)
        update_document_store(docstore_path, documents, text_index)
        print(
            json.dumps({"event": "vector_cache_write", "path": str(cache_path)}),
            flush=True,
        )
    else:
        documents, text_index, queries = cached
        print(json.dumps({"event": "vector_cache_hit", "path": str(cache_path)}), flush=True)

    compose_start = time.monotonic()
    composed, composed_rows = compose_document_matrix(
        documents, text_index, composes, args.alpha, workers=args.workers
    )
    print(
        json.dumps(
            {
                "event": "composition_complete",
                "alpha": args.alpha,
                "vectors": len(composes),
                "seconds": time.monotonic() - compose_start,
                "workers": args.workers,
            }
        ),
        flush=True,
    )
    ks = (1, 3, 5, 10, 15, 20, 30, 50)
    scoring_start = time.monotonic()
    evaluations = score(
        work,
        args.db_dir,
        composed,
        composed_rows,
        queries,
        ks,
        args.workers,
        include_chunkless=args.document_shape == "parent-composed",
    )
    metric_keys = ["mrr", "file_mrr"] + [
        f"{prefix}@{k}"
        for k in ks
        for prefix in ("acc", "recall", "file_acc", "file_recall")
    ]
    metrics, breakdown = nested_macro(evaluations, metric_keys)
    output = {
        "benchmark": "PatchPoint",
        "model": args.model,
        "model_profile": args.model_profile,
        "model_tag": args.model_tag,
        "document_shape": args.document_shape,
        "alpha": args.alpha,
        "max_seq_length": args.max_seq_length,
        "embedding_dimension": int(documents.shape[1]),
        "truncate_dim": args.truncate_dim,
        "aggregation": "macro query-within-task, task-within-repository, repository-within-language, language",
        "counts": {
            "queries": len(evaluations),
            "tasks": len({(row["repo"], row["task_id"]) for row in evaluations}),
            "repositories": len({row["repo"] for row in evaluations}),
            "languages": len({row["language"] for row in evaluations}),
        },
        "gold_resolution": gold_audit,
        "evaluation_slice": slice_audit,
        "document_shape_audit": document_shape_audit,
        "metrics": metrics,
        "breakdown": breakdown,
        "queries": evaluations,
    }
    args.output_dir.mkdir(parents=True, exist_ok=True)
    alpha_tag = f"{args.alpha:g}".replace(".", "")
    output_path = args.output_dir / f"{args.model_tag}-alpha{alpha_tag}.json"
    output_path.write_text(json.dumps(output, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    print(
        json.dumps(
            {
                "event": "evaluation_complete",
                "output": str(output_path),
                "seconds": time.monotonic() - scoring_start,
                "metrics": metrics,
            }
        ),
        flush=True,
    )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())