diff --git a/KNOWN_ISSUES.md b/KNOWN_ISSUES.md
index c7b8c7dd..7fab94fd 100644
--- a/KNOWN_ISSUES.md
+++ b/KNOWN_ISSUES.md
@@ -5,6 +5,14 @@
 
 ---
 
+## 2026-09-29 — FTS-тир молча выпадает по таймауту 2s, ранки плавают run-to-run (Open)
+
+- **Локация:** `src/core/search/engine.py:970-976` (`wait_for(..., timeout=2.0)` вокруг `_fts5_search_async`; `TimeoutError` → tier `[]` + warning в лог).
+- **Симптом:** членство FTS-тира в RRF-пуле недетерминировано от прогона к прогону: наблюдалось P2 rank 1↔2, воббл H6/H11/H12 на том же индексе и коде. Холодный FTS-билд (~0.5–2.5s lazy `to_pandas`) съедает бюджет целиком — первый замер в свежем процессе систематически без FTS-тира (частный случай уже учтён warm-up-правилом в записи 2026-09-28, но теплый индекс тоже флипает у границы 2s).
+- **Почему это ловушка для гейтов:** silent-degraded — ни флаг в выдаче, ни строка в harness-таблице; воббл выглядит как эффект кода, а не бюджета. `void`-флаг (`timing=={}`) и degraded-флаг (`reranker_ms==0`) этот класс НЕ ловят.
+- **Fix options (решение владельца):** (a) явный `fts_timed_out` флаг в результат/трейсер + degraded-строка в гейтах; (b) бюджет/квота вместо жёсткого капа (адаптивный timeout, повтор с урезанным лимитом); (c) прогрев FTS до замеров как обязательный шаг harness (уже частично: discarded warm-up).
+- **Статус:** 🟡 Open (процедурное правило до фикса: gate-серия обязана идти в одном процессе с discarded warm-up + фиксировать число FTS-таймаутов по логу `FTS5 search timed out`).
+
 ## 2026-09-28 — Pre-commit hook fail-open при потере маркеров (Fixed)
 
 - **Локация:** `.githooks/pre-commit:31-53` (`find_project_root` + `run_script`).
diff --git a/experiments/reranker_p3/PREREG.md b/experiments/reranker_p3/PREREG.md
new file mode 100644
index 00000000..9ee67f15
--- /dev/null
+++ b/experiments/reranker_p3/PREREG.md
@@ -0,0 +1,37 @@
+# P3 module-head anchor — preregistration (2026-09-29)
+
+Status: PREREGISTERED — written BEFORE implementing the anchor. No numbers
+invented here; thresholds/caps referenced are the existing ones
+(`_O1_ANCHOR_TOTAL`, `MAX_RERANKER_INPUT=30`, `MIN_RERANK_SCORE=0.3` untouched).
+
+## Hypothesis
+
+P3 (`src/core/artifact_gc.py` gold file below threshold) is a pool-entry /
+ranking problem of the same family as P2: the chunk the reranker scores
+highest (module-head/docstring) never reaches the reranker, while the code
+chunk that does reach it scores a negative logit and dies at the threshold.
+
+## Decision rule (verbatim)
+
+"anchor a file's module-head/docstring chunk into the pre-rerank pool iff it
+scores above threshold on holdout queries; falsified if (i) docstring chunks
+do not outscore code chunks on holdout, (ii) anchoring regresses holdout H-set,
+(iii) pool cost exceeds caps".
+
+## Reading of the three clauses
+
+- (i) is checked by the persisted probes
+  (`rerank_probe_run1.json`: gold_doc #1 on 6/6 holdout-style queries;
+  `rerank_probe_run2.json`: module_head top on P3/R2, code chunks negative).
+- (ii) is checked by the no-regression holdout H1–H12 + P/R + doc-control
+  gate (fresh-process discipline — reranker-cache trap).
+- (iii) is checked structurally: anchors bounded by the existing caps
+  (`_O1_ANCHOR_TOTAL`, `MAX_RERANKER_INPUT=30`).
+
+## Scope
+
+- Validate on holdout only — NEVER the frozen eval-16.
+- `MIN_RERANK_SCORE=0.3` untouched (threshold sweep on the eval set was
+  explicitly refuted in `EXPERIMENTS_LOG.md:2815-2816`).
+- Minimal diff extending the P2 `_anchor_identifier_chunks_async` precedent
+  (`engine.py:772-805`), same style.
diff --git a/experiments/reranker_p3/README.md b/experiments/reranker_p3/README.md
new file mode 100644
index 00000000..2bbd2d4c
--- /dev/null
+++ b/experiments/reranker_p3/README.md
@@ -0,0 +1,46 @@
+# reranker_p3 probes — module-head / docstring anchor evidence
+
+Persisted 2026-09-29 from `%TEMP%\opencode\` (byte-identical copies, hashes in SHA256SUMS).
+
+## What
+
+Two fresh-process direct-reranker probes that bypass retrieval and POST
+straight to the reranker. Finding: the gold module-head/docstring chunk of
+`src/core/artifact_gc.py` outscores every code chunk on holdout-style queries,
+while the `_prune`-body code chunk scores a negative logit (P3 -0.99, R2 -2.60
+in the eval path). Motivation for the P3 module-head anchor: guarantee the
+docstring chunk a place in the pre-rerank pool.
+
+## When / how run
+
+- Both scripts stdlib-only (`urllib`), run as `python <script> <out.json>`.
+- Model: BGE-M3 reranker served on `http://127.0.0.1:8081` (`/rerank`;
+  probe 1 docstring says `/v1/rerank`, actual POST path in code is `/rerank`).
+- No frozen eval-16 queries were used: probe queries are holdout-style
+  P3/R2 variants (`ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy`
+  etc.), disjoint from the frozen eval set.
+
+## Files
+
+- `probe_rerank.py` — probe 1: 6 queries x 5 passages (gold_doc head 800 chars
+  of `src/core/artifact_gc.py`, gold_code `_prune` body chars [1500:2300],
+  distractors engine/settings/diary heads). Output `rerank_probe_run1.json`.
+- `probe_rerank2.py` — probe 2: every AST-plausible chunk of `artifact_gc.py`
+  (module_head + per-def chunks with scope header, 800 chars) on P3/R2 queries.
+  Output `rerank_probe_run2.json`.
+- `rerank_probe_run1.json` — 6/6 queries rank `gold_doc` #1 (sigmoid 0.69–0.99).
+- `rerank_probe_run2.json` — `module_head` top on both queries
+  (P3 +0.57, R2 +0.43); all code chunks negative except `prune_stale_artifacts`
+  on R2 (+0.27).
+
+## Citation rule
+
+Rerank numbers are cited as
+`experiments/reranker_p3/rerank_probe_run{1,2}.json` + `EXPERIMENTS_LOG.md:2809`
+(raw eval logits P3 -0.99 / R2 -2.60 on the pre-rerank pool) — never
+`judged_raw.json` for rerank scores.
+
+## Frozen prompt
+
+None — queries are listed verbatim in the scripts and in `rerank_probe_run1.json`
+(`queries.<id>.query`). No LLM judge involved.
diff --git a/experiments/reranker_p3/RESULT-chunker.md b/experiments/reranker_p3/RESULT-chunker.md
new file mode 100644
index 00000000..b7a67864
--- /dev/null
+++ b/experiments/reranker_p3/RESULT-chunker.md
@@ -0,0 +1,85 @@
+# Chunker module-docstring fix — live gate result (2026-09-29): RED (mechanism delivered, retrieval blocks)
+
+Branch: `fix/chunker-module-doc` (off `origin/main` + cherry-picked P3 stack:
+anchor `d3d53075`, sigmoid `f2df8160`). Task: emit module docstring as chunk 0.
+
+## 1. Mechanism (implemented, unit-verified)
+
+`src/core/indexing/parser.py`: `_extract_module_docstring` (stdlib `ast`,
+.py only) + `chunks.insert(0, …)` in `_parse_with_tree_sitter` (only when the
+walk already produced chunks — fallback path untouched), `hierarchy_map`
+`module_docstring → module`, symbol `__module_doc__`. Files without a
+docstring: byte-identical behavior. Symbols untouched (no graph pollution).
+
+`tests/test_chunker_module_doc.py`: 5 passed. Related suites green:
+`test_parser.py` 5, `test_p3_module_head_anchor.py` 9,
+`test_chunk_cache.py` + `test_move_chunks.py` + `test_scm_definitions.py` 45.
+`ruff check` clean on both files (`ruff format` not enforced repo-wide —
+all pre-existing files fail it too; new code matches file style).
+
+## 2. Live reindex (evidence)
+
+- BEFORE: 15,426 rows, 0 `module_docstring` rows; `artifact_gc.py` 6 chunks,
+  chunk 0 = `function_definition` (`def _dir_has_files`).
+- Method: wipe `delete("1 = 1")` (no rmtree — live servers hold the DB open)
+  + `indexer.index_project(project)` with working-tree code, embedder :8080.
+- AFTER (repaired, see §4): **14,839 rows**, **371 `module_docstring` chunks**,
+  0 dup `(file_path, chunk_index)`; `artifact_gc.py` 7 chunks,
+  chunk 0 = `module_docstring` (start_line 1, head = file docstring).
+- Direct rerank of the new chunk 0 on the P3 query: **logit +1.21 / sig 0.77**
+  (probe predicted +0.83; old chunk 0 scored −6.66 and the probe passage did
+  not exist). Chunk 1 scores −6.52 → correctly cut. The chunker half of the
+  drill-down is closed.
+
+## 3. Gate (fresh process, `scripts/p3_holdout_gate.py`, rev `f2df8160`)
+
+```
+P2  rank=2    n=5  (expected 1 — REGRESSION vs FALSIFIED baseline rank 1)
+P3  rank=None n=2  (expected 1) | R2 rank=3 n=3 (expected 1; was None)
+H1  3 n=3 | H2 None n=1 | H3 3 n=3 | H4 2 n=2 | H5 1 n=5 | H6 3 n=5
+H7  None n=1 | H8 1 n=5 | H9 None n=5 | H10 None n=1 | H11 1 n=4 | H12 2 n=3
+N1  None (clean) | DOC None (clean)
+```
+
+Controls clean throughout: no unexpected boosts, no doc boosts, no
+reranker-cache voids, no degraded rows, no timeouts
+(`model=llama.cpp-reranker` every row — sigmoid fix confirmed live).
+
+## 4. Analysis (why RED)
+
+1. **Retrieval never surfaces any `artifact_gc.py` chunk for the P3 query.**
+   FINAL n=2 are both JSON experiment artifacts
+   (`reranker_p3/rerank_probe_run1.json:0`, `noderag/results/results.json:1`).
+   The P3 query's distinctive terms (`_cleanup_old_projects`,
+   `retention_policy`) occur verbatim in OUR OWN probe/result JSON
+   (verified by grep) and nowhere in `artifact_gc.py` — they dominate BM25
+   while the 0.77 doc chunk sits outside the pool. The P3 pool-anchor can
+   only anchor chunk 0 of files *already in the pool*; with zero pool chunks
+   from the target file it cannot fire. Design-level finding, not an
+   implementation bug. Fixing it means broadening retrieval/anchor scope —
+   beyond this task's minimal chunker brief.
+2. **P2 rank 2 is run-to-run noise, not a chunker regression.** A follow-up
+   fresh-process P2 run put `engine.py:35` back at rank 1; that run logged
+   `FTS5 search timed out (>2s), skipping FTS5 tier` — tier membership
+   flip-flops (~2.18s prebuild vs 2s budget) and moves ranks 1↔2. Same noise
+   class explains H6 2→3 / H11 2→1 / H12 None→2 wobbles. H-set: no systematic
+   demotion (H5=1, H8=1, H11=1 hold; R2 None→3 and H12 None→2 improved).
+3. **Infra incidents during this run (caveats):**
+   - Double-write: post-reindex table held 29,134 rows (every chunk twice,
+     identical ids). In-run mechanism unproven; repaired deterministically
+     (pandas dedup by id → wipe → single re-add, round-trip validated on a
+     scratch table first: vectors/text identical). AFTER = 14,839 verified.
+   - `_safe_ivf_index` (optimize/create_index) aborted: PID lock held by live
+     MCP servers (pid 2944/13172). Table now has NO vector index (flat exact
+     scan — correct, slightly slower; fine for the gate). Owner should run
+     `intel_trigger_reindex(full)` or Reload-Window Zed so the servers
+     re-open the table (their handles predate the wipe) and finalize IVF.
+   - Unrelated dirt `experiments/planted_break/results.json` was already
+     modified before this task — left untouched, unstaged.
+
+## Verdict
+
+RED per gate rule (P3 None, P2 2, R2 3 — all expected 1). No PR opened.
+Chunker fix stands on its own (unit + live verified); P3 rank 1 needs a
+retrieval-side follow-up (anchor scope / BM25 competition from experiment
+JSON artifacts), proposed as the next drill-down level, not this branch.
diff --git a/experiments/reranker_p3/RESULT.md b/experiments/reranker_p3/RESULT.md
new file mode 100644
index 00000000..f8dc5677
--- /dev/null
+++ b/experiments/reranker_p3/RESULT.md
@@ -0,0 +1,56 @@
+# P3 module-head anchor — live result (2026-09-29): FALSIFIED
+
+Mechanism implemented per `PREREG.md` (`_anchor_module_head_chunks_async`,
+`engine.py`, P2-style, caps `_O1_ANCHOR_TOTAL` / `MAX_RERANKER_INPUT=30`,
+`MIN_RERANK_SCORE=0.3` untouched). Live holdout validation
+(`scripts/p3_holdout_gate.py`, fresh process, FTS prebuild + discarded warm-up
++ per-case reranker-cache clear, BGE-M3 on :8081, embed on :8080) REJECTS the
+prereg expectation: **P3 rank None (expected 1), R2 rank None (expected 1)**.
+
+## What was verified live (mechanism works as coded)
+
+Pre-rerank pool capture for the P3 query
+(`ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy`): pool n=8,
+`src/core/artifact_gc.py:0` present with `module_head_anchor=True`, pool cap
+respected. The anchor does what the spec says.
+
+## Why the hit does not happen (two load-bearing findings)
+
+1. **chunk_index 0 is not a docstring chunk — for ANY file.** The AST chunker
+   drops module-level docstrings index-wide (verified: `artifact_gc.py` has 6
+   chunks, all function-scoped; chunk 0 = `def _dir_has_files`, len 279;
+   `engine.py` chunk 0 = `def _cache_key`; `graph.py`, `llama_runner.py`
+   likewise first-function). The probe passage that scores +0.83 (`gold_doc`,
+   first 800 chars of the file) does not exist as an indexed chunk. The real
+   chunk 0 scores **-6.66** on the P3 query — correctly cut. No pool-anchor can
+   place a chunk the index never built. Prereg clause (i)/(ii) fire.
+2. **The EXPERIMENTS_LOG:2813 sigmoid fix is absent from the code.**
+   `grep sigmoid src/` = zero hits; the llama_cpp path stores raw logits in
+   `reranker_score` (`multi_provider.py:500-502`, `apply_scores`) and filters
+   them against `MIN_RERANK_SCORE=0.3` (`multi_provider.py:670`). Live winner
+   for P3 was a junk JSON chunk at logit +1.65; FINAL n=1. Out of scope here
+   (threshold untouched by design), but it explains the all-None holdout rows.
+
+## Full holdout table (branch, rev e5756f55 + anchor)
+
+```
+P2  rank=1    n=2  (no P2 regression)
+P3  rank=None n=1  | R2 rank=None n=1
+H1  None n=1 | H2 None n=1 | H3 None n=1 | H4 2 n=2 | H5 1 n=5 | H6 2 n=3
+H7  None n=1 | H8 1 n=5 | H9 None n=5 | H10 None n=1 | H11 2 n=2 | H12 None n=1
+N1  None (negative control, clean) | DOC None (doc-control, clean)
+```
+
+Controls clean throughout: no unexpected boosts, no doc boosts, no
+reranker-cache voids, no degraded rows (reranker ran every query,
+`model=llama.cpp-reranker`). H-rank Nones are threshold cuts (finding 2),
+not anchor demotions — the anchor is append-only pre-rerank and cannot demote
+a chunk that passes the threshold.
+
+## Verdict
+
+FALSIFIED per prereg rule. No PR opened (nothing to propose). Next step, if
+wanted, is index-level, not pool-level: emit a module-docstring chunk at index
+time (parser/indexer change + reindex), then re-run this gate. The mocked
+suite (`tests/test_p3_module_head_anchor.py`, 9 passed) and the gate script
+stay on the branch as the reusable harness for that attempt.
diff --git a/experiments/reranker_p3/SHA256SUMS b/experiments/reranker_p3/SHA256SUMS
new file mode 100644
index 00000000..f7e9cd27
--- /dev/null
+++ b/experiments/reranker_p3/SHA256SUMS
@@ -0,0 +1,6 @@
+0a8718e9c1293f85c7493fb4062bfcbad9075be2d3f3851b990a8be67320ff7e  rerank_probe_run1.json
+e40f153d8638d911024eefc476be7d534ba79d5ca04047daff5115d0e0c9b34b  rerank_probe_run2.json
+fcaf3a725af6c366ace02292a3226d741797b62e120cef4fcc16a1ba4433177c  probe_rerank.py
+706f64b4cd6538cf637c7c42b93d0a94884d638c528e849c864ecbe421a723f4  probe_rerank2.py
+1bb952b9f911d32a88dc44ce2dc2fd8ef584405c78fcedaf53aa220f5369a6f6  README.md
+ea9681e6dbef57fed0b2a5010a38debf70dad8de9c6ba1e113d1ac765d1f3307  PREREG.md
diff --git a/experiments/reranker_p3/probe_rerank.py b/experiments/reranker_p3/probe_rerank.py
new file mode 100644
index 00000000..35892f91
--- /dev/null
+++ b/experiments/reranker_p3/probe_rerank.py
@@ -0,0 +1,71 @@
+"""Fresh-process direct reranker probe for OPEN item #3 (P3/R2 gold below threshold).
+Bypasses retrieval: POSTs straight to llama.cpp /v1/rerank on :8081.
+Stdlib only. Raw JSON -> same dir as this script (%TEMP%\\opencode\\).
+"""
+import io, json, math, sys, urllib.request
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+
+BASE = "http://127.0.0.1:8081"
+OUT = sys.argv[1] if len(sys.argv) > 1 else "rerank_probe_out.json"
+
+REPO = "D:\\Project\\MSCodeBase"
+
+
+def load(rel, n=800):
+    with open(REPO + "\\" + rel, encoding="utf-8") as f:
+        return f.read()[:n].strip()
+
+
+def score(query, passages):
+    payload = json.dumps({"query": query, "texts": passages}).encode()
+    req = urllib.request.Request(BASE + "/rerank", data=payload,
+                                 headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return json.loads(r.read().decode())
+
+
+def sig(x):
+    return 1.0 / (1.0 + math.exp(-x))
+
+
+GOLD_DOC = load("src\\core\\artifact_gc.py", 800)          # module docstring head
+GOLD_CODE = open(REPO + "\\src\\core\\artifact_gc.py", encoding="utf-8").read()[1500:2300]  # _prune body
+D_ENGINE = load("src\\core\\search\\engine.py", 800)
+D_SETTINGS = load("src\\config\\settings.py", 800)
+D_DIARY = load("AGENT_DIARY.md", 800)
+
+QUERIES = {
+    "P3_orig": "ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy",
+    "R2_orig": "ArtifactGC 30d projects 90d telemetry 7d logs retention",
+    "short": "ArtifactGC",
+    "keyword": "ArtifactGC cleanup old projects retention days",
+    "defform": "What is the ArtifactGC retention policy for old projects telemetry logs",
+    "real_symbols": "ArtifactGC prune_stale_artifacts project_max_age_days telemetry_max_age_days",
+}
+
+PASSAGES = {"gold_doc": GOLD_DOC, "gold_code": GOLD_CODE, "distr_engine": D_ENGINE,
+            "distr_settings": D_SETTINGS, "distr_diary": D_DIARY}
+
+print(f"gold_doc len={len(GOLD_DOC)} gold_code len={len(GOLD_CODE)} "
+      f"max_passage={max(len(p) for p in PASSAGES.values())}", flush=True)
+
+result = {"queries": {}, "passage_lens": {k: len(v) for k, v in PASSAGES.items()}}
+for qname, q in QUERIES.items():
+    names = list(PASSAGES)
+    raw = score(q, [PASSAGES[k] for k in names])
+    logits = [d["score"] for d in sorted(raw, key=lambda d: d["index"])]
+    ranked = sorted(zip(names, logits), key=lambda t: t[1], reverse=True)
+    result["queries"][qname] = {
+        "query": q,
+        "logits": {n: lg for n, lg in zip(names, logits)},
+        "sigmoid": {n: round(sig(lg), 4) for n, lg in zip(names, logits)},
+        "rank": [n for n, _ in ranked],
+    }
+    print(f"== {qname} ==", flush=True)
+    for n, lg in ranked:
+        print(f"  {n:14s} logit={lg:+.4f} sig={sig(lg):.4f}", flush=True)
+
+with open(OUT, "w", encoding="utf-8") as f:
+    json.dump(result, f, indent=1)
+print(f"WROTE {OUT}", flush=True)
diff --git a/experiments/reranker_p3/probe_rerank2.py b/experiments/reranker_p3/probe_rerank2.py
new file mode 100644
index 00000000..b904d4ed
--- /dev/null
+++ b/experiments/reranker_p3/probe_rerank2.py
@@ -0,0 +1,50 @@
+"""Probe run 2: score every AST-plausible chunk of artifact_gc.py on P3/R2 queries.
+Identifies which gold chunk reproduces eval logit -0.99 (P3) / -2.60 (R2).
+"""
+import io, json, math, re, sys, urllib.request
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+BASE = "http://127.0.0.1:8081"
+OUT = sys.argv[1]
+SRC = open("D:\\Project\\MSCodeBase\\src\\core\\artifact_gc.py", encoding="utf-8").read()
+
+
+def score(query, passages):
+    payload = json.dumps({"query": query, "texts": passages}).encode()
+    req = urllib.request.Request(BASE + "/rerank", data=payload,
+                                 headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=120) as r:
+        return json.loads(r.read().decode())
+
+
+def sig(x):
+    return 1.0 / (1.0 + math.exp(-x))
+
+
+# Split into module-head + per-def chunks, mimicking AST chunking w/ scope header
+parts = re.split(r"(?m)^(?=def |^class )", SRC)
+chunks = {}
+for i, p in enumerate(parts):
+    m = re.match(r"(def |class )(\w+)", p)
+    name = m.group(2) if m else "module_head"
+    hdr = f"// Scope: other | function | src.core.artifact_gc\n" if m else "// Scope: module\n"
+    chunks[name] = (hdr + p)[:800].strip()
+
+print(f"n_chunks={len(chunks)} lens=" + ",".join(f"{k}:{len(v)}" for k, v in chunks.items()), flush=True)
+QUERIES = {
+    "P3_orig": "ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy",
+    "R2_orig": "ArtifactGC 30d projects 90d telemetry 7d logs retention",
+}
+result = {}
+for qname, q in QUERIES.items():
+    names = list(chunks)
+    raw = score(q, [chunks[k] for k in names])
+    logits = [d["score"] for d in sorted(raw, key=lambda d: d["index"])]
+    print(f"== {qname} ==", flush=True)
+    for n, lg in sorted(zip(names, logits), key=lambda t: t[1], reverse=True):
+        print(f"  {n:22s} logit={lg:+.4f} sig={sig(lg):.4f}", flush=True)
+    result[qname] = {n: lg for n, lg in zip(names, logits)}
+
+with open(OUT, "w", encoding="utf-8") as f:
+    json.dump(result, f, indent=1)
+print(f"WROTE {OUT}", flush=True)
diff --git a/experiments/reranker_p3/rerank_probe_run1.json b/experiments/reranker_p3/rerank_probe_run1.json
new file mode 100644
index 00000000..f79d8429
--- /dev/null
+++ b/experiments/reranker_p3/rerank_probe_run1.json
@@ -0,0 +1,155 @@
+{
+ "queries": {
+  "P3_orig": {
+   "query": "ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy",
+   "logits": {
+    "gold_doc": 0.7880698442459106,
+    "gold_code": -6.444812774658203,
+    "distr_engine": -10.041930198669434,
+    "distr_settings": -10.663209915161133,
+    "distr_diary": -6.093839645385742
+   },
+   "sigmoid": {
+    "gold_doc": 0.6874,
+    "gold_code": 0.0016,
+    "distr_engine": 0.0,
+    "distr_settings": 0.0,
+    "distr_diary": 0.0023
+   },
+   "rank": [
+    "gold_doc",
+    "distr_diary",
+    "gold_code",
+    "distr_engine",
+    "distr_settings"
+   ]
+  },
+  "R2_orig": {
+   "query": "ArtifactGC 30d projects 90d telemetry 7d logs retention",
+   "logits": {
+    "gold_doc": 1.4550944566726685,
+    "gold_code": -5.0061869621276855,
+    "distr_engine": -8.402853965759277,
+    "distr_settings": -10.299126625061035,
+    "distr_diary": -6.017618656158447
+   },
+   "sigmoid": {
+    "gold_doc": 0.8108,
+    "gold_code": 0.0067,
+    "distr_engine": 0.0002,
+    "distr_settings": 0.0,
+    "distr_diary": 0.0024
+   },
+   "rank": [
+    "gold_doc",
+    "gold_code",
+    "distr_diary",
+    "distr_engine",
+    "distr_settings"
+   ]
+  },
+  "short": {
+   "query": "ArtifactGC",
+   "logits": {
+    "gold_doc": 2.2785263061523438,
+    "gold_code": -7.584114074707031,
+    "distr_engine": -6.615355491638184,
+    "distr_settings": -7.751883029937744,
+    "distr_diary": -5.450006484985352
+   },
+   "sigmoid": {
+    "gold_doc": 0.9071,
+    "gold_code": 0.0005,
+    "distr_engine": 0.0013,
+    "distr_settings": 0.0004,
+    "distr_diary": 0.0043
+   },
+   "rank": [
+    "gold_doc",
+    "distr_diary",
+    "distr_engine",
+    "gold_code",
+    "distr_settings"
+   ]
+  },
+  "keyword": {
+   "query": "ArtifactGC cleanup old projects retention days",
+   "logits": {
+    "gold_doc": 3.432910680770874,
+    "gold_code": -4.4543962478637695,
+    "distr_engine": -10.128113746643066,
+    "distr_settings": -10.337459564208984,
+    "distr_diary": -6.087577819824219
+   },
+   "sigmoid": {
+    "gold_doc": 0.9687,
+    "gold_code": 0.0115,
+    "distr_engine": 0.0,
+    "distr_settings": 0.0,
+    "distr_diary": 0.0023
+   },
+   "rank": [
+    "gold_doc",
+    "gold_code",
+    "distr_diary",
+    "distr_engine",
+    "distr_settings"
+   ]
+  },
+  "defform": {
+   "query": "What is the ArtifactGC retention policy for old projects telemetry logs",
+   "logits": {
+    "gold_doc": 1.7452340126037598,
+    "gold_code": -7.936079502105713,
+    "distr_engine": -9.989875793457031,
+    "distr_settings": -10.9386625289917,
+    "distr_diary": -7.29052734375
+   },
+   "sigmoid": {
+    "gold_doc": 0.8514,
+    "gold_code": 0.0004,
+    "distr_engine": 0.0,
+    "distr_settings": 0.0,
+    "distr_diary": 0.0007
+   },
+   "rank": [
+    "gold_doc",
+    "distr_diary",
+    "gold_code",
+    "distr_engine",
+    "distr_settings"
+   ]
+  },
+  "real_symbols": {
+   "query": "ArtifactGC prune_stale_artifacts project_max_age_days telemetry_max_age_days",
+   "logits": {
+    "gold_doc": 4.755861282348633,
+    "gold_code": -7.226933479309082,
+    "distr_engine": -6.984439373016357,
+    "distr_settings": -9.468976974487305,
+    "distr_diary": -5.173090934753418
+   },
+   "sigmoid": {
+    "gold_doc": 0.9915,
+    "gold_code": 0.0007,
+    "distr_engine": 0.0009,
+    "distr_settings": 0.0001,
+    "distr_diary": 0.0056
+   },
+   "rank": [
+    "gold_doc",
+    "distr_diary",
+    "distr_engine",
+    "gold_code",
+    "distr_settings"
+   ]
+  }
+ },
+ "passage_lens": {
+  "gold_doc": 800,
+  "gold_code": 800,
+  "distr_engine": 800,
+  "distr_settings": 797,
+  "distr_diary": 800
+ }
+}
\ No newline at end of file
diff --git a/experiments/reranker_p3/rerank_probe_run2.json b/experiments/reranker_p3/rerank_probe_run2.json
new file mode 100644
index 00000000..69500f12
--- /dev/null
+++ b/experiments/reranker_p3/rerank_probe_run2.json
@@ -0,0 +1,18 @@
+{
+ "P3_orig": {
+  "module_head": 0.5668665170669556,
+  "_dir_has_files": -6.313180446624756,
+  "_rmtree_safe": -3.794283390045166,
+  "_prune_project_dirs": -1.3174166679382324,
+  "_prune_telemetry": -2.575758457183838,
+  "prune_stale_artifacts": -0.6998268365859985
+ },
+ "R2_orig": {
+  "module_head": 0.4332163333892822,
+  "_dir_has_files": -5.922153949737549,
+  "_rmtree_safe": -3.7569305896759033,
+  "_prune_project_dirs": -1.972429633140564,
+  "_prune_telemetry": -0.9512827396392822,
+  "prune_stale_artifacts": 0.2744801640510559
+ }
+}
\ No newline at end of file
diff --git a/scripts/p3_holdout_gate.py b/scripts/p3_holdout_gate.py
new file mode 100644
index 00000000..af2a4b6c
--- /dev/null
+++ b/scripts/p3_holdout_gate.py
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""P3 module-head-anchor holdout gate (live, fresh-process): P3 + R2 + H1-H12.
+
+Usage:
+    python scripts/p3_holdout_gate.py [--project D:/Project/MSCodeBase]
+
+Pattern follows scripts/p2_holdout_gate.py (ONE event loop, blocking FTS
+prebuild, discarded warm-up, explicit reranker-cache clear per case, void /
+degraded flags). Case table imported from o1_holdout_gate (O1-holdout-v1,
+single source of truth); P3/R2 defined HERE (holdout-style queries with known
+target file, disjoint from the frozen eval-16 — NEVER validate on eval-16).
+
+Prereg: experiments/reranker_p3/PREREG.md (2026-09-29). Rerank evidence:
+experiments/reranker_p3/rerank_probe_run{1,2}.json + EXPERIMENTS_LOG.md:2809.
+
+PASS RULES: P3 rank==1 (prereg-expected hit: the anchored head chunk scores
+highest at the reranker); P2 rank==1 (no regression of the P2 anchor);
+expect_no_boost cases unboosted; doc chunks never boosted; no reranker-cache
+void measurements; no degraded rows (reranker_ms falsy = invalid, loud fail).
+H1-H12 rows are reported in full (falsification clause ii) — gate-relevant
+only via the shared controls; any H-row regression vs the p2-gate baseline
+is investigated, not silently kept.
+"""
+
+import argparse
+import asyncio
+import sys
+import time
+import traceback
+from pathlib import Path
+
+if sys.stdout.encoding and sys.stdout.encoding.lower() != "utf-8":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+    except Exception:  # noqa: BLE001 — encoding guard must never fail startup
+        pass
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from scripts.o1_holdout_gate import (  # noqa: E402 — imported for the case table
+    HOLDOUT,
+    P2,
+    QUERY_TIMEOUT,
+    build_searcher,
+    rank_of,
+)
+
+P3 = {"id": "P3", "query": "ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy",
+      "target": "src/core/artifact_gc.py", "expect_rank": 1}
+
+R2 = {"id": "R2", "query": "ArtifactGC 30d projects 90d telemetry 7d logs retention",
+      "target": "src/core/artifact_gc.py", "expect_rank": 1}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--project", default=str(ROOT))
+    args = ap.parse_args()
+    project = Path(args.project)
+    try:
+        import subprocess  # noqa: PLC0415
+
+        rev = (
+            subprocess.run(
+                ["git", "rev-parse", "--short", "HEAD"],
+                cwd=str(ROOT),
+                capture_output=True,
+                timeout=10,
+            )
+            .stdout.decode()
+            .strip()
+        )
+    except Exception:  # noqa: BLE001 — git metadata is best-effort diagnostics
+        rev = "unknown"
+    print(f"P3-anchor holdout gate | rev={rev} | project={project} | fresh process")
+    searcher = build_searcher(project)
+    rows = asyncio.run(_run_all(searcher))
+    print("---")
+    fails = []
+    for must in (P2, P3, R2):
+        row = next(r for r in rows if r["id"] == must["id"])
+        if row["rank"] != 1:
+            fails.append(f"{must['id']} rank={row['rank']} (expected 1)")
+    for row in rows:
+        case = next(c for c in [P2, P3, R2, *HOLDOUT] if c["id"] == row["id"])
+        if case.get("expect_no_boost") and row["n_boost"]:
+            fails.append(f"{row['id']} unexpectedly boosted")
+        if case.get("expect_no_doc_boost") and row["n_doc_boost"]:
+            fails.append(f"{row['id']} doc chunk boosted")
+        if row["void"]:
+            fails.append(f"{row['id']} reranker-cache void (wall<2s, no timing)")
+        if row["degraded"]:
+            fails.append(f"{row['id']} reranker degraded (reranker_ms=0, passthrough)")
+        if row["timed_out"]:
+            fails.append(f"{row['id']} query timed out (>{QUERY_TIMEOUT}s)")
+    if fails:
+        print("GATE FAIL: " + "; ".join(fails))
+        return 1
+    print("GATE PASS")
+    return 0
+
+
+async def _run_all(searcher):
+    """Whole sequence on ONE event loop (see p2_holdout_gate HARNESS LESSON)."""
+    # Blocking FTS prebuild (discarded): cold build ~2.9s > 2s tier budget.
+    t0 = time.perf_counter()
+    await asyncio.to_thread(searcher._build_fts5_index)
+    print(f"FTS prebuild (discarded): {time.perf_counter() - t0:.2f}s")
+    # Discarded warm-up on a disjoint query (cache key includes query text).
+    await asyncio.wait_for(
+        searcher.hybrid_search_async("warmup cold start primer", limit=3),
+        timeout=QUERY_TIMEOUT,
+    )
+    rows = []
+    for case in [P2, P3, R2, *HOLDOUT]:
+        searcher._reranker_cache.clear()
+        t0 = time.perf_counter()
+        try:
+            results = await asyncio.wait_for(
+                searcher.hybrid_search_async(case["query"], limit=5),
+                timeout=QUERY_TIMEOUT,
+            )
+            timed_out = False
+        except asyncio.TimeoutError:
+            results = []
+            timed_out = True
+        wall = time.perf_counter() - t0
+        boosted = [r for r in results if r.get("identifier_boost")]
+        doc_boosted = [
+            r
+            for r in boosted
+            if str((r.get("metadata") or {}).get("file", ""))
+            .lower()
+            .endswith((".md", ".markdown", ".rst", ".txt", ".ipynb"))
+        ]
+        rank = rank_of(results, case["target"]) if case.get("target") else None
+        timing = dict(getattr(searcher, "_last_rerank_timing", None) or {})
+        void = wall < 2.0 and timing == {}
+        degraded = not timing.get("reranker_ms")
+        rows.append(
+            {
+                "id": case["id"],
+                "rank": rank,
+                "target": case.get("target"),
+                "n_boost": len(boosted),
+                "n_doc_boost": len(doc_boosted),
+                "n": len(results),
+                "wall": round(wall, 2),
+                "void": void,
+                "degraded": degraded,
+                "timed_out": timed_out,
+            }
+        )
+        print(
+            f"{case['id']:>3} rank={rank} n={len(results)} target={case.get('target')} "
+            f"boost={len(boosted)} doc_boost={len(doc_boosted)} wall={wall:.2f}s "
+            f"rerank_ms={timing.get('reranker_ms')} model={timing.get('model')} "
+            f"flags={None if searcher._multi_reranker is None else (searcher._multi_reranker.ollama_available, searcher._multi_reranker.llama_cpp_available)}"
+        )
+    return rows
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception:  # noqa: BLE001 — gate must report, never crash silently
+        traceback.print_exc()
+        sys.exit(1)
diff --git a/src/core/indexing/file_guard.py b/src/core/indexing/file_guard.py
index 22044ea5..6fb47007 100644
--- a/src/core/indexing/file_guard.py
+++ b/src/core/indexing/file_guard.py
@@ -67,6 +67,7 @@ def should_skip_file(self, file_path: Path) -> bool:
         """Проверяет, нужно ли пропускать файл.
 
         Layer 2-4: Artifact Guard + Feedback Guard + Embedding Guard.
+        Layer 5: Measurement Hygiene (собственные замеры вне индекса).
         """
         # Layer 2: если файл в системной директории — сразу skip
         if SystemArtifacts.is_in_system_dir(file_path):
@@ -74,6 +75,9 @@ def should_skip_file(self, file_path: Path) -> bool:
         # Layer 3: если файл — feedback risk (создан индексатором)
         if SystemArtifacts.is_feedback_risk(file_path):
             return True
+        # Layer 5: артефакты собственных замеров (probe/result, results/work)
+        if SystemArtifacts.is_measurement_artifact(file_path):
+            return True
         # Layer 4: полная проверка (расширение, бинарность, размер, .gitignore)
         return not self.is_safe_to_index(file_path)
 
diff --git a/src/core/indexing/parser.py b/src/core/indexing/parser.py
index 62d51349..6276d990 100644
--- a/src/core/indexing/parser.py
+++ b/src/core/indexing/parser.py
@@ -520,11 +520,85 @@ def _parse_with_tree_sitter(self, file_path: Path, ext: str) -> tuple:
             tree.root_node, code, file_path, chunks, symbols, parent_context=""
         )
 
+        # P3 drill-down: AST-чанкер дропал module-level docstrings index-wide,
+        # и passage, который реранкер скорит выше всех, не существовал как
+        # чанк. Файл с docstring + функциями получает docstring чанком 0;
+        # без docstring — поведение без изменений; walk без чанков —
+        # fallback как раньше (срез 0 и так содержит head файла).
+        if chunks:
+            module_chunk = self._extract_module_docstring(file_path, ext)
+            if module_chunk is not None:
+                chunks.insert(0, module_chunk)
+
         if not chunks:
             return self._fallback_line_chunking(file_path)
 
         return chunks, symbols
 
+    # Имя символа для module-docstring чанка (chunk 0). Непустое и
+    # greppable — так наличие чанков проверяется запросом к индексу.
+    MODULE_DOC_SYMBOL = "__module_doc__"
+
+    def _extract_module_docstring(self, file_path: Path, ext: str):
+        """Module-level docstring .py-файла как чанк (chunk 0).
+
+        Только Python (stdlib ast — робастно к версиям tree-sitter
+        грамматик): первый statement — строковый Expr → чанк в том же
+        формате, что _walk_node. Иначе None (поведение без изменений).
+
+        Symbols не трогаем: это чанк для поиска, не definition для графа.
+        """
+        if ext != ".py":
+            return None
+        try:
+            import ast
+
+            source = file_path.read_text(encoding="utf-8", errors="ignore")
+            tree = ast.parse(source)
+        except Exception:
+            return None
+        if not tree.body or not isinstance(tree.body[0], ast.Expr):
+            return None
+        first = tree.body[0]
+        value = first.value
+        if not (isinstance(value, ast.Constant) and isinstance(value.value, str)):
+            return None
+        if not value.value or not value.value.strip():
+            return None
+        try:
+            segment = ast.get_source_segment(source, first)
+        except Exception:
+            segment = None
+        text = segment.strip() if segment and segment.strip() else value.value.strip()
+        if len(text) > self.MAX_CHUNK_CHARS:
+            text = text[: self.MAX_CHUNK_CHARS] + "\n..."
+
+        rel_path = str(file_path)
+        prefix = f"// File: {rel_path}\n"
+        meta = self._build_chunk_metadata(
+            rel_path,
+            symbol_name=self.MODULE_DOC_SYMBOL,
+            node_type="module_docstring",
+            context="",
+        )
+        return {
+            "text": prefix + text,
+            "text_compact": prefix + text,
+            "file": rel_path,
+            "start_line": 1,
+            "end_line": first.end_lineno or 1,
+            "type": "module_docstring",
+            "context": "",
+            "symbol_name": self.MODULE_DOC_SYMBOL,
+            # Metadata (MCompassRAG + SproutRAG) — как у _walk_node
+            "layer": meta["layer"],
+            "module_name": meta["module_name"],
+            "hierarchy_level": meta["hierarchy_level"],
+            "is_public": meta["is_public"],
+            "symbol_type": meta["symbol_type"],
+            "parent_id": meta["parent_id"],
+        }
+
     def _get_signature_and_docstring(self, node, code):
         """Извлекает сигнатуру и docstring символа из tree-sitter узла.
 
@@ -817,6 +891,7 @@ def _build_chunk_metadata(
             "fallback_lines": "lines",
             "giant_function_part": "function_part",
             "markdown_section": "section",
+            "module_docstring": "module",
         }
         hierarchy_level = hierarchy_map.get(node_type, "other")
 
diff --git a/src/core/search/engine.py b/src/core/search/engine.py
index 2323cbc7..e681c792 100644
--- a/src/core/search/engine.py
+++ b/src/core/search/engine.py
@@ -818,6 +818,79 @@ async def _anchor_identifier_chunks_async(
             logger.debug(f"[P2-anchor] +{added} exact-symbol chunks for {tokens}")
         return pool
 
+    async def _anchor_module_head_chunks_async(
+        self, pool: List[dict], query: str, limit: int
+    ) -> List[dict]:
+        """P3: anchor each candidate file's module-head chunk pre-rerank.
+
+        The reranker scores module-head/docstring chunks highest (persisted
+        probes: experiments/reranker_p3/rerank_probe_run{1,2}.json — gold_doc
+        #1 on 6/6 holdout-style queries; the eval code-chunk logit is P3
+        -0.99 / R2 -2.60 per EXPERIMENTS_LOG.md:2809), but the head never
+        enters the pool when multi-term RRF surfaces only a code chunk of
+        the file. For each distinct pool file (pool order), the chunk_index-0
+        head is resolved from the cached BM25 DataFrame (no new index
+        structures) and appended pre-rerank (tail, no re-sort — the reranker
+        re-sorts by its own scores), deduplicated by file:chunk_index,
+        capped at _O1_ANCHOR_TOTAL and MAX_RERANKER_INPUT — same bounds as
+        the P2 anchor above. Doc/data files are ineligible (P2/A2 doc-guard:
+        docs cite symbols without defining them). Any failure degrades to
+        the unanchored pool. limit<=0 keeps the empty contract.
+        """
+        if limit <= 0:
+            return pool
+        try:
+            self._build_bm25_index()
+            df = self._bm25_df
+            if df is None or df.empty:
+                return pool
+        except Exception:  # noqa: BLE001 — degraded BM25 never breaks search
+            return pool
+        have = set()
+        for r in pool:
+            meta = r.get("metadata") or {}
+            have.add(f"{meta.get('file', '?')}:{meta.get('chunk_index', 0)}")
+        added = 0
+        seen_files = set()
+        for r in pool:
+            if added >= _O1_ANCHOR_TOTAL or len(pool) >= MAX_RERANKER_INPUT:
+                break
+            meta = r.get("metadata") or {}
+            fname = str(meta.get("file", "") or "")
+            if not fname or fname in seen_files:
+                continue
+            seen_files.add(fname)
+            if not _is_anchor_eligible(r):
+                continue
+            try:
+                match = df[(df["file_path"] == fname) & (df["chunk_index"] == 0)]
+                if match.empty:
+                    continue
+                row = match.iloc[0]
+            except Exception:  # noqa: BLE001 — one bad file never breaks search
+                continue
+            key = f"{row['file_path']}:{row['chunk_index']}"
+            if key in have:
+                continue
+            pool.append(
+                {
+                    "text": str(row["text"]),
+                    "text_full": str(row.get("text_full", row["text"])),
+                    "metadata": {
+                        "file": str(row["file_path"]),
+                        "chunk_index": int(row["chunk_index"]),
+                        "indexed_at": str(row.get("indexed_at", "")),
+                        "layer": str(row.get("layer", "")),
+                    },
+                    "module_head_anchor": True,
+                }
+            )
+            have.add(key)
+            added += 1
+        if added:
+            logger.debug(f"[P3-anchor] +{added} module-head chunks")
+        return pool
+
     async def hybrid_search_async(
         self,
         query: str,
@@ -1067,6 +1140,15 @@ async def hybrid_search_async(
             pre_rerank_results, query, limit
         )
 
+        # === P3 (2026-09-29): module-head anchors at PRE-RERANK pool ===
+        # The reranker scores docstring heads highest (probes in
+        # experiments/reranker_p3/), but RRF surfaces code chunks only —
+        # the head of each candidate file is anchored so it reaches the
+        # reranker; O1/doc-guard/caps conventions inherited from P2.
+        pre_rerank_results = await self._anchor_module_head_chunks_async(
+            pre_rerank_results, query, limit
+        )
+
         # === O1 (2026-09-28): rare-identifier boost at PRE-RERANK pool (D3) ===
         # Runs here — after sort+cut/MMR, before the reranker — never post-cut:
         # the x100 guarantees a rare exact symbol match survives the reranker's
diff --git a/src/core/system_artifacts.py b/src/core/system_artifacts.py
index bfd97809..fe22d467 100644
--- a/src/core/system_artifacts.py
+++ b/src/core/system_artifacts.py
@@ -5,11 +5,12 @@
 пользовательским кодом. Предотвращает feedback loop (индексирование собственных
 описаний чанков) и защищает служебные данные от случайного попадания в индекс.
 
-Архитектура (4 уровня защиты):
+Архитектура (5 уровней защиты):
   Layer 1 — Directory Guard:   системные директории (.mscodebase/, .codebase_indices/)
   Layer 2 — Artifact Guard:    известные служебные файлы по имени/расширению
   Layer 3 — Feedback Guard:    файлы, созданные самим индексатором
   Layer 4 — Embedding Guard:   финальная проверка перед эмбеддингом
+  Layer 5 — Measurement Hygiene: собственные замеры (probe/result JSON, experiments/**/results|work)
 
 Использование:
     if SystemArtifacts.is_system_path(path):
@@ -100,6 +101,24 @@
 }
 
 
+# ══════════════════════════════════════════════════════════════
+# Layer 5: Measurement Hygiene — собственные замеры вне индекса
+# ══════════════════════════════════════════════════════════════
+# Probe/result JSON-дампы содержат дословный текст запросов — попадая в
+# индекс, они доминируют в BM25 и отравляют замеры (gate RED по вине
+# измерительного стенда, а не кода). Тот же эффект у файлов под
+# experiments/**/results и experiments/**/work.
+_MEASUREMENT_RESULTS_DIRS: Set[str] = {
+    "results",
+    "work",
+}
+
+_MEASUREMENT_JSON_STEMS: Set[str] = {
+    "probe",
+    "result",
+}
+
+
 # ══════════════════════════════════════════════════════════════
 # Public API
 # ══════════════════════════════════════════════════════════════
@@ -197,16 +216,44 @@ def is_feedback_risk(cls, path: Path) -> bool:
         name = path.name.lower()
         return name in _FEEDBACK_PATTERNS
 
-    # ─── Layer 4: Unified Check ─────────────────────────────
+    # ─── Layer 5: Measurement Hygiene ───────────────────────
+
+    @classmethod
+    def is_measurement_artifact(cls, path: Path) -> bool:
+        """Проверяет, является ли файл артефактом собственных замеров.
+
+        Два критерия (достаточно одного):
+        1. Файл лежит под ``experiments/**/results`` или ``experiments/**/work``
+           (любое расширение — дампы, логи, скрипты прогонов).
+        2. Имя — probe/result JSON-дамп (``*probe*.json``, ``*result*.json``,
+           регистронезависимо) в любом месте дерева.
+
+        Такие файлы содержат дословный текст проб-запросов и при индексации
+        доминируют в BM25 — измерительный стенд отравляет измерение.
+        """
+        parts = [p.lower() for p in path.parts]
+        if "experiments" in parts:
+            tail = parts[parts.index("experiments") + 1:]
+            if any(d in tail for d in _MEASUREMENT_RESULTS_DIRS):
+                return True
+        name = path.name.lower()
+        if name.endswith(".json"):
+            stem = name[:-len(".json")]
+            if any(s in stem for s in _MEASUREMENT_JSON_STEMS):
+                return True
+        return False
+
+    # ─── Unified Check ────────────────────────────────────────
 
     @classmethod
     def is_system_path(cls, path: Path) -> bool:
         """Единая проверка: является ли файл системным (финальный guard).
 
-        Объединяет все 3 уровня:
+        Объединяет все уровни:
         1. Находится в системной директории (Directory Guard).
         2. Является известным артефактом (Artifact Guard).
         3. Создан индексатором (Feedback Guard).
+        4. Артефакт собственных замеров (Measurement Hygiene).
 
         Returns:
             True — файл системный, не должен индексироваться.
@@ -217,4 +264,6 @@ def is_system_path(cls, path: Path) -> bool:
             return True
         if cls.is_feedback_risk(path):
             return True
+        if cls.is_measurement_artifact(path):
+            return True
         return False
diff --git a/src/providers/reranker/multi_provider.py b/src/providers/reranker/multi_provider.py
index a9571182..f5000efa 100644
--- a/src/providers/reranker/multi_provider.py
+++ b/src/providers/reranker/multi_provider.py
@@ -23,6 +23,7 @@
 
 import asyncio
 import logging
+import math
 import time
 from typing import Any, Dict, List, Optional
 
@@ -88,6 +89,16 @@ def _truncate_rerank_pair(
 MIN_RERANK_SCORE = 0.3
 
 
+def _sigmoid(x: float) -> float:
+    """Нормализация raw logit в [0, 1].
+
+    llama.cpp /v1/rerank возвращает raw logits ≈[-11, +11], а не вероятности —
+    без нормализации фильтр MIN_RERANK_SCORE отсекает почти всё подряд.
+    Только для llama_cpp-ветки; threshold 0.3 откалиброван под [0, 1].
+    """
+    return 1.0 / (1.0 + math.exp(-x))
+
+
 class MultiProviderReranker(IReranker):
     """Реранкер на основе внешних LLM-провайдеров (Ollama / LM Studio).
 
@@ -496,10 +507,11 @@ async def _llama_cpp_rerank(
                 results = data.get("results", [])
                 if results:
                     # Cohere format: results[i] = {"index": N, "relevance_score": F}
+                    # llama.cpp отдаёт raw logits ≈[-11, +11] → sigmoid в [0, 1]
                     scores = [0.0] * len(passages)
                     for r in results:
                         idx = r.get("index", 0)
-                        scores[idx] = r.get("relevance_score", 0.0)
+                        scores[idx] = _sigmoid(r.get("relevance_score", 0.0))
                     return scores
             logger.debug(f"llama.cpp rerank HTTP {resp.status_code}: {resp.text[:200]}")
             return None
diff --git a/tests/test_chunker_module_doc.py b/tests/test_chunker_module_doc.py
new file mode 100644
index 00000000..0337300e
--- /dev/null
+++ b/tests/test_chunker_module_doc.py
@@ -0,0 +1,111 @@
+"""
+Module-docstring chunk (P3 drill-down): chunker emits the module docstring
+as chunk 0 per .py file that has one; files without docstrings unchanged.
+"""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from src.core.indexing.parser import CodeParser
+
+
+@pytest.fixture
+def tmp_py():
+    """Временный .py-файл (удаляется после теста)."""
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, encoding="utf-8"
+    ) as f:
+        path = Path(f.name)
+    yield path
+    path.unlink(missing_ok=True)
+
+
+def _chunks(path):
+    parser = CodeParser()
+    result = parser.parse_file(path)
+    return result[0] if isinstance(result, tuple) else result
+
+
+def test_module_docstring_is_chunk_zero(tmp_py):
+    """Файл с docstring: chunk 0 — module docstring."""
+    tmp_py.write_text(
+        '"""ArtifactGC — очистка устаревших артефактов MCP."""\n'
+        "\n"
+        "import os\n"
+        "\n"
+        "\n"
+        "def hello():\n"
+        '    """Hi."""\n'
+        "    return 1\n",
+        encoding="utf-8",
+    )
+    chunks = _chunks(tmp_py)
+    assert len(chunks) == 2
+    head = chunks[0]
+    assert head["type"] == "module_docstring"
+    assert head["symbol_name"] == CodeParser.MODULE_DOC_SYMBOL
+    assert "ArtifactGC" in head["text"]
+    assert head["start_line"] == 1
+    assert head["hierarchy_level"] == "module"
+    # Остальные чанки — функции, порядок сохранён
+    assert chunks[1]["type"] == "function_definition"
+
+
+def test_no_docstring_unchanged(tmp_py):
+    """Файл без docstring: chunk 0 — первая функция, как раньше."""
+    tmp_py.write_text(
+        "import os\n"
+        "\n"
+        "\n"
+        "def hello():\n"
+        '    """Hi."""\n'
+        "    return 1\n"
+        "\n"
+        "\n"
+        "def world():\n"
+        "    return 2\n",
+        encoding="utf-8",
+    )
+    chunks = _chunks(tmp_py)
+    assert len(chunks) == 2
+    assert chunks[0]["type"] == "function_definition"
+    assert chunks[0]["symbol_name"] == "hello"
+    assert all(c["type"] != "module_docstring" for c in chunks)
+
+
+def test_chunk_counts_fixture_file():
+    """Фикстура репо: N функций + docstring → N+1 чанков, head — docstring."""
+    from src.core.indexing.parser import CodeParser as _CP
+
+    fixture = Path(__file__).resolve().parent.parent / "src" / "core" / "artifact_gc.py"
+    assert fixture.exists()
+    parser = _CP()
+    chunks, _symbols = parser.parse_file(fixture)
+    rest = [c for c in chunks if c["type"] != "module_docstring"]
+    assert len(rest) >= 2  # функции (+ parts гигантской prune_stale_artifacts)
+    assert len(chunks) == len(rest) + 1
+    assert chunks[0]["type"] == "module_docstring"
+    assert "ArtifactGC" in chunks[0]["text"]
+
+
+def test_syntax_error_no_crash(tmp_py):
+    """Битый файл: без исключений, поведение fallback без изменений."""
+    tmp_py.write_text("def broken(:\n  ???\n", encoding="utf-8")
+    chunks = _chunks(tmp_py)
+    assert all(c["type"] != "module_docstring" for c in chunks)
+
+
+def test_non_python_unchanged(tmp_py):
+    """Не-Python: module-чанк не эмитится."""
+    js_file = tmp_py.with_suffix(".js")
+    js_file.write_text(
+        "function hello() {\n  return 1;\n}\n",
+        encoding="utf-8",
+    )
+    try:
+        chunks = _chunks(js_file)
+    finally:
+        js_file.unlink(missing_ok=True)
+    assert all(c.get("type") != "module_docstring" for c in chunks)
diff --git a/tests/test_measurement_hygiene.py b/tests/test_measurement_hygiene.py
new file mode 100644
index 00000000..ec4e8a02
--- /dev/null
+++ b/tests/test_measurement_hygiene.py
@@ -0,0 +1,92 @@
+"""Тесты Measurement Hygiene (Layer 5): собственные замеры вне индекса.
+
+Probe/result JSON-дампы содержат дословный текст проб-запросов — попадая
+в индекс, они доминируют в BM25 (gate RED по вине измерительного стенда).
+Проверяется предикат, которым пользуются все обходы индексатора
+(`indexer.py:842`, `index_project_runner.py:335`, `freshness.py:93`,
+`index_status.py:157`): `FileGuard.should_skip_file`.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from src.core.indexing.file_guard import FileGuard
+from src.core.system_artifacts import SystemArtifacts
+
+
+def _write(path: Path, content: bytes = b'{"query": "hybrid_search_async"}') -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(content)
+    return path
+
+
+@pytest.mark.parametrize(
+    "rel",
+    [
+        "experiments/reranker_p3/rerank_probe_run1.json",
+        "experiments/4A_unit_of_return/f5/results_fresh.json",
+        "experiments/token_reduction/results/metrics.json",
+        "experiments/4A_unit_of_return/results/f5judged/work/dump.json",
+        "experiments/planted_break/results.json",
+        "misc_probes/PROBE_out.json",
+        "RESULTS_probe.json",
+    ],
+)
+def test_probe_result_json_dumps_are_measurement_artifacts(rel):
+    """Probe/result JSON-дампы опознаются в любом месте дерева."""
+    assert SystemArtifacts.is_measurement_artifact(Path(rel)) is True
+
+
+@pytest.mark.parametrize(
+    "rel",
+    [
+        "experiments/noderag/results/summary.md",
+        "experiments/closure_walk/results/graph.json",
+        "experiments/4A_unit_of_return/results/f5judged/work/trace.py",
+        "experiments/x/work/notes.txt",
+    ],
+)
+def test_results_work_subtrees_are_measurement_artifacts(rel):
+    """Любой файл под experiments/**/results|work — артефакт замеров."""
+    assert SystemArtifacts.is_measurement_artifact(Path(rel)) is True
+
+
+@pytest.mark.parametrize(
+    "rel",
+    [
+        "src/core/search/engine.py",
+        "src/core/system_artifacts.py",
+        "experiments/4A_unit_of_return/f5/RESULTS_JUDGED.md",
+        "package.json",
+        "tsconfig.json",
+        "experiments/notes.md",
+    ],
+)
+def test_legit_files_are_not_measurement_artifacts(rel):
+    """Обычный код, конфиги и writeup-доки вне results/work не трогаем."""
+    assert SystemArtifacts.is_measurement_artifact(Path(rel)) is False
+
+
+def test_indexer_walk_skips_probe_json_in_tree(tmp_path):
+    """Probe-JSON, положенный в дерево, пропускается обходом индексатора."""
+    dumped = _write(tmp_path / "experiments" / "reranker_p3" / "probe_run9.json")
+    legit = _write(tmp_path / "src" / "engine.py", b"def hybrid_search_async():\n    pass\n")
+    guard = FileGuard(tmp_path)
+    assert guard.should_skip_file(dumped) is True
+    assert guard.should_skip_file(legit) is False
+
+
+def test_indexer_walk_skips_results_work_files(tmp_path):
+    """Файлы под experiments/**/results|work пропускаются (любое расширение)."""
+    junk = _write(tmp_path / "experiments" / "noderag" / "results" / "hits.md", b"# hits")
+    work = _write(tmp_path / "experiments" / "x" / "work" / "trace.py", b"x = 1\n")
+    guard = FileGuard(tmp_path)
+    assert guard.should_skip_file(junk) is True
+    assert guard.should_skip_file(work) is True
+
+
+def test_is_system_path_covers_measurement_layer(tmp_path):
+    """Единый финальный guard тоже отсекает замеры."""
+    assert SystemArtifacts.is_system_path(Path("experiments/a/results/b.json")) is True
+    assert SystemArtifacts.is_system_path(Path("src/a.py")) is False
diff --git a/tests/test_p3_module_head_anchor.py b/tests/test_p3_module_head_anchor.py
new file mode 100644
index 00000000..de211d70
--- /dev/null
+++ b/tests/test_p3_module_head_anchor.py
@@ -0,0 +1,151 @@
+"""P3 module-head anchors: each candidate file's head chunk enters the pool.
+
+Root cause (probes persisted 2026-09-29 in experiments/reranker_p3/):
+fresh-process direct reranker probes (BGE-M3 on :8081, holdout-style queries,
+never the frozen eval-16) rank the gold module-head/docstring chunk #1 on 6/6
+queries (rerank_probe_run1.json: gold_doc sigmoid 0.69-0.99; run2: module_head
+top on P3/R2, all code chunks negative), while the eval code chunk scores a
+negative logit (P3 -0.99, R2 -2.60 per EXPERIMENTS_LOG.md:2809) and dies at
+MIN_RERANK_SCORE=0.3. The head never reaches the reranker because multi-term
+RRF surfaces only a code chunk of the file.
+
+Fix: _anchor_module_head_chunks_async — chunk_index-0 head per distinct pool
+file (cached BM25 DataFrame, no new index structures), appended pre-rerank,
+capped at _O1_ANCHOR_TOTAL / MAX_RERANKER_INPUT. All tests use a stub DataFrame
+(no live services); live validation via scripts/p3_holdout_gate.py.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pandas as pd
+
+from src.config.settings import MAX_RERANKER_INPUT
+from src.core.search.engine import _O1_ANCHOR_TOTAL
+
+GOLD = "src/core/artifact_gc.py"
+P3Q = "ArtifactGC _cleanup_old_projects 30d 90d 7d retention_policy"
+
+
+def _pool_chunk(path, idx=5):
+    return {
+        "text": "def _prune_body(): ...",
+        "metadata": {"file": path, "chunk_index": idx},
+        "final_score": 0.01,
+    }
+
+
+def _df(rows):
+    return pd.DataFrame(
+        [
+            {
+                "file_path": path,
+                "chunk_index": idx,
+                "text": text,
+                "text_full": text,
+                "indexed_at": "",
+                "layer": "",
+            }
+            for path, idx, text in rows
+        ]
+    )
+
+
+class _FakeSearcher:
+    """Minimal harness around the real P3 anchor method (stub DataFrame)."""
+
+    def __init__(self, df):
+        from src.core.search.engine import Searcher
+
+        self._anchor = Searcher._anchor_module_head_chunks_async.__get__(self)
+        self._bm25_df = df
+
+    def _build_bm25_index(self):
+        return None
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+HEAD_TEXT = '"""Artifact retention policy: 30d projects 90d telemetry."""'
+
+
+def test_pool_contains_gold_head_chunk():
+    """P3 assertion: gold file's head chunk enters the pool pre-rerank."""
+    pool = [_pool_chunk(GOLD, idx=5)]
+    s = _FakeSearcher(_df([(GOLD, 0, HEAD_TEXT)]))
+    out = _run(s._anchor(pool, P3Q, 5))
+    files = [(r["metadata"]["file"], r["metadata"]["chunk_index"]) for r in out]
+    assert (GOLD, 0) in files
+    heads = [r for r in out if r.get("module_head_anchor")]
+    assert len(heads) == 1 and heads[0]["metadata"]["file"] == GOLD
+
+
+def test_head_already_in_pool_no_dup():
+    pool = [_pool_chunk(GOLD, idx=5), _pool_chunk(GOLD, idx=0)]
+    s = _FakeSearcher(_df([(GOLD, 0, HEAD_TEXT)]))
+    out = _run(s._anchor(pool, P3Q, 5))
+    assert len(out) == 2  # dedup by file:chunk_index — nothing appended
+
+
+def test_doc_files_never_anchor():
+    """Doc-guard (P2/A2): docs cite symbols without defining — no head anchor."""
+    pool = [
+        {"text": "# note", "metadata": {"file": "docs/NOTE.md", "chunk_index": 2},
+         "final_score": 0.01},
+    ]
+    s = _FakeSearcher(_df([("docs/NOTE.md", 0, "# head"), (GOLD, 0, HEAD_TEXT)]))
+    out = _run(s._anchor(pool, P3Q, 5))
+    assert len(out) == 1  # .md file ineligible even with a head row present
+    assert not [r for r in out if r.get("module_head_anchor")]
+
+
+def test_data_files_never_anchor():
+    pool = [_pool_chunk("src/providers/embedder/canary_set.json", idx=1)]
+    s = _FakeSearcher(
+        _df([("src/providers/embedder/canary_set.json", 0, "{}"), (GOLD, 0, HEAD_TEXT)])
+    )
+    out = _run(s._anchor(pool, P3Q, 5))
+    assert out == pool  # .json ineligible
+
+
+def test_total_cap_and_pool_cap():
+    pool = [_pool_chunk(f"src/f{i}.py", idx=i + 1) for i in range(10)]
+    s = _FakeSearcher(_df([(f"src/f{i}.py", 0, HEAD_TEXT) for i in range(10)]))
+    out = _run(s._anchor(pool, P3Q, 5))
+    assert len(out) <= 10 + _O1_ANCHOR_TOTAL
+    assert len(out) <= MAX_RERANKER_INPUT
+    keys = [(r["metadata"]["file"], r["metadata"]["chunk_index"]) for r in out]
+    assert len(keys) == len(set(keys))
+
+
+def test_full_pool_unchanged():
+    pool = [_pool_chunk(f"src/f{i}.py", idx=1) for i in range(MAX_RERANKER_INPUT)]
+    s = _FakeSearcher(_df([(f"src/f{i}.py", 0, HEAD_TEXT) for i in range(10)]))
+    out = _run(s._anchor(pool, P3Q, 5))
+    assert len(out) == MAX_RERANKER_INPUT  # pool cap respected
+
+
+def test_limit_zero_keeps_empty_contract():
+    s = _FakeSearcher(_df([(GOLD, 0, HEAD_TEXT)]))
+    assert _run(s._anchor([], P3Q, 0)) == []
+
+
+def test_no_head_row_degrades_to_pool():
+    """File without a chunk_index-0 row: pool passes through unchanged."""
+    pool = [_pool_chunk(GOLD, idx=5)]
+    s = _FakeSearcher(_df([(GOLD, 3, "def x(): ...")]))
+    assert _run(s._anchor(pool, P3Q, 5)) == pool
+
+
+def test_no_bm25_dataframe_degrades_to_pool():
+    pool = [_pool_chunk(GOLD, idx=5)]
+
+    class _NoDf(_FakeSearcher):
+        def _build_bm25_index(self):
+            self._bm25_df = None
+
+    s = _NoDf(_df([(GOLD, 0, HEAD_TEXT)]))
+    assert _run(s._anchor(pool, P3Q, 5)) == pool