diff --git a/Cargo.lock b/Cargo.lock
index 984a9b9..6f0f1f6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1759,7 +1759,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-api"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "futures-util",
@@ -1787,7 +1787,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-cache"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "neuromesh-core",
@@ -1800,7 +1800,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-cli"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "dirs",
@@ -1830,7 +1830,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-context"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "blake3",
  "chrono",
@@ -1849,7 +1849,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-core"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "dirs",
@@ -1863,7 +1863,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-embed"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "dirs",
  "fastembed",
@@ -1878,7 +1878,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-graph"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "bincode",
  "chrono",
@@ -1900,7 +1900,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-graph-proxy"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "dirs",
  "neuromesh-core",
@@ -1914,7 +1914,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-index"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "blake3",
  "chrono",
@@ -1931,7 +1931,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-local-ai"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "neuromesh-core",
  "parking_lot",
@@ -1942,7 +1942,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-mcp"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "neuromesh-cache",
@@ -1967,7 +1967,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-memory"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "dirs",
@@ -1981,7 +1981,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-observability"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "chrono",
  "dirs",
@@ -1996,7 +1996,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-parser"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "neuromesh-core",
  "neuromesh-index",
@@ -2027,7 +2027,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-provider"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "futures-util",
  "neuromesh-core",
@@ -2040,7 +2040,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-router"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "neuromesh-context",
  "neuromesh-core",
@@ -2053,7 +2053,7 @@ dependencies = [
 
 [[package]]
 name = "neuromesh-task"
-version = "1.3.0"
+version = "1.4.0"
 dependencies = [
  "neuromesh-core",
  "neuromesh-parser",
diff --git a/Cargo.toml b/Cargo.toml
index a454700..64c39b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,7 @@ members = [
 exclude = ["tests/fixtures/mini-axum"]
 
 [workspace.package]
-version = "1.3.0"
+version = "1.4.0"
 edition = "2021"
 rust-version = "1.80"
 authors = ["NeuroMesh Team <team@neuromesh.local>"]
diff --git a/crates/neuromesh-cli/src/commands/packet.rs b/crates/neuromesh-cli/src/commands/packet.rs
index f7698e5..6115740 100644
--- a/crates/neuromesh-cli/src/commands/packet.rs
+++ b/crates/neuromesh-cli/src/commands/packet.rs
@@ -48,6 +48,10 @@ struct PacketJsonOut {
     /// lines), 20 deep — function-level localisation.
     #[serde(skip_serializing_if = "Vec::is_empty")]
     definitions: Vec<neuromesh_graph::RankedDefinition>,
+    /// Research runs (`NM_DIAG=1`): the same list under other settings.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    diag_definitions:
+        Option<std::collections::BTreeMap<String, Vec<neuromesh_graph::RankedDefinition>>>,
     /// The whole-question file ranking (BM25F), top 10, for evaluation.
     ranked_paths: Vec<String>,
     identifiers: Vec<String>,
@@ -104,12 +108,11 @@ pub fn execute(args: &[String]) -> Result<()> {
 
     let selected_paths = neuromesh_context::gold::packet_file_order(&graph, &prompt, &view);
     let localization = neuromesh_context::gold::localization_order(&graph, &prompt, &view, 20);
+    // Every prompt gets the function list: a short issue still has a function
+    // to change (30 of LocAgent's 274 Lite instances are under 60 words and
+    // scored as misses without one).
     let definitions =
-        if prompt.split_whitespace().count() >= neuromesh_parser::text_normalize::REPORT_WORDS {
-            neuromesh_context::gold::definition_order(&graph, &prompt, &localization, def_depth())
-        } else {
-            Vec::new()
-        };
+        neuromesh_context::gold::definition_order(&graph, &prompt, &localization, def_depth());
     let mut files: Vec<String> = packet_file_names(&view).into_iter().collect();
     files.sort();
     let reduction = if workspace_tokens > 0 {
@@ -139,6 +142,7 @@ pub fn execute(args: &[String]) -> Result<()> {
         selected_files_count: files.len(),
         selected_files: files.clone(),
         selected_paths,
+        diag_definitions: diag_definitions(&graph, &prompt, &localization),
         localization,
         definitions,
         ranked_paths: graph
@@ -417,6 +421,79 @@ fn def_depth() -> usize {
         .unwrap_or(20)
 }
 
+/// Definition lists under research settings, only when `NM_DIAG=1` (one run
+/// measures several variants on the same checkouts).
+fn diag_definitions(
+    graph: &neuromesh_graph::NeuralProjectGraph,
+    prompt: &str,
+    localization: &[String],
+) -> Option<std::collections::BTreeMap<String, Vec<neuromesh_graph::RankedDefinition>>> {
+    if std::env::var("NM_DIAG").ok().as_deref() != Some("1") {
+        return None;
+    }
+    use neuromesh_context::gold::{definition_order_with, DefinitionOpts};
+    use neuromesh_graph::ChunkOpts;
+    let base = DefinitionOpts::default();
+    let variants = [
+        (
+            "raw",
+            DefinitionOpts {
+                file_prior: false,
+                traceback: false,
+                ..base
+            },
+        ),
+        (
+            "no_trace",
+            DefinitionOpts {
+                traceback: false,
+                ..base
+            },
+        ),
+        (
+            "no_stem",
+            DefinitionOpts {
+                chunk: ChunkOpts {
+                    no_stem: true,
+                    owner_terms: false,
+                },
+                ..base
+            },
+        ),
+        (
+            "owner",
+            DefinitionOpts {
+                chunk: ChunkOpts {
+                    no_stem: false,
+                    owner_terms: true,
+                },
+                ..base
+            },
+        ),
+        (
+            "no_stem_owner",
+            DefinitionOpts {
+                chunk: ChunkOpts {
+                    no_stem: true,
+                    owner_terms: true,
+                },
+                ..base
+            },
+        ),
+    ];
+    Some(
+        variants
+            .into_iter()
+            .map(|(name, opts)| {
+                (
+                    name.to_string(),
+                    definition_order_with(graph, prompt, localization, def_depth(), opts),
+                )
+            })
+            .collect(),
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/neuromesh-context/src/gold.rs b/crates/neuromesh-context/src/gold.rs
index a584ca5..b0c3aee 100644
--- a/crates/neuromesh-context/src/gold.rs
+++ b/crates/neuromesh-context/src/gold.rs
@@ -1145,6 +1145,35 @@ pub fn definition_order(
     prompt: &str,
     files: &[String],
     k: usize,
+) -> Vec<neuromesh_graph::RankedDefinition> {
+    definition_order_with(graph, prompt, files, k, DefinitionOpts::default())
+}
+
+/// Switches for research runs (`NM_DIAG`); the default is what ships.
+#[derive(Debug, Clone, Copy)]
+pub struct DefinitionOpts {
+    pub chunk: neuromesh_graph::ChunkOpts,
+    pub file_prior: bool,
+    pub traceback: bool,
+}
+
+impl Default for DefinitionOpts {
+    fn default() -> Self {
+        Self {
+            chunk: neuromesh_graph::ChunkOpts::default(),
+            file_prior: true,
+            traceback: true,
+        }
+    }
+}
+
+/// [`definition_order`] with research switches.
+pub fn definition_order_with(
+    graph: &neuromesh_graph::NeuralProjectGraph,
+    prompt: &str,
+    files: &[String],
+    k: usize,
+    opts: DefinitionOpts,
 ) -> Vec<neuromesh_graph::RankedDefinition> {
     const K: f32 = 60.0;
     let file_rank: std::collections::HashMap<&str, usize> = files
@@ -1152,8 +1181,13 @@ pub fn definition_order(
         .enumerate()
         .map(|(i, f)| (f.as_str(), i))
         .collect();
+    let file_rank = if opts.file_prior {
+        file_rank
+    } else {
+        std::collections::HashMap::new()
+    };
     let mut scored: Vec<(f32, usize, neuromesh_graph::RankedDefinition)> = graph
-        .rank_definitions(prompt, 300)
+        .rank_definitions_with(prompt, 300, opts.chunk)
         .into_iter()
         .filter(|d| !crate::selector::is_noise_path(std::path::Path::new(&d.path)))
         .enumerate()
@@ -1165,38 +1199,167 @@ pub fn definition_order(
             (s, i, d)
         })
         .collect();
+    // The functions a traceback runs through vote at double weight, deepest
+    // frame first, and enter the list even when the ranking missed them.
+    // SWE-bench dev, func Acc@5: dev-fast 0.212 → 0.250, dev-rest 0.253 →
+    // 0.278 (prototype `scripts/research/priors.py --prior traceback`).
+    const TRACE_WEIGHT: f32 = 2.0;
+    let frames = if opts.traceback {
+        traceback_definitions(graph, prompt)
+    } else {
+        Vec::new()
+    };
+    for (i, d) in frames.into_iter().enumerate() {
+        let vote = TRACE_WEIGHT / (K + i as f32 + 1.0);
+        match scored
+            .iter_mut()
+            .find(|(_, _, s)| s.path == d.path && s.name == d.name)
+        {
+            Some(hit) => hit.0 += vote,
+            None => {
+                let mut s = vote;
+                if let Some(r) = file_rank.get(d.path.as_str()) {
+                    s += 1.0 / (K + *r as f32 + 1.0);
+                }
+                let at = scored.len();
+                scored.push((s, at, d));
+            }
+        }
+    }
     scored.sort_by(|a, b| b.0.total_cmp(&a.0).then_with(|| a.1.cmp(&b.1)));
     scored.into_iter().take(k).map(|(_, _, d)| d).collect()
 }
 
-/// Indexed files a report names, best pointer first: traceback frames
-/// (`File "…/pkg/mod.py", line 12`) from the deepest up, then any other path
-/// or file name in order of mention. A path resolves by its longest suffix
-/// that names exactly one indexed file (site-packages prefixes fall away); a
-/// bare file name only when one non-test file has it.
-fn named_files(graph: &neuromesh_graph::NeuralProjectGraph, prompt: &str) -> Vec<String> {
+/// The definitions a report's traceback runs through, deepest frame first.
+/// A frame (`File "…/pkg/mod.py", line 12, in name`, or pytest's
+/// `pkg/mod.py:12: in name`) resolves to an indexed file as in
+/// [`named_files`], then to the definition called `name` there (the one
+/// containing the line when several share the name) or, for `<module>` and
+/// names the index lacks, the innermost definition containing the line.
+/// Frames in tests are skipped: the test that reproduces a bug is not where
+/// it is fixed. Line numbers come from the reporter's version, so the name
+/// decides first.
+pub fn traceback_definitions(
+    graph: &neuromesh_graph::NeuralProjectGraph,
+    prompt: &str,
+) -> Vec<neuromesh_graph::RankedDefinition> {
     use std::sync::OnceLock;
     static FRAME: OnceLock<regex::Regex> = OnceLock::new();
-    static PATH: OnceLock<regex::Regex> = OnceLock::new();
-    let frame = FRAME.get_or_init(|| regex::Regex::new(r#"File "([^"\n]+)", line \d+"#).unwrap());
-    let path =
-        PATH.get_or_init(|| regex::Regex::new(r"[\w./\\-]+\.[A-Za-z][A-Za-z0-9]{0,5}\b").unwrap());
-    let files: Vec<String> = graph
-        .file_node_paths()
-        .into_iter()
-        .map(|(_, p)| p.to_string_lossy().replace('\\', "/"))
-        .collect();
-    let mut by_name: std::collections::HashMap<&str, Vec<&String>> =
-        std::collections::HashMap::new();
-    for f in &files {
-        if !neuromesh_core::source_path::is_test_path(std::path::Path::new(f)) {
-            by_name
-                .entry(f.rsplit('/').next().unwrap_or(f))
-                .or_default()
-                .push(f);
+    static PYTEST: OnceLock<regex::Regex> = OnceLock::new();
+    let frame = FRAME.get_or_init(|| {
+        regex::Regex::new(r#"File "([^"\n]+\.py)", line (\d+), in ([\w<>.]+)"#).unwrap()
+    });
+    let pytest = PYTEST.get_or_init(|| {
+        regex::Regex::new(r"(?m)^([\w./\\-]+\.py):(\d+):(?: in ([\w<>.]+))?").unwrap()
+    });
+    let mut frames: Vec<(String, usize, Option<String>)> = Vec::new();
+    for c in frame.captures_iter(prompt) {
+        let line = c[2].parse().unwrap_or(0);
+        frames.push((c[1].to_string(), line, Some(c[3].to_string())));
+    }
+    for c in pytest.captures_iter(prompt) {
+        let line = c[2].parse().unwrap_or(0);
+        frames.push((
+            c[1].to_string(),
+            line,
+            c.get(3).map(|m| m.as_str().to_string()),
+        ));
+    }
+    if frames.is_empty() {
+        return Vec::new();
+    }
+    let resolver = FileResolver::new(graph);
+    let mut out: Vec<neuromesh_graph::RankedDefinition> = Vec::new();
+    for (token, line, func) in frames.iter().rev() {
+        let Some(path) = resolver.resolve(token) else {
+            continue;
+        };
+        if neuromesh_core::source_path::is_test_path(std::path::Path::new(&path)) {
+            continue;
         }
+        // (qualified name, first line, last line) of every definition that
+        // is not a container (a class whose methods name it as parent).
+        let nodes = graph.nodes_in_file(std::path::Path::new(&path));
+        let parents: std::collections::HashSet<&str> =
+            nodes.iter().filter_map(|n| n.parent.as_deref()).collect();
+        let defs: Vec<(String, usize, usize)> = nodes
+            .iter()
+            .filter(|n| n.node_type != neuromesh_core::NodeType::File)
+            .filter_map(|n| {
+                let r = n.line_range.as_ref()?;
+                if r.end <= r.start {
+                    return None;
+                }
+                let name = match &n.parent {
+                    Some(p) if !p.is_empty() => format!("{p}.{}", n.name),
+                    _ => n.name.clone(),
+                };
+                (!parents.contains(name.as_str())).then_some((name, r.start, r.end))
+            })
+            .collect();
+        let wanted = func
+            .as_deref()
+            .filter(|f| *f != "<module>")
+            .map(|f| f.rsplit('.').next().unwrap_or(f));
+        let inside = |d: &&(String, usize, usize)| d.1 <= *line && *line <= d.2;
+        let named: Vec<&(String, usize, usize)> = defs
+            .iter()
+            .filter(|d| wanted.is_some_and(|w| d.0.rsplit('.').next() == Some(w)))
+            .collect();
+        let pick = if named.is_empty() {
+            defs.iter().filter(inside).min_by_key(|d| d.2 - d.1)
+        } else {
+            named
+                .iter()
+                .copied()
+                .filter(inside)
+                .min_by_key(|d| d.2 - d.1)
+                .or_else(|| named.iter().copied().min_by_key(|d| d.1.abs_diff(*line)))
+        };
+        if let Some((name, start, end)) = pick {
+            if !out.iter().any(|d| d.path == path && &d.name == name) {
+                out.push(neuromesh_graph::RankedDefinition {
+                    path: path.clone(),
+                    name: name.clone(),
+                    lines: (*start, *end),
+                    score: 0.0,
+                });
+            }
+        }
+    }
+    out
+}
+
+/// Resolves a path or file name written in a report to an indexed file: the
+/// longest suffix that names exactly one indexed file (site-packages and
+/// home-directory prefixes fall away), else a bare file name that exactly one
+/// non-test file has.
+struct FileResolver {
+    files: Vec<String>,
+    by_name: std::collections::HashMap<String, Vec<String>>,
+}
+
+impl FileResolver {
+    fn new(graph: &neuromesh_graph::NeuralProjectGraph) -> Self {
+        let files: Vec<String> = graph
+            .file_node_paths()
+            .into_iter()
+            .map(|(_, p)| p.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let mut by_name: std::collections::HashMap<String, Vec<String>> =
+            std::collections::HashMap::new();
+        for f in &files {
+            if !neuromesh_core::source_path::is_test_path(std::path::Path::new(f)) {
+                by_name
+                    .entry(f.rsplit('/').next().unwrap_or(f).to_string())
+                    .or_default()
+                    .push(f.clone());
+            }
+        }
+        Self { files, by_name }
     }
-    let resolve = |token: &str| -> Option<String> {
+
+    fn resolve(&self, token: &str) -> Option<String> {
         let t = token.replace('\\', "/");
         let t = t.trim_start_matches("./");
         let parts: Vec<&str> = t.split('/').filter(|s| !s.is_empty()).collect();
@@ -1205,9 +1368,11 @@ fn named_files(graph: &neuromesh_graph::NeuralProjectGraph, prompt: &str) -> Vec
         }
         for i in 0..parts.len() {
             let suffix = parts[i..].join("/");
-            let hits: Vec<&String> = files
+            let tail = format!("/{suffix}");
+            let hits: Vec<&String> = self
+                .files
                 .iter()
-                .filter(|f| **f == suffix || f.ends_with(&format!("/{suffix}")))
+                .filter(|f| **f == suffix || f.ends_with(&tail))
                 .collect();
             match hits.len() {
                 1 => return Some(hits[0].clone()),
@@ -1216,11 +1381,27 @@ fn named_files(graph: &neuromesh_graph::NeuralProjectGraph, prompt: &str) -> Vec
                 _ => return None,
             }
         }
-        match by_name.get(parts[parts.len() - 1]) {
+        match self.by_name.get(parts[parts.len() - 1]) {
             Some(c) if c.len() == 1 => Some(c[0].clone()),
             _ => None,
         }
-    };
+    }
+}
+
+/// Indexed files a report names, best pointer first: traceback frames
+/// (`File "…/pkg/mod.py", line 12`) from the deepest up, then any other path
+/// or file name in order of mention. A path resolves by its longest suffix
+/// that names exactly one indexed file (site-packages prefixes fall away); a
+/// bare file name only when one non-test file has it.
+fn named_files(graph: &neuromesh_graph::NeuralProjectGraph, prompt: &str) -> Vec<String> {
+    use std::sync::OnceLock;
+    static FRAME: OnceLock<regex::Regex> = OnceLock::new();
+    static PATH: OnceLock<regex::Regex> = OnceLock::new();
+    let frame = FRAME.get_or_init(|| regex::Regex::new(r#"File "([^"\n]+)", line \d+"#).unwrap());
+    let path =
+        PATH.get_or_init(|| regex::Regex::new(r"[\w./\\-]+\.[A-Za-z][A-Za-z0-9]{0,5}\b").unwrap());
+    let resolver = FileResolver::new(graph);
+    let resolve = |token: &str| resolver.resolve(token);
     let mut out: Vec<String> = Vec::new();
     let frames: Vec<&str> = frame
         .captures_iter(prompt)
@@ -1304,6 +1485,46 @@ mod tests {
         }
     }
 
+    #[test]
+    fn traceback_frames_name_the_functions_deepest_first() {
+        use neuromesh_index::{IndexedFile, SourceLanguage};
+        use neuromesh_parser::CodeIntelligenceEngine;
+        use std::path::PathBuf;
+        let graph = NeuralProjectGraph::new(ProjectId::new("tb"));
+        let core = "def helper(x):\n    return x + 1\n\n\nclass Frame:\n    def render(self, x):\n        y = helper(x)\n        return y\n\n    def close(self):\n        pass\n";
+        let test = "from pkg.core import Frame\n\ndef test_render():\n    Frame().render(1)\n";
+        for (rel, src) in [("pkg/core.py", core), ("tests/test_core.py", test)] {
+            let file = IndexedFile {
+                project_id: ProjectId::new("tb"),
+                relative_path: PathBuf::from(rel),
+                full_path: PathBuf::from(rel),
+                blake3_hash: rel.into(),
+                byte_size: src.len() as u64,
+                token_count: 40,
+                language: SourceLanguage::Python,
+                last_modified: chrono::Utc::now(),
+            };
+            graph.ingest_file(
+                &file,
+                &CodeIntelligenceEngine::analyze(&PathBuf::from(rel), src, SourceLanguage::Python),
+                Some(src),
+            );
+        }
+        graph.finalize_links();
+        let report = "Rendering fails:\n\nTraceback (most recent call last):\n  File \"tests/test_core.py\", line 4, in test_render\n    Frame().render(1)\n  File \"/usr/lib/python3/site-packages/pkg/core.py\", line 7, in render\n    y = helper(x)\n  File \"/usr/lib/python3/site-packages/pkg/core.py\", line 2, in helper\n    return x + 1\nTypeError: boom\n";
+        let got: Vec<(String, String)> = traceback_definitions(&graph, report)
+            .into_iter()
+            .map(|d| (d.path, d.name))
+            .collect();
+        assert_eq!(
+            got,
+            vec![
+                ("pkg/core.py".to_string(), "helper".to_string()),
+                ("pkg/core.py".to_string(), "Frame.render".to_string()),
+            ]
+        );
+    }
+
     #[test]
     fn parses_forbidden_files_from_toml() {
         let tasks = parse_gold_toml(
diff --git a/crates/neuromesh-graph/src/chunk_rank.rs b/crates/neuromesh-graph/src/chunk_rank.rs
index 08c20f6..6a9581e 100644
--- a/crates/neuromesh-graph/src/chunk_rank.rs
+++ b/crates/neuromesh-graph/src/chunk_rank.rs
@@ -15,7 +15,7 @@
 //! Built lazily from the sources on disk on the first long report, cached
 //! with the file ranker's key.
 
-use crate::file_rank::{stemmer, terms_of, RankedFile};
+use crate::file_rank::{stemmer, terms_of_opt, RankedFile};
 use neuromesh_core::NodeId;
 use rayon::prelude::*;
 use std::collections::HashMap;
@@ -41,6 +41,16 @@ pub(crate) struct ChunkSource {
     pub containers: Vec<bool>,
 }
 
+/// How chunks and queries are turned into terms. The default is what ships;
+/// the other settings exist for research runs (`NM_DIAG`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct ChunkOpts {
+    /// Exact words instead of Snowball stems.
+    pub no_stem: bool,
+    /// A method's chunk also carries its class name's words.
+    pub owner_terms: bool,
+}
+
 /// One definition ranked for a report: where it is and how well it matched.
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct RankedDefinition {
@@ -65,21 +75,27 @@ pub(crate) struct ChunkRankIndex {
     post: HashMap<String, Vec<(u32, u16)>>,
     /// Per chunk: definition name (`<head>` for the file head) and lines.
     label: Vec<Label>,
+    opts: ChunkOpts,
 }
 
 impl ChunkRankIndex {
     pub(crate) fn build(sources: Vec<ChunkSource>) -> Self {
+        Self::build_with(sources, ChunkOpts::default())
+    }
+
+    pub(crate) fn build_with(sources: Vec<ChunkSource>, opts: ChunkOpts) -> Self {
         // Per file: its chunks' term counts, computed in parallel.
         let per_file: Vec<FileChunks> = sources
             .into_par_iter()
             .map(|f| {
-                let st = stemmer();
+                let stem = stemmer();
+                let st = (!opts.no_stem).then_some(&stem);
                 let rel = f.path.to_string_lossy().replace('\\', "/");
                 let stem_path = match rel.rsplit_once('.') {
                     Some((head, ext)) if !ext.contains('/') => head.to_string(),
                     _ => rel.clone(),
                 };
-                let path_terms = terms_of(&stem_path, &st, true);
+                let path_terms = terms_of_opt(&stem_path, st, true);
                 let lines: Vec<&str> = f.source.lines().collect();
                 let head = (1..HEAD_LINES.min(lines.len()), ("<head>".to_string(), true));
                 let mut chunks = Vec::new();
@@ -96,9 +112,17 @@ impl ChunkRankIndex {
                         continue;
                     }
                     let mut counts: HashMap<String, u16> = HashMap::new();
-                    for t in terms_of(&lines[start..end].join("\n"), &st, false)
+                    let owner = if opts.owner_terms {
+                        name.rsplit_once('.')
+                            .map(|(o, _)| terms_of_opt(o, st, false))
+                            .unwrap_or_default()
+                    } else {
+                        Vec::new()
+                    };
+                    for t in terms_of_opt(&lines[start..end].join("\n"), st, false)
                         .into_iter()
                         .chain(path_terms.iter().cloned())
+                        .chain(owner)
                     {
                         let c = counts.entry(t).or_insert(0);
                         *c = c.saturating_add(1);
@@ -110,7 +134,10 @@ impl ChunkRankIndex {
                 (f.id, f.path, chunks)
             })
             .collect();
-        let mut idx = ChunkRankIndex::default();
+        let mut idx = ChunkRankIndex {
+            opts,
+            ..ChunkRankIndex::default()
+        };
         for (id, path, chunks) in per_file {
             let file = idx.files.len() as u32;
             idx.files.push((id, path));
@@ -197,7 +224,8 @@ impl ChunkRankIndex {
         if n == 0.0 {
             return score;
         }
-        let st = stemmer();
+        let stem = stemmer();
+        let st = (!self.opts.no_stem).then_some(&stem);
         let body = neuromesh_parser::strip_issue_boilerplate(prompt);
         let title = body
             .lines()
@@ -205,15 +233,23 @@ impl ChunkRankIndex {
             .find(|l| !l.is_empty())
             .unwrap_or("");
         let mut q: HashMap<String, f32> = HashMap::new();
-        for t in terms_of(&body, &st, false) {
+        for t in terms_of_opt(&body, st, false) {
             q.insert(t, 1.0);
         }
-        for t in terms_of(title, &st, false) {
+        for t in terms_of_opt(title, st, false) {
             *q.entry(t).or_insert(0.0) += TITLE_EXTRA;
         }
+        // A cap bounds the work on a pasted log; it keeps the title's terms and
+        // then the rarest ones. (It used to keep the alphabetically first 256,
+        // so a long report lost every term after about "p".)
         let mut terms: Vec<(String, f32)> = q.into_iter().collect();
-        terms.sort_by(|a, b| a.0.cmp(&b.0));
-        terms.truncate(256);
+        terms.sort_by(|a, b| {
+            let df = |t: &str| self.post.get(t).map_or(usize::MAX, Vec::len);
+            b.1.total_cmp(&a.1)
+                .then_with(|| df(&a.0).cmp(&df(&b.0)))
+                .then_with(|| a.0.cmp(&b.0))
+        });
+        terms.truncate(1024);
         for (t, w) in &terms {
             let Some(list) = self.post.get(t) else {
                 continue;
diff --git a/crates/neuromesh-graph/src/file_rank.rs b/crates/neuromesh-graph/src/file_rank.rs
index b19b2b0..e70caaa 100644
--- a/crates/neuromesh-graph/src/file_rank.rs
+++ b/crates/neuromesh-graph/src/file_rank.rs
@@ -221,6 +221,11 @@ pub(crate) fn stemmer() -> Stemmer {
 /// Lowercase, split identifiers into words, drop short/non-alphabetic
 /// pieces and stopwords, stem.
 pub(crate) fn terms_of(text: &str, st: &Stemmer, keep_stopwords: bool) -> Vec<String> {
+    terms_of_opt(text, Some(st), keep_stopwords)
+}
+
+/// [`terms_of`], stemming only when a stemmer is given.
+pub(crate) fn terms_of_opt(text: &str, st: Option<&Stemmer>, keep_stopwords: bool) -> Vec<String> {
     let mut out = Vec::new();
     for raw in text.split(|c: char| !c.is_ascii_alphanumeric() && c != '_') {
         if raw.is_empty() {
@@ -237,7 +242,10 @@ pub(crate) fn terms_of(text: &str, st: &Stemmer, keep_stopwords: bool) -> Vec<St
             if !keep_stopwords && STOPWORDS.contains(&w.as_str()) {
                 continue;
             }
-            out.push(st.stem(&w).into_owned());
+            out.push(match st {
+                Some(st) => st.stem(&w).into_owned(),
+                None => w,
+            });
         }
     }
     out
diff --git a/crates/neuromesh-graph/src/graph.rs b/crates/neuromesh-graph/src/graph.rs
index bb7b0c8..ef3ae04 100644
--- a/crates/neuromesh-graph/src/graph.rs
+++ b/crates/neuromesh-graph/src/graph.rs
@@ -791,16 +791,49 @@ impl NeuralProjectGraph {
             .rank_definitions(&prompt[..end], limit)
     }
 
+    /// [`Self::rank_definitions`] over an index built with other term
+    /// settings (research runs only: built per call, not cached).
+    pub fn rank_definitions_with(
+        &self,
+        prompt: &str,
+        limit: usize,
+        opts: crate::chunk_rank::ChunkOpts,
+    ) -> Vec<crate::chunk_rank::RankedDefinition> {
+        if opts == crate::chunk_rank::ChunkOpts::default() {
+            return self.rank_definitions(prompt, limit);
+        }
+        let mut end = prompt.len().min(32 * 1024);
+        while !prompt.is_char_boundary(end) {
+            end -= 1;
+        }
+        crate::chunk_rank::ChunkRankIndex::build_with(self.chunk_sources(), opts)
+            .rank_definitions(&prompt[..end], limit)
+    }
+
     fn chunk_rank_index(&self) -> Arc<crate::chunk_rank::ChunkRankIndex> {
-        let (key, files) = {
+        let key = {
             let data = self.inner.read();
-            let key = (data.generation, data.file_to_nodes.len() as u64);
-            {
-                let cached = self.derived.read();
-                if cached.chunk_rank_key == Some(key) {
-                    return Arc::clone(&cached.chunk_rank);
-                }
+            (data.generation, data.file_to_nodes.len() as u64)
+        };
+        {
+            let cached = self.derived.read();
+            if cached.chunk_rank_key == Some(key) {
+                return Arc::clone(&cached.chunk_rank);
             }
+        }
+        let sources = self.chunk_sources();
+        let t0 = std::time::Instant::now();
+        let index = Arc::new(crate::chunk_rank::ChunkRankIndex::build(sources));
+        crate::timing("chunk_rank build", t0);
+        let mut cached = self.derived.write();
+        cached.chunk_rank_key = Some(key);
+        cached.chunk_rank = Arc::clone(&index);
+        index
+    }
+
+    fn chunk_sources(&self) -> Vec<crate::chunk_rank::ChunkSource> {
+        let files = {
+            let data = self.inner.read();
             let mut files = Vec::new();
             for (path, ids) in &data.file_to_nodes {
                 if neuromesh_core::is_low_priority_source_path(path) {
@@ -839,10 +872,9 @@ impl NeuralProjectGraph {
                     files.push((id, path.clone(), spans, names, containers));
                 }
             }
-            (key, files)
+            files
         };
-        let t0 = std::time::Instant::now();
-        let sources: Vec<crate::chunk_rank::ChunkSource> = files
+        files
             .into_par_iter()
             .filter_map(|(id, path, spans, names, containers)| {
                 let source = self.read_source(&path)?;
@@ -855,13 +887,7 @@ impl NeuralProjectGraph {
                     containers,
                 })
             })
-            .collect();
-        let index = Arc::new(crate::chunk_rank::ChunkRankIndex::build(sources));
-        crate::timing("chunk_rank build", t0);
-        let mut cached = self.derived.write();
-        cached.chunk_rank_key = Some(key);
-        cached.chunk_rank = Arc::clone(&index);
-        index
+            .collect()
     }
 
     fn file_rank_index(&self) -> Arc<crate::file_rank::FileRankIndex> {
diff --git a/crates/neuromesh-graph/src/lib.rs b/crates/neuromesh-graph/src/lib.rs
index 2f57dc7..7ecbc83 100644
--- a/crates/neuromesh-graph/src/lib.rs
+++ b/crates/neuromesh-graph/src/lib.rs
@@ -1,6 +1,6 @@
 pub mod activation;
 mod chunk_rank;
-pub use chunk_rank::RankedDefinition;
+pub use chunk_rank::{ChunkOpts, RankedDefinition};
 pub mod concept_index;
 pub mod edge;
 pub mod embeddings;
diff --git a/crates/neuromesh-mcp/src/protocol.rs b/crates/neuromesh-mcp/src/protocol.rs
index 19e1d66..fee0b86 100644
--- a/crates/neuromesh-mcp/src/protocol.rs
+++ b/crates/neuromesh-mcp/src/protocol.rs
@@ -114,7 +114,7 @@ pub fn canonical_tool_name(name: &str) -> String {
 }
 
 pub fn initialize_instructions() -> &'static str {
-    "NeuroMesh MCP v1.3.0 (code-context-engine) — agent loop: (1) get_context_packet with the user task as written (default engine: fast — graph + query-side lexical expansion; prompt only; no client keywords; opt in to hybrid/deep for MiniLM embed-primary); for a pasted issue or bug report the response also lists where_to_look (files to open next, best first) and functions_to_look (path:Class.method with line range); (2) if coverage is partial/no_seed_resolved/no_confident_match, neuromesh_search_symbols or neuromesh_expand_gap; (3) neuromesh_expand_fold only when you need a folded body; (4) neuromesh_trace / neuromesh_get_dependencies for callers and blast radius; (5) after a successful edit, neuromesh_record_feedback with touched nodes. Check retrieval.resolution_tier and retrieval.cache_hit. Prefer these tools over reading whole files. neuromesh_get_context is deprecated — use get_context_packet."
+    "NeuroMesh MCP v1.4.0 (code-context-engine) — agent loop: (1) get_context_packet with the user task as written (default engine: fast — graph + query-side lexical expansion; prompt only; no client keywords; opt in to hybrid/deep for MiniLM embed-primary); for a pasted issue or bug report the response also lists where_to_look (files to open next, best first) and functions_to_look (path:Class.method with line range); (2) if coverage is partial/no_seed_resolved/no_confident_match, neuromesh_search_symbols or neuromesh_expand_gap; (3) neuromesh_expand_fold only when you need a folded body; (4) neuromesh_trace / neuromesh_get_dependencies for callers and blast radius; (5) after a successful edit, neuromesh_record_feedback with touched nodes. Check retrieval.resolution_tier and retrieval.cache_hit. Prefer these tools over reading whole files. neuromesh_get_context is deprecated — use get_context_packet."
 }
 
 pub fn tool_success(id: Option<Value>, val: &Value) -> Value {
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 2643c2c..4debc4a 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -2,6 +2,30 @@
 
 All notable user-facing changes live here. The README stays a product guide, not a version diary.
 
+## 1.4.0 — 2026-10-10
+
+### Bug reports and issues
+
+- **Functions a traceback runs through** vote in `functions_to_look` / `definitions`: each frame
+  (`File "…", line N, in name`, or pytest's `path.py:N: in name`) resolves to the indexed file and
+  then to the function it names (or the innermost one containing the line); test frames are
+  skipped. SWE-bench dev, function level Acc@1/5/10: 0.158/0.292/0.364 → 0.190/0.324/0.390; both
+  halves of dev agree (+0.03–0.04 at Acc@1 and Acc@5).
+- `packet --json` lists `definitions` for every prompt, not only reports of 60+ words (a short
+  issue still has a function to change).
+- The definition ranker no longer drops query terms after the alphabetically first 256 on long
+  reports; it keeps the title's terms, then the rarest.
+
+### Measured
+
+- v1.3.0 run once on SWE-bench Lite (276 strict holdout: Acc@1/3/5 0.507/0.717/0.750) and Verified
+  (500: 0.446/0.680/0.736); function level on LocAgent's 274: Acc@5/@10 0.394/0.482.
+- Fresh plain-language holdout (jsoup, Java, gold locked before the run): list R@3 0.750 vs BM25
+  0.667 (0.417 before the 1.3.0 list fusion).
+- Rejected with numbers (see `docs/research/contributions-log.md` §8.14–8.16): commit-history
+  prior, repro-code identifiers, test→module links, RM3 expansion, doc→code bridge, owner/unstemmed
+  definition variants.
+
 ## 1.3.0 — 2026-10-09
 
 ### Bug reports and issues
diff --git a/docs/measured.md b/docs/measured.md
index 6aa3274..cfc0994 100644
--- a/docs/measured.md
+++ b/docs/measured.md
@@ -25,9 +25,12 @@ not the project's number.** Only the holdout rows are.
 | **holdout-cfg** | lightning-hydra-template (Hydra YAML), detr (argparse) | D-4 gold; F55 (session 12) + F71/F72 (session 13) tuned on it — dev-class for config questions | **1.000** | **0.767** | **0** | — |
 | holdout-web (30 q) | fastify/demo (Fastify API), shadcn-ui/taxonomy (Next.js app router) | dev-class for the web domain (fixed on since session 13; 10 blind questions added in G4 scored 0.58 before fixes) | **0.917** | **0.643** | **0** | — |
 | **private** | one closed-source B2B backend+frontend (Fastify/Drizzle + Next.js, ~1.2k files) | never tuned on; gold and checkout live outside this repo | **1.000** | **0.587** | **0** | — |
-| concept (14 q) | this repository, plain-language questions (no identifier in the prompt) | dev-class (written 2026-09-30 from the upstream author's report, tuned on in session 16) | 0.679 | 0.392 | 0 | — || **concept-holdout** (12 q) | ripgrep 14.1.1 (Rust), plain-language questions | never tuned on; gold locked before any run; 1.0.0 scored recall **0.042** | **0.500** | **0.152** | **0** | — |
+| concept (14 q) | this repository, plain-language questions (no identifier in the prompt) | dev-class (written 2026-09-30 from the upstream author's report, tuned on in session 16) | 0.679 | 0.392 | 0 | — |
 | **concept-holdout** (12 q) | ripgrep 14.1.1 (Rust), plain-language questions | never tuned on; gold locked before any run; 1.0.0 scored recall **0.042** | **0.500** | **0.156** | **0** | — |
 | **concept-holdout2** (12 q) | click 8.1.7 (Python, 16 source files), plain-language questions | never tuned on; gold locked before the single run (2026-10-01) | **0.958** | **0.342** | **0** | — |
+| concept-holdout3 (12 q) | cobra v1.8.1 (Go), plain-language questions | gold locked before its single run (2026-10-09); looked at since | 0.833 | 0.357 | 0 | — |
+| concept-holdout4 (12 q) | axios v1.7.7 (JavaScript), plain-language questions | gold locked before its single run (2026-10-09); looked at since | 0.667 | 0.528 | 0 | — |
+| **concept-holdout5** (12 q) | jsoup 1.18.1 (Java), plain-language questions | gold locked before its single run (2026-10-10); list R@3 0.750 vs BM25 0.667 (pre-S1 v1.2.0: 0.417) | **0.667** | **0.235** | **0** | — |
 
 - **recall / precision** are file-level against a hand-written gold (`gold_files`) per question.
   A forbidden file in the packet zeroes that question's precision.
@@ -97,10 +100,10 @@ instance. 95% bootstrap intervals in brackets.
 | Lite strict holdout | 276 | **0.507** [0.45,0.57] | **0.717** [0.66,0.77] | **0.750** [0.70,0.80] | **0.815** | 0.301 / 0.507 / 0.587 / 0.721 |
 | Lite, LocAgent's subset | 274 | **0.500** [0.44,0.56] | **0.723** [0.67,0.77] | **0.755** [0.70,0.81] | **0.828** | 0.299 / 0.522 / 0.606 / 0.734 |
 | Verified, all | 500 | **0.446** [0.40,0.49] | **0.680** [0.64,0.72] | **0.736** [0.69,0.77] | **0.814** | 0.216 / 0.392 / 0.490 / 0.642 |
-| Verified, not in Lite | 403 | **0.437** [0.39,0.48] | **0.670** [0.63,0.72] | **0.732** [0.69,0.77] | **0.811** | 0.194 / 0.372 / 0.476 / 0.620 |
+| Verified, not in Lite | 407 | **0.435** [0.38,0.48] | **0.671** [0.62,0.71] | **0.732** [0.69,0.78] | **0.811** | 0.194 / 0.373 / 0.477 / 0.622 |
 
-v1.2.0 → v1.3.0 on the same instances: Lite 276 Acc@1 0.486 → 0.507; Verified-not-Lite 0.392 →
-0.437; Acc@5 unchanged within ±0.005. p50 2.9 s / p90 10.6 s per Lite issue (cold index included).
+v1.2.0 → v1.3.0 on the same instances: Lite 276 Acc@1 0.486 → 0.507; Verified-not-Lite (the 403
+v1.2.0 scored) 0.392 → 0.437; Acc@5 unchanged within ±0.005. p50 2.9 s / p90 10.6 s per Lite issue (cold index included).
 
 | function level (all edited functions in top k) | n | Acc@1 | Acc@5 | Acc@10 |
 |---|---|---|---|---|
diff --git a/docs/research/contributions-log.md b/docs/research/contributions-log.md
index 68a5a65..fd59cf3 100644
--- a/docs/research/contributions-log.md
+++ b/docs/research/contributions-log.md
@@ -406,9 +406,10 @@ Release binary v1.3.0 (tag `6e94b91`), one run per benchmark (`swebench/lite-v13
 | Lite strict holdout | 276 | **0.507** [0.45,0.57] | **0.717** [0.66,0.77] | 0.750 [0.70,0.80] | 0.815 | 0.301/0.507/0.587/0.721 |
 | LocAgent subset | 274 | **0.500** [0.44,0.56] | **0.723** [0.67,0.77] | 0.755 [0.70,0.81] | 0.828 | 0.299/0.522/0.606/0.734 |
 | Verified, all | 500 | **0.446** [0.40,0.49] | 0.680 [0.64,0.72] | 0.736 [0.69,0.77] | 0.814 | 0.216/0.392/0.490/0.642 |
-| Verified not in Lite | 403 | **0.437** [0.39,0.48] | 0.670 [0.63,0.72] | 0.732 [0.69,0.77] | 0.811 | 0.194/0.372/0.476/0.620 |
+| Verified not in Lite | 407 | **0.435** [0.38,0.48] | 0.671 [0.62,0.71] | 0.732 [0.69,0.78] | 0.811 | 0.194/0.373/0.477/0.622 |
 
-v1.2.0 → v1.3.0, same instances: Lite-276 Acc@1 0.486 → 0.507, Verified-not-Lite 0.392 → 0.437
+v1.2.0 → v1.3.0, same instances: Lite-276 Acc@1 0.486 → 0.507, Verified-not-Lite (the 403 v1.2.0 scored;
+the subset has 407) 0.392 → 0.437
 (+0.045; the named-files vote, C13, dev gain was +0.049 — it transferred); Acc@5 within ±0.005.
 Latency p50 2.9 s / p90 10.6 s (Lite), 2.5 s / 8.8 s (Verified), cold index included.
 
@@ -438,3 +439,125 @@ function-gold extraction. Engine follow-up: emit the function list for short rep
 DeepSeek-V4-Flash, DeepSeek-V4-Pro) authenticate (`/v1/models` 200) but every chat call returns
 HTTP 402 "please check your current payment status" — the accounts have no credit. The strong-LLM
 stage stays unmeasured until one is funded.
+
+### 8.14 Phase 1: LLM-free priors from the bug-localisation literature (session 18, dev only)
+
+Protocol: each prior first as an offline Python prototype over stored engine lists
+(`scripts/research/priors.py`: RRF vote into `loc_files` / `definitions`, weights swept), scored
+on both halves of SWE-bench dev (dev-fast 59 / dev-rest 166); kept only if file Acc@1 or func
+Acc@5 rises ≥ 0.02 in both halves. Function metric with the corrected denominator (§8.13): 210
+dev issues have function gold. Baseline = v1.3.0 engine (`dev-func2-all.jsonl`): file
+0.308/0.527/0.621/0.692, func Acc@1/5/10 0.158/0.292/0.364.
+
+**Bookkeeping slip, caught:** the first prototype round used `dev-func300-all.jsonl` as its base
+— a deeper run made *before* #140 removed classes from the function list (func 0.124/0.243/0.305).
+Every function-level delta below is re-measured against the true v1.3.0 run.
+
+| prior (inspiration) | fires on | file Acc@1 fast / rest | func Acc@5 fast / rest | verdict |
+|---|---|---|---|---|
+| traceback frame → enclosing function (agents open the deepest frame) | 43 | = / = (w=1) | 0.269→0.288 / 0.299→0.312 (proto) | **kept; engine port below** |
+| non-code "definitions" (YAML keys) out of the function list | 203 | = | = (10 of 2,030 top-10 slots) | no effect |
+| identifiers in the issue's code blocks → their definitions (repro code) | 115 | 0.271→0.254..0.271 / 0.319→0.271..0.313 | +0.019 / +0.019 (base pre-#140) | rejected: file level drops, func gain < 0.02 |
+| commit history (BugLocator / Locus): past commits whose message is like the issue → their files; ancestors of base only | 224 | 0.271→0.169 / 0.319→0.289 even at w=0.1 | = | **rejected** |
+| test named in the issue → modules it imports | 0 | – | – | no effect: dev reports name no repository tests (5 name a `test_` word, all the reporter's own) |
+| RM3 pseudo-relevance feedback on definition BM25 (5 docs, 20 terms, λ=0.6) | 225 | +0.017 / +0.018 (w=0.5); @5 −0.018 / −0.018 | 0.269→0.346 / 0.299→0.306 | rejected: alone worse than plain definition BM25 at @1 (0.038 vs 0.135 fast); as a vote no better than the plain one |
+| plain Python definition BM25 (unstemmed, method text prefixed with its class) as a second vote | 225 | +0.017 / +0.024 (w=1); @5 −0.017 / −0.036 | 0.269→0.327 / 0.299→0.312 (w=1) | not shipped: standalone it is level with the engine at @1 and below at @5/@10 (fast 0.135/0.250/0.327 vs 0.135/0.269/0.346; rest 0.171/0.272/0.329 vs 0.165/0.297/0.367) — the gain is diversity; the engine-side variants below do not reproduce it |
+
+History details: `git log --no-renames` is required on blobless clones — rename detection fetches
+blobs one by one (it returned 214 of 1,878 pvlib commits in 53 s before the fix).
+
+**Engine port (kept):** `traceback_definitions` (frames → file by longest unique suffix → the
+definition named in the frame, or the innermost one containing the line; test frames skipped),
+voting at weight 2 in `definition_order`, plus a function list for *every* prompt in
+`packet --json` (short reports were automatic misses). Full dev, engine run:
+
+| | func Acc@1 | Acc@5 | Acc@10 | Acc@20 |
+|---|---|---|---|---|
+| v1.3.0, dev-fast (52) | 0.135 | 0.269 | 0.346 | 0.385 |
+| **+ traceback + short reports, dev-fast** | **0.173** | **0.308** | **0.365** | 0.423 |
+| v1.3.0, dev-rest (158) | 0.166 | 0.299 | 0.369 | 0.427 |
+| **+ traceback + short reports, dev-rest** | **0.196** | **0.329** | **0.399** | 0.456 |
+| all 210 | 0.158 → **0.190** | 0.292 → **0.324** | 0.364 → **0.390** | 0.416 → 0.448 |
+
+File level unchanged on every instance (0.308/0.527/0.621/0.692). Of 20 short dev reports with
+function gold, 4 now have every edited function in the top 5 (0 before).
+
+Also fixed in passing: the definition ranker sorted query terms alphabetically and kept the first
+256, so a long report lost every term after about "p" (4 of 225 dev issues, 2 of 300 Lite issues
+exceed 256 distinct terms); it now keeps title terms, then the rarest, up to 1,024.
+
+### 8.15 Phase 3: plain-language questions through the docs (rejected)
+
+Idea (how people ask vs how code names things): the project's own doc sections that read most
+like the question (BM25 over Markdown/rST sections) name the flags and identifiers involved; the
+source files that contain those identifiers (rarity-weighted) vote next to the engine's list
+(RRF). Prototype `scripts/research/doc_bridge.py`, engine lists from v1.3.0 cached
+(`plain-lists-v130.jsonl`), R@3 on the four looked-at plain-language sets:
+
+| set | engine (v1.3.0) | doc bridge alone | fused w=0.5 | w=1 | w=2 |
+|---|---|---|---|---|---|
+| ripgrep (Rust) | 0.500 | 0.125 | 0.375 | 0.208 | 0.167 |
+| click (Python) | 0.917 | 0.500 | 0.958 | 0.875 | 0.833 |
+| cobra (Go) | 0.875 | 0.458 | 0.792 | 0.708 | 0.625 |
+| axios (JS) | 0.833 | 0.083 | 0.583 | 0.417 | 0.250 |
+
+Rejected: worse on three of four sets at every weight. Doc sections mention many identifiers
+(examples, other flags, changelog entries), and an identifier→file vote by containment spreads
+over every file that uses it — the bridge is far noisier than the question itself.
+
+**Why does a second definition ranker help? (`NM_DIAG=1`, one engine run, dev 225).** The engine
+emits its function list under research settings next to the shipped one
+(`diag_definitions`; `scripts/research/diag_eval.py`). Shipped = traceback vote + file prior.
+
+| variant | func Acc@1 fast / rest | func Acc@5 fast / rest | verdict |
+|---|---|---|---|
+| shipped (v1.4 candidate) | 0.173 / 0.196 | 0.308 / 0.329 | – |
+| no traceback vote | 0.135 / 0.171 | 0.288 / 0.316 | traceback's share: @1 +0.038/+0.025 |
+| no traceback, no file prior (raw ranking) | 0.135 / 0.171 | 0.288 / 0.304 | file prior's share: @5 0/+0.012 |
+| exact words instead of stems | 0.192 / 0.184 | 0.288 / 0.335 | rejected (mixed) |
+| method chunks carry their class name ("owner") | 0.192 / 0.209 | 0.308 / 0.342 | rejected: @5 0/+0.013 < bar |
+| RRF of owner + owner-unstemmed (two indices) | 0.212 / 0.222 | 0.308 / 0.342 | rejected by the pre-set bar (func @5 0/+0.013), although @1 rises +0.039/+0.026 — noted for a later round with a fresh dev split |
+
+The bar was fixed before the run (file Acc@1 or func Acc@5 ≥ +0.02 in both halves); the two-index
+fusion clears it only at func Acc@1, a metric the bar does not name, so it is not shipped.
+
+### 8.16 Fifth plain-language holdout: jsoup (Java), run once (2026-10-10)
+
+`concept-holdout5`: jhy/jsoup 1.18.1, 12 plain-language questions, gold written from the source
+and committed (`2b9f4a3` on the pushed branch, `b86026c` after rebase) before any engine run. Purpose fixed in advance: confirm the
+short-question list fusion (S1, §8.6), which had been decided on looked-at sets and was only
+neutral on axios. Run once with three binaries chosen beforehand (v1.2.0 = before S1, v1.3.0 =
+S1, the v1.4 candidate) and BM25:
+
+| | list R@3 | packet recall / precision |
+|---|---|---|
+| plain BM25 | 0.667 (R@1 0.500, R@5 0.917) | – |
+| v1.2.0 (no S1) | 0.417 | – |
+| **v1.3.0 (S1)** | **0.750** | – |
+| v1.4 candidate | 0.750 (list unchanged for short questions) | 0.667 / 0.235 |
+
+S1 holds on a language and repository never run before: +0.333 R@3 over the packet-order list and
++0.083 over BM25. jsoup is now looked at.
+
+**Fourteen sets with the v1.4 candidate** (traceback vote, function list for every prompt, query
+term cap fix): identical to the numbers on record (docs/measured.md) on all fourteen, including `concept`
+0.679 / 0.392 (§8.3's 0.398 was an older reading of this self-measuring set).
+
+**Dense on the short list only (prior 6, CodeRankEmbed/Jina-inspired).** jina-code-v2 (int8 ONNX,
+CPU, 4 threads) embeds the issue and the engine's top-30 definitions (text from the base commit),
+reorders them by cosine (`scripts/research/dense_shortlist.py`); the order votes by RRF. Dev 225,
+base = v1.4 candidate:
+
+| | file Acc@1 fast / rest | file Acc@3 | file Acc@5 | func Acc@1 | func Acc@5 |
+|---|---|---|---|---|---|
+| base | 0.271 / 0.319 | 0.525 / 0.524 | 0.576 / 0.633 | 0.173 / 0.196 | 0.308 / 0.329 |
+| + dense vote w=0.5 | 0.288 / 0.343 | 0.525 / 0.554 | 0.593 / 0.651 | 0.212 / 0.215 | 0.327 / 0.342 |
+| + dense vote w=1 | 0.271 / 0.361 | 0.559 / 0.554 | 0.610 / 0.645 | 0.212 / 0.190 | 0.308 / 0.329 |
+| dense order alone (all 225) | file 0.356 / 0.524 / 0.596 (@1/3/5) | | | func 0.162 / 0.276 (@1/5) | |
+
+Cost: 10.6 s p50 / 27.7 s p90 per issue on top of the engine (CPU shared with other runs).
+Verdict: **not shipped by default** — positive on almost every cell but below the pre-set bar in
+dev-fast (file Acc@1 +0.017 = one issue of 59; func Acc@5 +0.019/+0.013). Noted: the dense order
+alone puts the right file first more often than the engine (0.356 vs 0.307) while losing depth —
+a cheap re-ranker of the top few files, not a retriever. Candidate for an opt-in deep mode, to be
+decided on a larger split.
diff --git a/docs/research/paper-draft.md b/docs/research/paper-draft.md
index fb59f2b..4076fd5 100644
--- a/docs/research/paper-draft.md
+++ b/docs/research/paper-draft.md
@@ -12,8 +12,8 @@ graph, field-weighted lexical ranking, a definition-level ranking of long report
 report hygiene, all on a laptop CPU. On SWE-bench Lite, run once after tuning only on the SWE-bench
 dev split, the engine reaches file-level Acc@1/3/5 of 0.507/0.717/0.750 on 276 held-out issues
 (plain BM25 0.301/0.507/0.587) in 2.9 s per issue including a cold index — above a code embedding
-model at Acc@1 and level with Agentless+GPT-4o at Acc@5; on SWE-bench Verified's 403 issues outside
-Lite, 0.437/0.670/0.732 (BM25 0.194/0.372/0.476). We report every component's effect,
+model at Acc@1 and level with Agentless+GPT-4o at Acc@5; on SWE-bench Verified's 407 issues outside
+Lite, 0.435/0.671/0.732 (BM25 0.194/0.373/0.477). We report every component's effect,
 negative results (dense retrieval on CPU, cross-encoder reranking, blind graph expansion), and a
 holdout protocol that caught two results that looked-at sets had suggested. TODO: LLM stage (D1),
 Verified, ablations.
@@ -46,6 +46,11 @@ MoatlessTools (agentic search), CodeRankEmbed / Jina code embeddings (dense), BM
 3.3 Reports (≥60 words): hygiene (template scaffolding, links, checklists, headings), code-like
 tokens, definition-level BM25 with title ×3, RRF with the packet order → `where_to_look`.
 3.4 Short questions: RRF of packet order and whole-question ranking.
+3.5 Functions to look at (every prompt): the definition ranking fused (RRF) with each
+definition's file rank (Agentless's file → function step without an LLM), plus the functions a
+traceback runs through — each frame resolved to an indexed file by its longest unique path suffix,
+then to the definition named in the frame (or the innermost one containing its line), test frames
+skipped, voting at double weight deepest-first.
 
 ## 4. Evaluation protocol
 
@@ -81,8 +86,9 @@ tokens, definition-level BM25 with title ×3, RRF with the packet order → `whe
 
 dev: BM25 0.160/0.347/0.427/0.538 → engine v1.3.0 0.308/0.527/0.621/0.692 (Acc@1/3/5/10).
 Verified (run once per version): BM25 0.216/0.392/0.490/0.642 → v1.2.0 0.405/0.669/0.732/0.804 (496)
-→ **v1.3.0 0.446/0.680/0.736/0.814** (500). On the 403 Verified issues not in Lite: BM25
-0.194/0.372/0.476/0.620 → v1.2.0 0.392/0.655/0.727/0.809 → v1.3.0 0.437/0.670/0.732/0.811.
+→ **v1.3.0 0.446/0.680/0.736/0.814** (500). On the Verified issues not in Lite (407; v1.2.0 lost 4 to checkout errors): BM25
+0.194/0.372/0.476/0.620 → v1.2.0 0.392/0.655/0.727/0.809 (403 scored) → v1.3.0 0.435/0.671/0.732/0.811
+(all 407; BM25 on 407: 0.194/0.373/0.477/0.622).
 Function level (v1.3.0, all edited functions in top k): Verified 459 with function gold
 0.163/0.346/0.416 (Acc@1/5/10); not in Lite (375) 0.157/0.312/0.381.
 
@@ -120,9 +126,18 @@ p50 2.9 s / p90 10.6 s per Lite issue (Verified 2.5 s / 8.8 s) on a 6-core lapto
 | body term frequency in BM25F | Acc@5 0.544 → 0.509 |
 | MiniLM fusion | lowered every plain-language set |
 | evaluation: suffix match without segment boundary | inflated a BM25 baseline (0.958 vs 0.875) |
+| commit-history prior (BugLocator: similar past commit messages → their files) | dev file Acc@1 0.271 → 0.169 even at weight 0.1 |
+| identifiers in the issue's code blocks → their definitions | file Acc@1 drops; func Acc@5 +0.019 (below the 0.02 bar) |
+| RM3 pseudo-relevance feedback on the definition ranking | alone worse at @1 (0.135 → 0.038, dev-fast); as a vote no better than plain BM25 |
+| doc sections as a bridge from question words to identifiers (plain-language) | R@3 down on 3 of 4 sets (ripgrep 0.500 → 0.375, axios 0.833 → 0.583) |
+| evaluation: function-level denominator without short reports | 244 instead of 274 instances, Acc@5 0.443 instead of 0.394 |
 
 ## 7. Threats to validity
 
+Bookkeeping is itself a threat: two of our own evaluation slips were caught only by re-deriving
+counts against an external reference (LocAgent's 274) — a denominator that silently dropped short
+reports, and a prototype baseline taken from an older run. Both are reported with their effect.
+
 Different instance subsets vs published numbers; single annotator for plain-language gold; 12
 questions per plain-language holdout; Windows-only timing; blobless clones / network.
 
diff --git a/scripts/benchmark-fast.sh b/scripts/benchmark-fast.sh
index 3787128..1cf4e30 100644
--- a/scripts/benchmark-fast.sh
+++ b/scripts/benchmark-fast.sh
@@ -29,6 +29,7 @@ declare -A MANIFEST=(
   [concept-holdout2]="tests/third_party/concept-holdout2/repos.toml"
   [concept-holdout3]="tests/third_party/concept-holdout3/repos.toml"
   [concept-holdout4]="tests/third_party/concept-holdout4/repos.toml"
+  [concept-holdout5]="tests/third_party/concept-holdout5/repos.toml"
 )
 declare -A TEST=(
   [dev]="third_party_gold"
@@ -45,6 +46,7 @@ declare -A TEST=(
   [concept-holdout2]="third_party_private_gold"
   [concept-holdout3]="third_party_private_gold"
   [concept-holdout4]="third_party_private_gold"
+  [concept-holdout5]="third_party_private_gold"
 )
 sets=("$@")
 if [ ${#sets[@]} -eq 0 ]; then
@@ -82,6 +84,7 @@ run_set() {
     concept-holdout2) envs=(NM_PRIVATE_SET_DIR="$root/tests/third_party/concept-holdout2" NM_PRIVATE_DIR="$root/target/third_party/concept-holdout2") ;;
     concept-holdout3) envs=(NM_PRIVATE_SET_DIR="$root/tests/third_party/concept-holdout3" NM_PRIVATE_DIR="$root/target/third_party/concept-holdout3") ;;
     concept-holdout4) envs=(NM_PRIVATE_SET_DIR="$root/tests/third_party/concept-holdout4" NM_PRIVATE_DIR="$root/target/third_party/concept-holdout4") ;;
+    concept-holdout5) envs=(NM_PRIVATE_SET_DIR="$root/tests/third_party/concept-holdout5" NM_PRIVATE_DIR="$root/target/third_party/concept-holdout5") ;;
   esac
   # The harness resolves the workspace from its manifest dir at build time.
   (cd crates/neuromesh-context && env "${envs[@]}" "$bin" --nocapture >"$root/$out/$set.log" 2>&1 || true)
diff --git a/scripts/research/chunk_ablate.py b/scripts/research/chunk_ablate.py
new file mode 100644
index 0000000..dbd5c27
--- /dev/null
+++ b/scripts/research/chunk_ablate.py
@@ -0,0 +1,107 @@
+"""Which part of the Python definition-level BM25 (`chunk_prf.py`) makes its
+function list better than the engine's `rank_definitions`? Same checkout, same
+query, one index per variant; function lists written per variant for
+`priors.py --prior ext` / standalone scoring.
+
+  base       chunk_prf's chunks: method text prefixed with `class Name:`
+  noclass    methods without the class line
+  owner2     class name of a method counted twice (owner-name boost)
+  query_tf   query terms weighted by frequency (log), not set membership
+
+    py -3 scripts/research/chunk_ablate.py --data devset/swe-dev.json --repos repos --work C:/w/abl
+        --out chunk-abl-dev.jsonl [--subset devset/dev-fast.json]
+"""
+import argparse
+import json
+import math
+import os
+import sys
+from collections import Counter
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, os.path.dirname(__file__))
+from compare_baselines import repo_files, words  # noqa: E402
+from swebench_localize import checkout, gold_files  # noqa: E402
+from lex_variants import Bm25  # noqa: E402
+from chunk_prf import ranked  # noqa: E402
+from dense_loc import chunks_of  # noqa: E402
+
+
+def variant_docs(files, dest):
+    """Per variant: (docs, owners, labels)."""
+    out = {v: ([], [], []) for v in ("base", "noclass", "owner2")}
+    for f in files:
+        try:
+            text = open(os.path.join(dest, f), encoding="utf-8", errors="ignore").read()
+        except OSError:
+            text = ""
+        path_words = Counter(words(f.rsplit(".", 1)[0]))
+        if not f.endswith(".py"):
+            for v in out:
+                out[v][0].append(Counter(words(text)) + path_words)
+                out[v][1].append(f)
+                out[v][2].append("<module>")
+            continue
+        for label, ch in chunks_of(f, text, max_chars=20000):
+            base = Counter(words(ch)) + path_words
+            cls = label.split(".")[0] if "." in label else None
+            if cls:
+                body = ch.split("\n", 2)[2] if ch.count("\n") >= 2 else ch
+                noclass = Counter(words(f + "\n" + body)) + path_words
+                owner2 = base + Counter(words(cls))
+            else:
+                noclass, owner2 = base, base
+            for v, d in (("base", base), ("noclass", noclass), ("owner2", owner2)):
+                out[v][0].append(d)
+                out[v][1].append(f)
+                out[v][2].append(label)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data", required=True)
+    ap.add_argument("--repos", required=True)
+    ap.add_argument("--work", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--subset", default="")
+    args = ap.parse_args()
+    rows = json.load(open(args.data, encoding="utf-8"))
+    if args.subset:
+        keep = {r["instance_id"] for r in json.load(open(args.subset, encoding="utf-8"))}
+        rows = [r for r in rows if r["instance_id"] in keep]
+    rows.sort(key=lambda r: (r["repo"], r["instance_id"]))
+    done = set()
+    if os.path.exists(args.out):
+        done = {json.loads(l)["instance_id"] for l in open(args.out, encoding="utf-8") if l.strip()}
+    with open(args.out, "a", encoding="utf-8") as out:
+        for row in rows:
+            if row["instance_id"] in done:
+                continue
+            name = row["repo"].split("/")[1]
+            dest = os.path.join(args.work, name)
+            rec = {"instance_id": row["instance_id"], "repo": row["repo"], "gold": gold_files(row["patch"])}
+            try:
+                checkout(os.path.join(args.repos, name), row["base_commit"], dest)
+                files = repo_files(dest)
+                text = row["problem_statement"]
+                title = text.strip().splitlines()[0] if text.strip() else ""
+                q = Counter(set(words(text)))
+                for w in set(words(title)):
+                    q[w] += 2
+                qtf = Counter({w: 1 + math.log(c) for w, c in Counter(words(text)).items()})
+                for w in set(words(title)):
+                    qtf[w] += 2
+                for v, (docs, owners, labels) in variant_docs(files, dest).items():
+                    idx = Bm25(docs)
+                    rec[f"{v}_files"], rec[f"{v}_defs"] = ranked(idx.scores(q), owners, labels)
+                    if v == "base":
+                        rec["query_tf_files"], rec["query_tf_defs"] = ranked(idx.scores(qtf), owners, labels)
+            except Exception as e:  # recorded, not fatal
+                rec["error"] = str(e)[-300:]
+            out.write(json.dumps(rec) + "\n")
+            out.flush()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/research/chunk_prf.py b/scripts/research/chunk_prf.py
new file mode 100644
index 0000000..5cddedc
--- /dev/null
+++ b/scripts/research/chunk_prf.py
@@ -0,0 +1,155 @@
+"""Definition-level ranking variants for phase 1 (session 18), offline on checkouts:
+
+  chunk   definition-level BM25 with the issue title counted three times (the Python
+          stand-in for the engine's `chunk_rank`, `lex_variants.py`)
+  rm3     the same after RM3 pseudo-relevance feedback: the top `--fb-docs`
+          definitions' term distribution (weighted by retrieval score and idf)
+          adds `--fb-terms` words to the query, mixed with weight 1 - lambda
+  dense   jina-code-v2 cosine over the top `--dense-k` definitions of `chunk`
+          only (a short list, not the repository: CPU embeds ~2.6 chunks/s)
+
+Writes file lists and definition lists (`[path, name]`) per issue; `priors.py
+--prior ext` fuses any of them into the engine's stored lists and scores both
+halves of the dev split.
+
+    py -3 scripts/research/chunk_prf.py --data devset/swe-dev.json --repos repos --work C:/w/prf
+        --out prf-dev.jsonl [--dense-k 30] [--no-dense]
+"""
+import argparse
+import json
+import math
+import os
+import sys
+from collections import Counter, defaultdict
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, os.path.dirname(__file__))
+from compare_baselines import repo_files, words  # noqa: E402
+from swebench_localize import checkout, gold_files  # noqa: E402
+from dense_loc import chunks_of  # noqa: E402
+from lex_variants import Bm25  # noqa: E402
+
+
+def ranked(scores, owners, labels, n_files=50, n_defs=100):
+    best_f, best_d = {}, {}
+    for i, s in scores.items():
+        f = owners[i]
+        if s > best_f.get(f, 0):
+            best_f[f] = s
+        d = (f, labels[i])
+        if labels[i] != "<module>" and s > best_d.get(d, 0):
+            best_d[d] = s
+    files = [f for f, _ in sorted(best_f.items(), key=lambda kv: (-kv[1], kv[0]))][:n_files]
+    defs = [list(d) for d, _ in sorted(best_d.items(), key=lambda kv: (-kv[1], kv[0]))][:n_defs]
+    return files, defs
+
+
+def rm3_query(idx, docs, q, scores, fb_docs, fb_terms, lam):
+    top = sorted(scores.items(), key=lambda kv: -kv[1])[:fb_docs]
+    if not top:
+        return q
+    z = sum(s for _, s in top)
+    fb = defaultdict(float)
+    for i, s in top:
+        d = docs[i]
+        ln = max(sum(d.values()), 1)
+        for w, c in d.items():
+            fb[w] += (s / z) * (c / ln)
+    for w in list(fb):
+        df = idx.df.get(w, 0)
+        fb[w] *= math.log((idx.n - df + 0.5) / (df + 0.5) + 1)
+    terms = sorted(fb.items(), key=lambda kv: -kv[1])[:fb_terms]
+    tz = sum(v for _, v in terms) or 1.0
+    qz = sum(q.values()) or 1.0
+    out = Counter()
+    for w, c in q.items():
+        out[w] += lam * c / qz
+    for w, v in terms:
+        out[w] += (1 - lam) * v / tz
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data", required=True)
+    ap.add_argument("--repos", required=True)
+    ap.add_argument("--work", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--fb-docs", type=int, default=5)
+    ap.add_argument("--fb-terms", type=int, default=20)
+    ap.add_argument("--lam", type=float, default=0.6)
+    ap.add_argument("--dense-k", type=int, default=30)
+    ap.add_argument("--no-dense", action="store_true")
+    ap.add_argument("--subset", default="")
+    args = ap.parse_args()
+    rows = json.load(open(args.data, encoding="utf-8"))
+    if args.subset:
+        keep = {r["instance_id"] for r in json.load(open(args.subset, encoding="utf-8"))}
+        rows = [r for r in rows if r["instance_id"] in keep]
+    rows.sort(key=lambda r: (r["repo"], r["instance_id"]))
+    done = set()
+    if os.path.exists(args.out):
+        done = {json.loads(l)["instance_id"] for l in open(args.out, encoding="utf-8") if l.strip()}
+    emb = None
+    if not args.no_dense:
+        from dense_loc import Embedder
+        emb = Embedder("jina-code-v2", 512, threads=4)
+    with open(args.out, "a", encoding="utf-8") as out:
+        for row in rows:
+            if row["instance_id"] in done:
+                continue
+            name = row["repo"].split("/")[1]
+            dest = os.path.join(args.work, name)
+            rec = {"instance_id": row["instance_id"], "repo": row["repo"], "gold": gold_files(row["patch"])}
+            try:
+                checkout(os.path.join(args.repos, name), row["base_commit"], dest)
+                files = repo_files(dest)
+                docs, owners, labels, texts = [], [], [], []
+                for f in files:
+                    try:
+                        text = open(os.path.join(dest, f), encoding="utf-8", errors="ignore").read()
+                    except OSError:
+                        text = ""
+                    path_words = Counter(words(f.rsplit(".", 1)[0]))
+                    if f.endswith(".py"):
+                        for label, ch in chunks_of(f, text, max_chars=20000):
+                            docs.append(Counter(words(ch)) + path_words)
+                            owners.append(f)
+                            labels.append(label)
+                            texts.append(ch)
+                    else:
+                        docs.append(Counter(words(text)) + path_words)
+                        owners.append(f)
+                        labels.append("<module>")
+                        texts.append(text[:1500])
+                idx = Bm25(docs)
+                text = row["problem_statement"]
+                title = text.strip().splitlines()[0] if text.strip() else ""
+                q = Counter(set(words(text)))
+                for w in set(words(title)):
+                    q[w] += 2
+                s0 = idx.scores(q)
+                rec["chunk_files"], rec["chunk_defs"] = ranked(s0, owners, labels)
+                q1 = rm3_query(idx, docs, q, s0, args.fb_docs, args.fb_terms, args.lam)
+                s1 = idx.scores(q1)
+                rec["rm3_files"], rec["rm3_defs"] = ranked(s1, owners, labels)
+                if emb is not None:
+                    top = [i for i, _ in sorted(s0.items(), key=lambda kv: -kv[1])
+                           if labels[i] != "<module>" or not owners[i].endswith(".py")][:args.dense_k]
+                    vecs = emb.embed([text[:4000]] + [texts[i][:1500] for i in top])
+                    sims = vecs[1:] @ vecs[0]
+                    order = sorted(range(len(top)), key=lambda j: -float(sims[j]))
+                    rec["dense_defs"] = [[owners[top[j]], labels[top[j]]] for j in order]
+                    seen = []
+                    for j in order:
+                        if owners[top[j]] not in seen:
+                            seen.append(owners[top[j]])
+                    rec["dense_files"] = seen
+            except Exception as e:  # recorded, not fatal
+                rec["error"] = str(e)[-300:]
+            out.write(json.dumps(rec) + "\n")
+            out.flush()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/research/dense_shortlist.py b/scripts/research/dense_shortlist.py
new file mode 100644
index 0000000..9269497
--- /dev/null
+++ b/scripts/research/dense_shortlist.py
@@ -0,0 +1,95 @@
+"""Dense re-ranking of the engine's own short list (phase 1, prior 6).
+
+Whole-repository chunk embedding is hours per large repository on a laptop CPU
+(2.6 chunks/s, §8.1); CodeRankEmbed-style gains need it only where the lexical
+ranking already looks. This embeds the engine's top `--k` definitions (from a
+harness run with `NM_DEFINITIONS` ≥ k) and the issue with jina-code-v2 (int8
+ONNX), reorders them by cosine, and writes `dense_defs` / `dense_files` for
+`priors.py --prior ext`. Source text comes from the clone at the base commit
+(`git show`), so no checkout is needed. Embeddings are cached by text hash.
+
+    py -3 scripts/research/dense_shortlist.py --results dev-s18a-all.jsonl --data devset/swe-dev.json
+        --repos repos --out dense-sl-dev.jsonl [--k 30] [--cache emb-cache/shortlist.npz]
+"""
+import argparse
+import json
+import os
+import sys
+import time
+
+sys.path.insert(0, os.path.dirname(__file__))
+from dense_loc import Cache, Embedder, key  # noqa: E402
+from func_eval import git_show  # noqa: E402
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--results", required=True)
+    ap.add_argument("--data", required=True)
+    ap.add_argument("--repos", required=True)
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--k", type=int, default=30)
+    ap.add_argument("--cache", default="")
+    ap.add_argument("--threads", type=int, default=4)
+    ap.add_argument("--subset", default="")
+    args = ap.parse_args()
+    rows = {r["instance_id"]: r for r in json.load(open(args.data, encoding="utf-8"))}
+    res = [json.loads(l) for l in open(args.results, encoding="utf-8") if l.strip()]
+    res = [r for r in res if "error" not in r and r.get("definitions")]
+    if args.subset:
+        keep = {r["instance_id"] for r in json.load(open(args.subset, encoding="utf-8"))}
+        res = [r for r in res if r["instance_id"] in keep]
+    done = set()
+    if os.path.exists(args.out):
+        done = {json.loads(l)["instance_id"] for l in open(args.out, encoding="utf-8") if l.strip()}
+    emb = Embedder("jina-code-v2", 512, threads=args.threads)
+    cache = Cache(args.cache) if args.cache else None
+    with open(args.out, "a", encoding="utf-8") as out:
+        for n, r in enumerate(res, 1):
+            if r["instance_id"] in done:
+                continue
+            row = rows[r["instance_id"]]
+            clone = os.path.join(args.repos, row["repo"].split("/")[1])
+            defs = r["definitions"][: args.k]
+            texts, files = [], {}
+            for d in defs:
+                if d["path"] not in files:
+                    files[d["path"]] = git_show(clone, row["base_commit"], d["path"]).splitlines()
+                lines = files[d["path"]]
+                a, b = d["lines"]
+                body = "\n".join(lines[max(a - 1, 0):b])
+                texts.append(f"{d['path']}\n{d['name']}\n{body}"[:1500])
+            query = row["problem_statement"][:4000]
+            t0 = time.time()
+            todo = [t for t in [query] + texts if cache is None or key(t) not in cache.vec]
+            if todo:
+                vecs = emb.embed(todo)
+                if cache is not None:
+                    for t, v in zip(todo, vecs):
+                        cache.vec[key(t)] = v
+                    cache.dirty = True
+                fresh = dict(zip(todo, vecs))
+            else:
+                fresh = {}
+            get = lambda t: fresh[t] if t in fresh else cache.vec[key(t)]  # noqa: E731
+            q = get(query).astype("float32")
+            sims = [float(get(t).astype("float32") @ q) for t in texts]
+            order = sorted(range(len(defs)), key=lambda i: -sims[i])
+            dense_defs = [[defs[i]["path"], defs[i]["name"]] for i in order]
+            dense_files = []
+            for p, _ in dense_defs:
+                if p not in dense_files:
+                    dense_files.append(p)
+            out.write(json.dumps({"instance_id": r["instance_id"], "dense_defs": dense_defs,
+                                  "dense_files": dense_files, "sims": [round(sims[i], 4) for i in order],
+                                  "secs": round(time.time() - t0, 1)}) + "\n")
+            out.flush()
+            if cache is not None and n % 10 == 0:
+                cache.save()
+            print(f"[{n}/{len(res)}] {r['instance_id']} {time.time() - t0:.1f}s", flush=True)
+    if cache is not None:
+        cache.save()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/research/diag_eval.py b/scripts/research/diag_eval.py
new file mode 100644
index 0000000..ede0027
--- /dev/null
+++ b/scripts/research/diag_eval.py
@@ -0,0 +1,70 @@
+"""Function-level Acc@k of each `NM_DIAG` definition variant (and RRF fusions
+of two of them) per half of SWE-bench dev.
+
+    py -3 scripts/research/diag_eval.py --results dev-s18b-all.jsonl --data devset/swe-dev.json
+        --repos repos --gold-cache func-gold-dev.json [--fuse definitions+no_stem]
+"""
+import argparse
+import json
+import os
+import sys
+from collections import defaultdict
+
+sys.path.insert(0, os.path.dirname(__file__))
+from func_eval import load_gold, same  # noqa: E402
+
+
+def lists_of(r):
+    out = {"definitions": [(d["path"], d["name"]) for d in r.get("definitions", [])]}
+    for k, v in (r.get("diag_definitions") or {}).items():
+        out[k] = [(d["path"], d["name"]) for d in v]
+    return out
+
+
+def rrf(a, b, k=60):
+    s = defaultdict(float)
+    for lst in (a, b):
+        for i, d in enumerate(lst):
+            s[d] += 1 / (k + i + 1)
+    return [d for d, _ in sorted(s.items(), key=lambda kv: -kv[1])]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--results", required=True)
+    ap.add_argument("--data", required=True)
+    ap.add_argument("--repos", required=True)
+    ap.add_argument("--gold-cache", default="")
+    ap.add_argument("--fuse", action="append", default=[])
+    ap.add_argument("--halves", default="devset/dev-fast.json")
+    args = ap.parse_args()
+    rows = {r["instance_id"]: r for r in json.load(open(args.data, encoding="utf-8"))}
+    res = [json.loads(l) for l in open(args.results, encoding="utf-8") if l.strip()]
+    res = [r for r in res if "error" not in r]
+    golds = load_gold(rows, [r["instance_id"] for r in res], args.repos, args.gold_cache)
+    fast = {r["instance_id"] for r in json.load(open(args.halves, encoding="utf-8"))}
+    for half, sel in (("dev-fast", lambda i: i in fast), ("dev-rest", lambda i: i not in fast),
+                      ("all", lambda i: True)):
+        rs = [r for r in res if sel(r["instance_id"]) and golds.get(r["instance_id"])]
+        if not rs:
+            continue
+        variants = defaultdict(list)
+        for r in rs:
+            ls = lists_of(r)
+            for f in args.fuse:
+                a, b = f.split("+")
+                if a in ls and b in ls:
+                    ls[f] = rrf(ls[a], ls[b])
+            for name, lst in ls.items():
+                variants[name].append((lst, golds[r["instance_id"]]))
+        print(f"-- {half}: {len(rs)} with function gold")
+        for name, items in variants.items():
+            cells = []
+            for k in (1, 5, 10):
+                hit = sum(all(any(same(p, g) for p in lst[:k]) for g in gold) for lst, gold in items)
+                cells.append(f"@{k} {hit / len(items):.3f}")
+            print(f"   {name:24s} " + "  ".join(cells))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/research/doc_bridge.py b/scripts/research/doc_bridge.py
new file mode 100644
index 0000000..69d984f
--- /dev/null
+++ b/scripts/research/doc_bridge.py
@@ -0,0 +1,203 @@
+"""Plain-language questions through the project's own documentation (phase 3).
+
+People ask in the vocabulary of the docs ("smart case", "binary files"); the
+code says `--smart-case`, `BinaryDetection`. The docs are the bridge: the doc
+sections that read most like the question name the flags and identifiers
+involved, and the files that define those identifiers get a vote next to the
+engine's localisation list (RRF).
+
+    py -3 scripts/research/doc_bridge.py --bin <neuromesh.exe> --cache plain-lists.jsonl
+        --set ripgrep=<gold_tasks.toml>:<checkout> [--set ...] [--weights 0.5,1]
+
+R@3 per set = share of gold files in the top 3 (as `rerank_test.py`). Engine lists
+are cached (one `packet --json` per question).
+"""
+import argparse
+import json
+import math
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections import Counter, defaultdict
+
+try:
+    import tomllib
+except ImportError:  # Python < 3.11
+    import tomli as tomllib
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from compare_baselines import SOURCE_EXT, words  # noqa: E402
+
+DOC_EXT = (".md", ".rst", ".txt", ".adoc")
+CODE_EXT = tuple(e for e in SOURCE_EXT if e not in (".toml", ".yaml", ".yml", ".json", ".html", ".css", ".scss"))
+TICK = re.compile(r"`([^`\n]{2,60})`")
+FLAG = re.compile(r"(?<![\w-])--?[a-zA-Z][\w-]{2,40}")
+IDENT = re.compile(r"\b(?:[a-z]+_[a-z0-9_]+|[A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)+|[a-z]+[A-Z][A-Za-z0-9]+)\b")
+
+
+def packet(binary, repo, prompt):
+    home = tempfile.mkdtemp(prefix="nmhome-")
+    try:
+        r = subprocess.run([binary, "packet", "--json", "--query", prompt], cwd=repo,
+                           env=dict(os.environ, NEUROMESH_HOME=home, NEUROMESH_NO_BROWSER="1"),
+                           capture_output=True, text=True, timeout=900)
+        out = r.stdout
+        return json.loads(out[out.find("{"):])
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+
+
+def tracked(repo):
+    out = subprocess.run(["git", "-C", repo, "ls-files"], capture_output=True, text=True).stdout
+    return [f for f in out.splitlines() if f]
+
+
+def sections(repo, files):
+    """Doc sections: split at headings, long ones cut into 40-line pieces."""
+    out = []
+    for f in files:
+        if not f.lower().endswith(DOC_EXT) or "/node_modules/" in f:
+            continue
+        try:
+            lines = open(os.path.join(repo, f), encoding="utf-8", errors="ignore").read().splitlines()
+        except OSError:
+            continue
+        cur = []
+        for line in lines + ["# end"]:
+            heading = line.startswith("#") or (cur and set(line.strip()) <= set("=-~^") and line.strip())
+            if heading or len(cur) >= 40:
+                if cur:
+                    out.append((f, "\n".join(cur)))
+                cur = []
+            cur.append(line)
+    return out
+
+
+class Bm25:
+    def __init__(self, docs):
+        self.docs = [Counter(words(d)) for d in docs]
+        self.lens = [sum(d.values()) for d in self.docs]
+        self.avg = sum(self.lens) / max(len(self.docs), 1)
+        self.df = Counter()
+        for d in self.docs:
+            self.df.update(d.keys())
+        self.n = len(self.docs)
+
+    def rank(self, q):
+        qs = set(words(q))
+        out = []
+        for i, d in enumerate(self.docs):
+            s = 0.0
+            for w in qs:
+                t = d.get(w)
+                if t:
+                    idf = math.log((self.n - self.df[w] + 0.5) / (self.df[w] + 0.5) + 1)
+                    s += idf * t * 2.2 / (t + 1.2 * (0.25 + 0.75 * self.lens[i] / max(self.avg, 1)))
+            if s > 0:
+                out.append((s, i))
+        return [i for _, i in sorted(out, reverse=True)]
+
+
+def identifiers(text):
+    found = []
+    for m in TICK.findall(text):
+        for tok in re.split(r"[\s(),=]+", m):
+            tok = tok.strip(".:;'\"")
+            if len(tok) >= 3:
+                found.append(tok)
+    found += FLAG.findall(text)
+    found += IDENT.findall(text)
+    return found
+
+
+def bridge(repo, files, secs, idx, question, top_secs=3):
+    ranked = idx.rank(question)[:top_secs]
+    toks = Counter()
+    for r, i in enumerate(ranked):
+        for t in set(identifiers(secs[i][1])):
+            toks[t] += 1.0 / (r + 1)
+    if not toks:
+        return []
+    code = [f for f in files if f.endswith(CODE_EXT) and not re.search(r"(^|/)(tests?|testdata|examples?|docs?)/", f)]
+    votes = defaultdict(float)
+    # A file votes once per identifier it contains, scaled by how rare the identifier is.
+    texts = {}
+    for f in code:
+        try:
+            texts[f] = open(os.path.join(repo, f), encoding="utf-8", errors="ignore").read()
+        except OSError:
+            texts[f] = ""
+    for t, w in toks.items():
+        needle = t.lstrip("-") if t.startswith("-") else t
+        if len(needle) < 3:
+            continue
+        holders = [f for f, s in texts.items() if needle in s]
+        if not holders or len(holders) > 0.2 * len(code) + 3:
+            continue
+        for f in holders:
+            votes[f] += w / math.log(2 + len(holders))
+    return [f for f, _ in sorted(votes.items(), key=lambda kv: -kv[1])]
+
+
+def rrf(lists, weights, k=60):
+    s = defaultdict(float)
+    for lst, w in zip(lists, weights):
+        for i, f in enumerate(lst):
+            s[f] += w / (k + i + 1)
+    return [f for f, _ in sorted(s.items(), key=lambda kv: -kv[1])]
+
+
+def r_at3(order, gold):
+    top = [o.replace("\\", "/") for o in order[:3]]
+    return sum(1 for g in gold if g in top) / len(gold)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--bin", required=True)
+    ap.add_argument("--cache", required=True)
+    ap.add_argument("--set", action="append", required=True, help="name=gold.toml:checkout")
+    ap.add_argument("--weights", default="0.5,1")
+    ap.add_argument("--top-secs", type=int, default=3)
+    args = ap.parse_args()
+    cache = {}
+    if os.path.exists(args.cache):
+        for line in open(args.cache, encoding="utf-8"):
+            if line.strip():
+                r = json.loads(line)
+                cache[(r["set"], r["id"])] = r["localization"]
+    weights = [float(w) for w in args.weights.split(",")]
+    with open(args.cache, "a", encoding="utf-8") as out:
+        for spec in args.set:
+            name, rest = spec.split("=", 1)
+            gold_path, repo = rest.rsplit(":", 1) if rest.count(":") > 1 else rest.split(":", 1)
+            tasks = tomllib.load(open(gold_path, "rb"))["task"]
+            files = tracked(repo)
+            secs = sections(repo, files)
+            idx = Bm25([s[1] for s in secs])
+            res = {"engine": [], "doc": [], **{f"w={w:g}": [] for w in weights}}
+            fired = 0
+            for t in tasks:
+                key = (name, t["id"])
+                if key not in cache:
+                    loc = packet(args.bin, repo, t["prompt"]).get("localization", [])
+                    cache[key] = loc
+                    out.write(json.dumps({"set": name, "id": t["id"], "localization": loc}) + "\n")
+                    out.flush()
+                loc = cache[key]
+                doc = bridge(repo, files, secs, idx, t["prompt"], args.top_secs)
+                fired += bool(doc)
+                gold = t["gold_files"]
+                res["engine"].append(r_at3(loc, gold))
+                res["doc"].append(r_at3(doc, gold))
+                for w in weights:
+                    res[f"w={w:g}"].append(r_at3(rrf([loc, doc], [1.0, w]), gold))
+            print(f"{name:8s} {len(tasks)} q, {len(secs)} doc sections, bridge fired {fired}: " +
+                  "  ".join(f"{k} {sum(v) / len(v):.3f}" for k, v in res.items()))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/research/llm_localize.py b/scripts/research/llm_localize.py
index 93d2b82..3a06eb0 100644
--- a/scripts/research/llm_localize.py
+++ b/scripts/research/llm_localize.py
@@ -10,9 +10,16 @@
     py -3 scripts/research/llm_localize.py --results run.jsonl --data rows.json --repos <clones>
         --work <short dir> --out llm.jsonl [--endpoint http://127.0.0.1:8089/v1] [--top 15]
 
-Any OpenAI-compatible endpoint works (llama.cpp `llama-server`, a hosted API).
-Writes `llm` (model's order, then the rest of the candidates) plus token usage
-and latency per issue, so Acc@k and cost per issue can be reported side by side.
+Any OpenAI-compatible endpoint works (llama.cpp `llama-server`, a hosted API:
+`--endpoint https://inference.baseten.co/v1 --model deepseek-ai/DeepSeek-V4-Pro-0813`,
+key in `$LLM_API_KEY`). Writes `llm` (model's order, then the rest of the
+candidates) plus token usage and latency per issue, so Acc@k and cost per issue
+can be reported side by side.
+
+`--functions` adds Agentless's second step: the model's top files are shown
+with every function and method (the engine's `definitions` for them first), and
+the model names up to five to edit; written as `llm_funcs` for
+`func_eval.py --key llm_funcs`.
 """
 import argparse
 import json
@@ -60,21 +67,88 @@ def skeleton(root, path, max_lines=30, max_chars=900):
     return f"{path}\n{body}" if body else path
 
 
-def chat(endpoint, prompt, max_tokens=200):
-    req = urllib.request.Request(
-        endpoint.rstrip("/") + "/chat/completions",
-        data=json.dumps({
-            "model": "local",
-            "messages": [{"role": "user", "content": prompt}],
-            "temperature": 0,
-            "max_tokens": max_tokens,
-        }).encode(),
-        headers={"Content-Type": "application/json",
-                 "Authorization": "Bearer " + os.environ.get("LLM_API_KEY", "none")},
-    )
-    with urllib.request.urlopen(req, timeout=1800) as r:
-        data = json.loads(r.read())
-    return data["choices"][0]["message"]["content"], data.get("usage", {})
+MODEL = "local"
+
+
+def chat(endpoint, prompt, max_tokens=200, tries=4):
+    """One completion. Hosted reasoning models spend tokens thinking first, so
+    `max_tokens` must leave room for that; 429/5xx retry with backoff."""
+    body = json.dumps({
+        "model": MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0,
+        "max_tokens": max_tokens,
+    }).encode()
+    for attempt in range(tries):
+        req = urllib.request.Request(
+            endpoint.rstrip("/") + "/chat/completions", data=body,
+            headers={"Content-Type": "application/json",
+                     "Authorization": "Bearer " + os.environ.get("LLM_API_KEY", "none")})
+        try:
+            with urllib.request.urlopen(req, timeout=1800) as r:
+                data = json.loads(r.read())
+            return data["choices"][0]["message"].get("content") or "", data.get("usage", {})
+        except urllib.error.HTTPError as e:
+            if e.code not in (429, 500, 502, 503, 504) or attempt == tries - 1:
+                raise
+            time.sleep(10 * (attempt + 1))
+    raise RuntimeError("unreachable")
+
+
+FUNC_PROMPT = """You are localising the code change a GitHub issue needs.
+
+### Issue
+{issue}
+
+### Functions in the files most likely to change
+{listing}
+
+Which functions or methods must be edited to resolve the issue? Answer with up
+to {k} entries from the list above, most likely first, one per line as
+`path:Name` exactly as listed, inside a single FENCE block, and nothing else.""".replace("FENCE", "`" * 3)
+
+
+def function_listing(root, path, first, max_items=60):
+    """`path:Class.method` lines for one file: the engine's ranked definitions
+    first, then the file's other functions in source order."""
+    import ast
+    try:
+        tree = ast.parse(open(os.path.join(root, path), encoding="utf-8", errors="ignore").read())
+    except (OSError, SyntaxError, ValueError):
+        return [f"{path}:{n}" for n in first][:max_items]
+    names = []
+
+    def walk(node, stack):
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, ast.ClassDef):
+                walk(child, stack + [child.name])
+            elif isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                names.append(".".join(stack + [child.name]))
+                walk(child, stack + [child.name])
+            else:
+                walk(child, stack)
+
+    walk(tree, [])
+    ordered = [n for n in first if n in names] + [n for n in names if n not in first]
+    return [f"{path}:{n}" for n in ordered][:max_items]
+
+
+def parse_funcs(answer, listing):
+    allowed = {l: tuple(l.rsplit(":", 1)) for l in listing}
+    picked = []
+    for line in answer.splitlines():
+        line = line.strip().strip("`").strip().lstrip("-*0123456789. ").strip()
+        if not line:
+            continue
+        hit = allowed.get(line)
+        if hit is None:
+            for l, pn in allowed.items():
+                if l.endswith(line) or line.endswith(":" + pn[1]):
+                    hit = pn
+                    break
+        if hit and list(hit) not in picked:
+            picked.append(list(hit))
+    return picked
 
 
 def parse(answer, candidates):
@@ -104,7 +178,13 @@ def main():
     ap.add_argument("--subset", default="")
     ap.add_argument("--shuffle", action="store_true",
                     help="list candidates alphabetically, hiding the engine's order from the model")
+    ap.add_argument("--model", default="local")
+    ap.add_argument("--max-tokens", type=int, default=200)
+    ap.add_argument("--functions", action="store_true", help="second step: functions in the top files")
+    ap.add_argument("--func-files", type=int, default=3)
     args = ap.parse_args()
+    global MODEL
+    MODEL = args.model
     rows = {r["instance_id"]: r for r in json.load(open(args.data, encoding="utf-8"))}
     keep = None
     if args.subset:
@@ -130,7 +210,7 @@ def main():
                                        skeletons="\n\n".join(skeleton(dest, c) for c in shown))
                 t0 = time.time()
                 try:
-                    answer, usage = chat(args.endpoint, prompt)
+                    answer, usage = chat(args.endpoint, prompt, args.max_tokens)
                 except Exception as e:  # recorded, not fatal
                     answer, usage = f"ERROR {e}", {}
                 secs = time.time() - t0
@@ -138,6 +218,22 @@ def main():
                 rec = {"instance_id": r["instance_id"], "repo": r["repo"], "gold": r["gold"],
                        "loc": r["loc_files"], "llm": picked + [c for c in r["loc_files"] if c not in picked],
                        "picked": picked, "answer": answer[:500], "usage": usage, "secs": round(secs, 1)}
+                if args.functions:
+                    engine_defs = r.get("definitions", [])
+                    listing = []
+                    for f in rec["llm"][: args.func_files]:
+                        listing += function_listing(dest, f, [d["name"] for d in engine_defs if d["path"] == f])
+                    fprompt = FUNC_PROMPT.format(issue=issue, k=args.k, listing="\n".join(listing))
+                    t1 = time.time()
+                    try:
+                        fanswer, fusage = chat(args.endpoint, fprompt, args.max_tokens)
+                    except Exception as e:  # recorded, not fatal
+                        fanswer, fusage = f"ERROR {e}", {}
+                    chosen = parse_funcs(fanswer, listing)
+                    rest = [[d["path"], d["name"]] for d in engine_defs if [d["path"], d["name"]] not in chosen]
+                    rec.update({"llm_funcs": [{"path": p_, "name": n_} for p_, n_ in chosen + rest],
+                                "func_answer": fanswer[:500], "func_usage": fusage,
+                                "func_secs": round(time.time() - t1, 1)})
                 out.write(json.dumps(rec) + "\n")
                 out.flush()
                 print(f"[{n}/{len(res)}] {r['instance_id']} picked={len(picked)} "
diff --git a/scripts/research/paper_tables.py b/scripts/research/paper_tables.py
new file mode 100644
index 0000000..67601d8
--- /dev/null
+++ b/scripts/research/paper_tables.py
@@ -0,0 +1,192 @@
+"""Every SWE-bench table in the paper, rebuilt from the stored result files.
+
+    py -3 scripts/research/paper_tables.py --swe <swebench dir> [--repos <clones>] [--out tables.md]
+
+Reads the harness outputs (`swebench_localize.py` jsonl), the instance subsets
+under `<swe>/devset/`, and the function-gold caches (`func-gold-*.json`, built
+by `func_eval.py --gold-cache`; computed from the clones when missing). Runs that
+are not on disk are skipped with a note, so the script works at any point of
+the project. Published numbers are constants below, each with its source.
+"""
+import argparse
+import json
+import os
+import statistics
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+from eval_loc import acc  # noqa: E402
+from func_eval import boot_ci, load_gold, same  # noqa: E402
+
+# (label, results file, list key) per benchmark; first existing file wins per label.
+RUNS = {
+    "lite": [
+        ("engine v1.2.0", "results-final-test.jsonl", "loc_files"),
+        ("engine v1.3.0", "lite-v130-all.jsonl", "loc_files"),
+        ("engine v1.4.0", "lite-v140-all.jsonl", "loc_files"),
+    ],
+    "verified": [
+        ("engine v1.2.0", "results-verified-v120.jsonl", "loc_files"),
+        ("engine v1.3.0", "verified-v130-all.jsonl", "loc_files"),
+        ("engine v1.4.0", "verified-v140-all.jsonl", "loc_files"),
+    ],
+}
+SUBSETS = {
+    "Lite strict holdout": ("lite", "devset/lite-holdout-ids.json"),
+    "Lite, LocAgent subset": ("lite", "devset/locagent-274.json"),
+    "Verified, all": ("verified", None),
+    "Verified, not in Lite": ("verified", "devset/verified-not-lite.json"),
+}
+ABLATION = [  # Lite strict holdout, v1.2.0 engine with one component switched off (NM_ABLATE build)
+    ("nothing removed", "results-final-test.jsonl", "loc_files"),
+    ("report hygiene + code tokens (C11)", "abl-hyg-all.jsonl", "loc_files"),
+    ("definition-level ranking (C12)", "abl-chunk-all.jsonl", "loc_files"),
+    ("localisation list (packet order only)", "results-final-test.jsonl", "ours_files"),
+]
+# LocAgent (arXiv 2503.09089) Table 4, SWE-bench Lite, their 274-instance subset.
+PUBLISHED_FILE = [
+    ("BM25 †", "–", 0.3869, 0.5182, 0.6168),
+    ("Jina-Code-v2 †", "–", 0.4343, 0.7117, 0.8029),
+    ("CodeRankEmbed †", "–", 0.5255, 0.7774, 0.8467),
+    ("Agentless + GPT-4o †", "✓", 0.6715, 0.7445, 0.7445),
+    ("Agentless + Claude-3.5 †", "✓", 0.7263, 0.7920, 0.7956),
+    ("LocAgent + Qwen2.5-7B (ft) †", "✓", 0.7080, 0.8467, 0.8832),
+    ("LocAgent + Claude-3.5 †", "✓", 0.7774, 0.9197, 0.9416),
+]
+PUBLISHED_FUNC = [  # function level Acc@5 / Acc@10, same table
+    ("BM25 †", 0.3175, 0.3686),
+    ("CodeRankEmbed †", 0.5182, 0.5876),
+    ("Agentless + Claude-3.5 †", 0.5876, None),
+    ("LocAgent + Claude-3.5 †", 0.7336, 0.7737),
+]
+
+
+def load(path):
+    out = {}
+    for line in open(path, encoding="utf-8"):
+        if line.strip():
+            r = json.loads(line)
+            if "error" not in r:
+                out[r["instance_id"]] = r
+    return out
+
+
+def ids_of(swe, subset, rows):
+    if subset is None:
+        return [r["instance_id"] for r in rows]
+    return [r["instance_id"] for r in json.load(open(os.path.join(swe, subset), encoding="utf-8"))]
+
+
+def fmt(vals, ci):
+    m = sum(vals) / len(vals)
+    if not ci:
+        return f"{m:.3f}"
+    lo, hi = boot_ci(vals)
+    return f"{m:.3f} [{lo:.2f},{hi:.2f}]"
+
+
+def file_row(res, ids, key, ks=(1, 3, 5, 10), ci=True):
+    """Acc@k over `ids`; an instance the run lost (checkout error) counts as a miss."""
+    cells = []
+    for k in ks:
+        if key.startswith("bm25"):
+            vals = [res[i].get(f"bm25_hit@{k}", 0) if i in res else 0 for i in ids]
+        else:
+            vals = [acc(res[i].get(key) or [], res[i]["gold"], k) if i in res else 0 for i in ids]
+        cells.append(fmt(vals, ci and k in (1, 3, 5)))
+    return cells
+
+
+def func_row(res, ids, golds, key="definitions", ks=(1, 5, 10)):
+    have = [i for i in ids if golds.get(i)]
+    cells = []
+    for k in ks:
+        vals = []
+        for i in have:
+            preds = [(d["path"], d["name"]) for d in (res.get(i, {}).get(key) or [])][:k]
+            vals.append(int(all(any(same(p, g) for p in preds) for g in golds[i])))
+        cells.append(fmt(vals, k == 5))
+    return len(have), cells
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--swe", required=True)
+    ap.add_argument("--repos", default="")
+    ap.add_argument("--out", default="")
+    args = ap.parse_args()
+    swe = args.swe
+    repos = args.repos or os.path.join(swe, "repos")
+    data = {"lite": json.load(open(os.path.join(swe, "lite.json"), encoding="utf-8")),
+            "verified": json.load(open(os.path.join(swe, "verified.json"), encoding="utf-8"))}
+    rows_by = {b: {r["instance_id"]: r for r in d} for b, d in data.items()}
+    lines = ["# Paper tables (generated by scripts/research/paper_tables.py)", ""]
+
+    runs = {}
+    for bench, lst in RUNS.items():
+        for label, f, key in lst:
+            p = os.path.join(swe, f)
+            if os.path.exists(p):
+                runs[(bench, label)] = (load(p), key)
+            else:
+                lines.append(f"_skipped: {bench} {label} ({f} not found)_")
+    lines.append("")
+
+    lines += ["## File level (all gold files in the top k; 95% bootstrap CI)", "",
+              "| set | n | method | Acc@1 | Acc@3 | Acc@5 | Acc@10 |", "|---|---|---|---|---|---|---|"]
+    for name, (bench, subset) in SUBSETS.items():
+        ids = ids_of(swe, subset, data[bench])
+        # BM25 from the run that scored it on the most instances (an older run
+        # may have lost a few to checkout errors).
+        cands = [runs[k][0] for k in runs if k[0] == bench]
+        bm_src = max(cands, key=lambda res: sum("bm25_hit@1" in r for r in res.values()), default=None)
+        if bm_src is not None:
+            lines.append(f"| {name} | {len(ids)} | BM25 | " + " | ".join(file_row(bm_src, ids, "bm25")) + " |")
+        for (b, label), (res, key) in runs.items():
+            if b == bench:
+                lines.append(f"| {name} | {len(ids)} | {label} | " + " | ".join(file_row(res, ids, key)) + " |")
+    lines += ["", "Published (LocAgent Table 4, Lite 274): " + "; ".join(
+        f"{n} {a1:.3f}/{a3:.3f}/{a5:.3f}" for n, _, a1, a3, a5 in PUBLISHED_FILE), ""]
+
+    lines += ["## Function level (every edited function in the top k)", "",
+              "| set | n with function gold | method | Acc@1 | Acc@5 | Acc@10 |", "|---|---|---|---|---|---|"]
+    gold_cache = {"lite": os.path.join(swe, "func-gold-lite.json"),
+                  "verified": os.path.join(swe, "func-gold-verified.json")}
+    golds = {}
+    for bench in data:
+        all_ids = [r["instance_id"] for r in data[bench]]
+        golds[bench] = load_gold(rows_by[bench], all_ids, repos, gold_cache[bench])
+    for name, (bench, subset) in SUBSETS.items():
+        ids = ids_of(swe, subset, data[bench])
+        for (b, label), (res, _) in runs.items():
+            if b == bench and any("definitions" in r for r in res.values()):
+                n, cells = func_row(res, ids, golds[bench])
+                lines.append(f"| {name} | {n} | {label} | " + " | ".join(cells) + " |")
+    lines += ["", "Published function Acc@5/@10 (LocAgent Table 4): " + "; ".join(
+        f"{n} {a5:.3f}/{a10:.3f}" if a10 else f"{n} {a5:.3f}" for n, a5, a10 in PUBLISHED_FUNC), ""]
+
+    lines += ["## Ablation (Lite strict holdout, 276)", "",
+              "| removed | Acc@1 | Acc@3 | Acc@5 | Acc@10 |", "|---|---|---|---|---|"]
+    ids = ids_of(swe, "devset/lite-holdout-ids.json", data["lite"])
+    for label, f, key in ABLATION:
+        p = os.path.join(swe, f)
+        if os.path.exists(p):
+            lines.append(f"| {label} | " + " | ".join(file_row(load(p), ids, key, ci=False)) + " |")
+    lines.append("")
+
+    lines += ["## Cost per issue (cold index included, laptop CPU)", "",
+              "| run | n | latency p50 | p90 | packet tokens p50 |", "|---|---|---|---|---|"]
+    for (bench, label), (res, _) in runs.items():
+        lat = sorted(r["ours_latency_ms"] for r in res.values() if r.get("ours_latency_ms") is not None)
+        tok = sorted(r["ours_tokens"] for r in res.values() if r.get("ours_tokens") is not None)
+        if lat:
+            lines.append(f"| {bench} {label} | {len(lat)} | {statistics.median(lat) / 1000:.1f} s | "
+                         f"{lat[int(0.9 * (len(lat) - 1))] / 1000:.1f} s | {int(statistics.median(tok))} |")
+    text = "\n".join(lines) + "\n"
+    if args.out:
+        open(args.out, "w", encoding="utf-8", newline="\n").write(text)
+    print(text)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/research/priors.py b/scripts/research/priors.py
new file mode 100644
index 0000000..b34967d
--- /dev/null
+++ b/scripts/research/priors.py
@@ -0,0 +1,462 @@
+"""Offline prototypes of LLM-free priors for issue localisation (session 18, phase 1).
+
+Each prior reads the issue text (and, where it needs one, the repository at the
+issue's base commit — never anything later) and returns ranked votes:
+files and/or functions. The votes are fused by RRF into the engine's stored
+lists (`loc_files`, `definitions` from `swebench_localize.py`), and file- and
+function-level Acc@k are printed per half of the SWE-bench dev split, so a prior
+is kept only if it helps on both halves.
+
+    py -3 scripts/research/priors.py --results dev-func300-all.jsonl --data devset/swe-dev.json
+        --repos repos --prior traceback [--weights 0.5,1,2,4] [--gold-cache func-gold-dev.json]
+
+Priors:
+  codeonly   function list without non-code "definitions" (YAML/JSON/TOML keys)
+  traceback  frames `File "x.py", line N, in f` → the function at base commit (name, then line)
+  repro      identifiers called / imported in the issue's code blocks → their definitions
+  history    BugLocator: past commits (ancestors of base) whose message is like the issue
+             → the files they changed
+  testlink   tests the issue names → modules those tests import
+"""
+import argparse
+import ast
+import json
+import math
+import os
+import re
+import subprocess
+import sys
+from collections import Counter, defaultdict
+
+sys.path.insert(0, os.path.dirname(__file__))
+from eval_loc import acc  # noqa: E402
+from func_eval import boot_ci, defs_with_names, git_show, load_gold, same  # noqa: E402
+from mention_prior import resolve  # noqa: E402
+
+CODE_EXT = (".py", ".pyx", ".pyi")
+
+
+# ---------------------------------------------------------------- repository access
+
+class Repo:
+    """Read-only view of a clone at one commit (object store only, no checkout)."""
+
+    _trees = {}
+    _shows = {}
+
+    def __init__(self, clone, commit):
+        self.clone, self.commit = clone, commit
+
+    def files(self):
+        key = (self.clone, self.commit)
+        if key not in Repo._trees:
+            out = subprocess.run(["git", "-C", self.clone, "ls-tree", "-r", "--name-only", self.commit],
+                                 capture_output=True, text=True, encoding="utf-8", errors="ignore").stdout
+            Repo._trees[key] = out.splitlines()
+        return Repo._trees[key]
+
+    def py_files(self):
+        return [f for f in self.files() if f.endswith(".py")]
+
+    def show(self, path):
+        key = (self.clone, self.commit, path)
+        if key not in Repo._shows:
+            Repo._shows[key] = git_show(self.clone, self.commit, path)
+        return Repo._shows[key]
+
+    def defs(self, path):
+        return defs_with_names(self.show(path))
+
+
+def by_name_index(files):
+    idx = {}
+    for f in files:
+        if "/test" in "/" + f or f.startswith("test"):
+            continue
+        idx.setdefault(f.rsplit("/", 1)[-1], []).append(f)
+    return idx
+
+
+def is_test(path):
+    p = "/" + path
+    return "/test" in p or "/tests/" in p or path.rsplit("/", 1)[-1].startswith("test_")
+
+
+# ---------------------------------------------------------------- issue text
+
+FENCE = re.compile(r"```[^\n]*\n(.*?)```", re.S)
+
+
+def code_blocks(text):
+    """Fenced blocks, doctest lines and 4-space indented runs."""
+    blocks = FENCE.findall(text)
+    rest = FENCE.sub("", text)
+    doc = [l.strip()[4:] for l in rest.splitlines() if l.strip().startswith((">>> ", "... "))]
+    if doc:
+        blocks.append("\n".join(doc))
+    indented, cur = [], []
+    for line in rest.splitlines():
+        if line.startswith(("    ", "\t")) and line.strip():
+            cur.append(line.strip())
+        else:
+            if len(cur) >= 2:
+                indented.append("\n".join(cur))
+            cur = []
+    if len(cur) >= 2:
+        indented.append("\n".join(cur))
+    return blocks + indented
+
+
+# ---------------------------------------------------------------- priors
+
+def prior_codeonly(row, res, repo):
+    defs = [(d["path"], d["name"]) for d in res.get("definitions", [])]
+    return None, [d for d in defs if d[0].endswith(CODE_EXT)], "replace"
+
+
+FRAME = re.compile(r'File "([^"]+\.py)", line (\d+), in ([\w<>.]+)')
+PYTEST_FRAME = re.compile(r"^([\w./\\-]+\.py):(\d+):(?: in ([\w<>.]+))?", re.M)
+
+
+def enclosing(defs, line, name=None):
+    """Innermost def containing `line`; with `name`, prefer defs of that name."""
+    named = [d for d in defs if name and d[2].split(".")[-1] == name]
+    if named:
+        inside = [d for d in named if d[0] <= line <= d[1]]
+        pick = min(inside or named, key=lambda d: (abs(d[0] - line) if not inside else d[1] - d[0]))
+        return pick[2]
+    inside = [d for d in defs if d[0] <= line <= d[1]]
+    return min(inside, key=lambda d: d[1] - d[0])[2] if inside else None
+
+
+def prior_traceback(row, res, repo):
+    text = row["problem_statement"]
+    frames = [(p, int(n), f) for p, n, f in FRAME.findall(text)]
+    frames += [(p, int(n), f or None) for p, n, f in PYTEST_FRAME.findall(text)]
+    if not frames:
+        return [], [], "fuse"
+    files = repo.py_files()
+    idx = by_name_index(files)
+    out_files, out_funcs = [], []
+    for path, line, func in reversed(frames):  # deepest first
+        f = resolve(path, files, idx)
+        if not f or is_test(f):
+            continue
+        if f not in out_files:
+            out_files.append(f)
+        name = enclosing(repo.defs(f), line, None if func in (None, "<module>") else func)
+        if name and (f, name) not in out_funcs:
+            out_funcs.append((f, name))
+    return out_files, out_funcs, "fuse"
+
+
+CALL = re.compile(r"(?<![\w.])(\w+)\s*\(|\.(\w+)\s*\(|\.(\w+)\b")
+IMPORT = re.compile(r"^\s*from\s+([\w.]+)\s+import\s+\(?([\w,\s]+)\)?|^\s*import\s+([\w.]+)", re.M)
+STOP = set("print len str int float list dict set tuple range open isinstance type super self cls "
+           "append extend items keys values get format join split strip shape dtype copy "
+           "array arange zeros ones linspace DataFrame Series plot show figure subplots "
+           "assert raise return import from".split())
+
+
+def module_file(mod, files):
+    p = mod.replace(".", "/")
+    for cand in (p + ".py", p + "/__init__.py"):
+        hits = [f for f in files if f == cand or f.endswith("/" + cand)]
+        if len(hits) == 1:
+            return hits[0]
+        if hits:
+            return min(hits, key=len)
+    return None
+
+
+def prior_repro(row, res, repo):
+    blocks = code_blocks(row["problem_statement"])
+    if not blocks:
+        return [], [], "fuse"
+    code = "\n".join(blocks)
+    files = repo.py_files()
+    out_files, names = [], []
+    for m in IMPORT.finditer(code):
+        mod = m.group(1) or m.group(3)
+        f = module_file(mod, files)
+        if f and not is_test(f) and f not in out_files:
+            out_files.append(f)
+        for n in (m.group(2) or "").replace("\n", " ").split(","):
+            n = n.strip().split(" as ")[0].strip()
+            if n:
+                names.append(n)
+                sub = module_file(mod + "." + n, files)
+                if sub and not is_test(sub) and sub not in out_files:
+                    out_files.append(sub)
+    for m in CALL.finditer(code):
+        n = m.group(1) or m.group(2) or m.group(3)
+        if n and n not in STOP and not n.startswith("__") and len(n) > 2:
+            names.append(n)
+    counts = Counter(names)
+    # Definitions with those names, among the engine's deep list (the engine port
+    # looks them up in its own symbol table).
+    defs = [(d["path"], d["name"]) for d in res.get("definitions", []) if d["path"].endswith(CODE_EXT)]
+    by_last = defaultdict(list)
+    for p, n in defs:
+        by_last[n.split(".")[-1]].append((p, n))
+    out_funcs = []
+    for n, _ in sorted(counts.items(), key=lambda kv: -kv[1]):
+        for d in by_last.get(n, [])[:3]:
+            if d not in out_funcs and not is_test(d[0]):
+                out_funcs.append(d)
+    for p, _ in out_funcs:
+        if p not in out_files:
+            out_files.append(p)
+    return out_files, out_funcs, "fuse"
+
+
+WORD = re.compile(r"[A-Za-z][A-Za-z0-9]+")
+
+
+def toks(text):
+    out = []
+    for w in WORD.findall(text):
+        for part in re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", w).split():
+            p = part.lower()
+            if len(p) > 2:
+                out.append(p)
+    return out
+
+
+class History:
+    """Commit log of one clone: message tokens and changed .py files per commit.
+    `--no-renames`: rename detection reads blobs, which a blobless clone fetches one
+    by one over the network (it returned 214 of 1,878 pvlib commits in 53 s)."""
+
+    _cache = {}
+
+    @classmethod
+    def of(cls, clone):
+        if clone not in cls._cache:
+            cls._cache[clone] = cls(clone)
+        return cls._cache[clone]
+
+    def __init__(self, clone):
+        out = subprocess.run(["git", "-C", clone, "log", "--all", "--no-merges", "--no-renames", "--format=%x01%H%x02%s%n%b%x03",
+                              "--name-only"], capture_output=True, text=True, encoding="utf-8",
+                             errors="ignore").stdout
+        self.commits = {}
+        for chunk in out.split("\x01")[1:]:
+            head, _, rest = chunk.partition("\x02")
+            msg, _, names = rest.partition("\x03")
+            fs = [l.strip() for l in names.splitlines() if l.strip().endswith(".py")]
+            self.commits[head.strip()] = (Counter(toks(msg)), fs)
+        self.clone = clone
+
+    def ancestors(self, commit):
+        out = subprocess.run(["git", "-C", self.clone, "rev-list", commit], capture_output=True,
+                             text=True).stdout
+        return [h for h in out.split() if h in self.commits]
+
+
+def prior_history(row, res, repo, top=20, max_files=10):
+    hist = History.of(repo.clone)
+    anc = hist.ancestors(repo.commit)
+    docs = [(h, hist.commits[h]) for h in anc if 0 < len(hist.commits[h][1]) <= max_files]
+    if not docs:
+        return [], [], "fuse"
+    n = len(docs)
+    df = Counter()
+    for _, (c, _) in docs:
+        df.update(c.keys())
+    avg = sum(sum(c.values()) for _, (c, _) in docs) / n
+    q = Counter(toks(row["problem_statement"]))
+    scored = []
+    for h, (c, fs) in docs:
+        ln = sum(c.values())
+        s = 0.0
+        for w, qc in q.items():
+            t = c.get(w)
+            if t:
+                idf = math.log((n - df[w] + 0.5) / (df[w] + 0.5) + 1)
+                s += idf * t * 2.2 / (t + 1.2 * (0.25 + 0.75 * ln / max(avg, 1)))
+        if s > 0:
+            scored.append((s, h, fs))
+    scored.sort(reverse=True)
+    present = set(repo.files())
+    votes = defaultdict(float)
+    for s, h, fs in scored[:top]:
+        for f in fs:
+            if f in present and not is_test(f):
+                votes[f] += s / len(fs)
+    return [f for f, _ in sorted(votes.items(), key=lambda kv: -kv[1])], [], "fuse"
+
+
+TESTNAME = re.compile(r"\b(test_\w+)\b")
+TESTPATH = re.compile(r"[\w./\\-]*tests?[\w./\\-]*\.py\b")
+
+
+def prior_testlink(row, res, repo):
+    text = row["problem_statement"]
+    files = repo.py_files()
+    tests = []
+    for tok in TESTPATH.findall(text):
+        f = resolve(tok, files, {})
+        if f and is_test(f) and f not in tests:
+            tests.append(f)
+    names = set(TESTNAME.findall(text))
+    if names and not tests:
+        # A test named without its file: test modules defining it (bounded scan).
+        for f in files:
+            if is_test(f) and f.rsplit("/", 1)[-1].startswith("test"):
+                src = repo.show(f)
+                if any(f"def {n}(" in src for n in names):
+                    tests.append(f)
+                    if len(tests) >= 3:
+                        break
+    out = []
+    for t in tests:
+        try:
+            tree = ast.parse(repo.show(t))
+        except (SyntaxError, ValueError):
+            continue
+        for node in ast.walk(tree):
+            mod = None
+            if isinstance(node, ast.ImportFrom) and node.module:
+                mod = node.module
+                for a in node.names:
+                    sub = module_file(mod + "." + a.name, files)
+                    if sub and not is_test(sub) and sub not in out:
+                        out.append(sub)
+            elif isinstance(node, ast.Import):
+                mod = node.names[0].name
+            if mod:
+                f = module_file(mod, files)
+                if f and not is_test(f) and f not in out and not f.endswith("__init__.py"):
+                    out.append(f)
+    return out, [], "fuse"
+
+
+_EXT = {}
+
+
+def prior_ext(row, res, repo):
+    """Lists another script stored (`--ext file.jsonl:files_key:defs_key`)."""
+    path, fkey, dkey = EXT_SPEC
+    if path not in _EXT:
+        _EXT[path] = {}
+        for line in open(path, encoding="utf-8"):
+            if line.strip():
+                r = json.loads(line)
+                if "error" not in r:
+                    _EXT[path][r["instance_id"]] = r
+    r = _EXT[path].get(row["instance_id"], {})
+    files = r.get(fkey, []) if fkey else []
+    defs = [tuple(d) for d in r.get(dkey, [])] if dkey else []
+    return files, defs, "fuse"
+
+
+EXT_SPEC = ("", "", "")
+PRIORS = {"ext": prior_ext, "codeonly": prior_codeonly, "traceback": prior_traceback, "repro": prior_repro,
+          "history": prior_history, "testlink": prior_testlink}
+
+
+# ---------------------------------------------------------------- scoring
+
+def rrf(lists, weights, k=60):
+    s = {}
+    for lst, w in zip(lists, weights):
+        for i, f in enumerate(lst):
+            s[f] = s.get(f, 0.0) + w / (k + i + 1)
+    return [f for f, _ in sorted(s.items(), key=lambda kv: -kv[1])]
+
+
+def func_hit(preds, gold, k):
+    top = preds[:k]
+    return int(all(any(same(p, g) for p in top) for g in gold))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--results", required=True)
+    ap.add_argument("--data", required=True)
+    ap.add_argument("--repos", required=True)
+    ap.add_argument("--prior", required=True, choices=sorted(PRIORS))
+    ap.add_argument("--weights", default="0.5,1,2,4")
+    ap.add_argument("--gold-cache", default="")
+    ap.add_argument("--halves", default="devset/dev-fast.json,devset/dev-rest.json")
+    ap.add_argument("--dump", default="", help="write per-instance votes (jsonl) for the engine port check")
+    ap.add_argument("--ci", action="store_true")
+    ap.add_argument("--within", type=int, default=0,
+                    help="keep only prior votes for files/functions already in the base top N (rerank, no new candidates)")
+    ap.add_argument("--ext", default="", help="file.jsonl:files_key:defs_key for --prior ext")
+    args = ap.parse_args()
+    if args.ext:
+        global EXT_SPEC
+        parts = args.ext.split(":")
+        EXT_SPEC = (":".join(parts[:-2]), parts[-2], parts[-1])
+
+    rows = {r["instance_id"]: r for r in json.load(open(args.data, encoding="utf-8"))}
+    res = [json.loads(l) for l in open(args.results, encoding="utf-8") if l.strip()]
+    res = [r for r in res if "error" not in r and r["instance_id"] in rows]
+    golds = load_gold(rows, [r["instance_id"] for r in res], args.repos, args.gold_cache)
+    halves = []
+    for h in args.halves.split(","):
+        ids = {r["instance_id"] for r in json.load(open(h, encoding="utf-8"))}
+        halves.append((os.path.basename(h).replace(".json", ""), ids))
+    halves.append(("all", {r["instance_id"] for r in res}))
+
+    prior = PRIORS[args.prior]
+    weights = [float(w) for w in args.weights.split(",")]
+    variants = {"base": {}, **{f"w={w:g}": {} for w in weights}}
+    fired = 0
+    dump = open(args.dump, "w", encoding="utf-8") if args.dump else None
+    for r in res:
+        row = rows[r["instance_id"]]
+        repo = Repo(os.path.join(args.repos, row["repo"].split("/")[1]), row["base_commit"])
+        files = r.get("loc_files") or []
+        funcs = [(d["path"], d["name"]) for d in r.get("definitions", [])]
+        pf, pfun, mode = prior(row, r, repo)
+        if args.within and mode == "fuse":
+            top_f, top_fun = set(files[:args.within]), set(funcs[:args.within])
+            pf = [f for f in pf if f in top_f]
+            pfun = [f for f in pfun if f in top_fun]
+        if pf or pfun:
+            fired += 1
+        if dump:
+            dump.write(json.dumps({"instance_id": r["instance_id"], "files": pf, "funcs": pfun}) + "\n")
+        variants["base"][r["instance_id"]] = (files, funcs)
+        for w in weights:
+            if mode == "replace":
+                nf = files if pf is None else pf
+                nfun = funcs if pfun is None else pfun
+            else:
+                nf = rrf([files, pf], [1.0, w]) if pf else files
+                nfun = rrf([funcs, pfun], [1.0, w]) if pfun else funcs
+            variants[f"w={w:g}"][r["instance_id"]] = (nf, nfun)
+    print(f"prior {args.prior}: fired on {fired} of {len(res)}")
+    for name, ids in halves:
+        fg = [i for i in ids if i in variants["base"]]
+        fung = [i for i in fg if golds.get(i)]
+        print(f"-- {name}: {len(fg)} issues, {len(fung)} with function gold")
+        for v, lists in variants.items():
+            fa = {k: [acc(lists[i][0], rows_gold(r_by_id(res, i)), k) for i in fg] for k in (1, 3, 5, 10)}
+            fu = {k: [func_hit(lists[i][1], golds[i], k) for i in fung] for k in (1, 5, 10)}
+            cell = "  ".join(f"@{k} {sum(fa[k]) / max(len(fg), 1):.3f}" for k in (1, 3, 5, 10))
+            cell += "  | func " + "  ".join(f"@{k} {sum(fu[k]) / max(len(fung), 1):.3f}" for k in (1, 5, 10))
+            if args.ci and v == "base":
+                lo, hi = boot_ci(fa[1])
+                cell += f"  (file@1 CI [{lo:.2f},{hi:.2f}])"
+            print(f"   {v:8s} {cell}")
+
+
+_BY_ID = {}
+
+
+def r_by_id(res, iid):
+    if not _BY_ID:
+        _BY_ID.update({r["instance_id"]: r for r in res})
+    return _BY_ID[iid]
+
+
+def rows_gold(r):
+    return [g.replace("\\", "/") for g in r["gold"]]
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/swebench_localize.py b/scripts/swebench_localize.py
index eee1b4a..2b2b400 100644
--- a/scripts/swebench_localize.py
+++ b/scripts/swebench_localize.py
@@ -122,6 +122,9 @@ def _main():
     ap.add_argument("--only", default="", help="comma-separated repos to keep")
     ap.add_argument("--shard", default="", help="i/n: this process takes every n-th instance starting at i")
     ap.add_argument("--work", default=os.path.join(tempfile.gettempdir(), "swe-wt"))
+    ap.add_argument("--no-bm25", action="store_true",
+                    help="skip the Python BM25 baseline (it does not change between engine runs and "
+                         "costs more CPU than the engine on large checkouts)")
     args = ap.parse_args()
     _ARGS["args"] = args
 
@@ -164,6 +167,8 @@ def _main():
                 )
                 if pkt.get("definitions"):
                     rec["definitions"] = pkt["definitions"]
+                if pkt.get("diag_definitions"):
+                    rec["diag_definitions"] = pkt["diag_definitions"]
                 loc = pkt.get("localization") or []
                 if loc:
                     rec["loc_files"] = loc
@@ -171,8 +176,9 @@ def _main():
                 ranked = pkt.get("ranked_paths") or []
                 if ranked:
                     rec.update(**{f"bm25f_hit@{k}": hit(ranked, gold, k) for k in (1, 3, 5, 10)})
-                bm = Bm25(dest, repo_files(dest)).rank(row["problem_statement"])
-                rec.update(**{f"bm25_hit@{k}": hit(bm, gold, k) for k in (1, 3, 5, 10)})
+                if not args.no_bm25:
+                    bm = Bm25(dest, repo_files(dest)).rank(row["problem_statement"])
+                    rec.update(**{f"bm25_hit@{k}": hit(bm, gold, k) for k in (1, 3, 5, 10)})
             except Exception as e:  # recorded, not fatal: one bad checkout must not stop the run
                 rec["error"] = str(e)[-300:]
             out.write(json.dumps(rec) + "\n")
diff --git a/tests/third_party/concept-holdout5/jsoup/gold_tasks.toml b/tests/third_party/concept-holdout5/jsoup/gold_tasks.toml
new file mode 100644
index 0000000..a63ae32
--- /dev/null
+++ b/tests/third_party/concept-holdout5/jsoup/gold_tasks.toml
@@ -0,0 +1,87 @@
+# Locked 2026-10-10 before any engine run on jsoup. Plain-language
+# questions only; gold from reading the source (grep-checked).
+
+[[task]]
+id = "js_clean_untrusted"
+prompt = "How does it strip tags and attributes that are not allowed from untrusted HTML, keeping only safe markup?"
+gold_files = ["src/main/java/org/jsoup/safety/Cleaner.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_allowed_presets"
+prompt = "Where are the sets of tags and attributes that may survive sanitising defined, including the ready-made basic and relaxed presets?"
+gold_files = ["src/main/java/org/jsoup/safety/Safelist.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_detect_encoding"
+prompt = "When a downloaded page does not declare its character encoding in the HTTP headers, how is the encoding worked out from the bytes or a meta tag?"
+gold_files = ["src/main/java/org/jsoup/helper/DataUtil.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_escape_output"
+prompt = "When writing a document back out as HTML, how are special characters like less-than signs or non-breaking spaces turned into named or numeric references?"
+gold_files = ["src/main/java/org/jsoup/nodes/Entities.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_css_query"
+prompt = "How is a CSS-style query such as div > p.intro turned into something that can match elements?"
+gold_files = ["src/main/java/org/jsoup/select/QueryParser.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_cookies"
+prompt = "How are cookies attached to an outgoing request and saved from the headers of the response?"
+gold_files = ["src/main/java/org/jsoup/helper/CookieUtil.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_redirects"
+prompt = "How does fetching a URL follow redirects, and what limits the number of hops?"
+gold_files = ["src/main/java/org/jsoup/helper/HttpConnection.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_walk_tree"
+prompt = "How does it visit every node under a root depth-first, calling back when entering and leaving each node, without recursion?"
+gold_files = ["src/main/java/org/jsoup/select/NodeTraversor.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_to_w3c"
+prompt = "How can a parsed document be converted into a standard W3C DOM document, for example to run XPath over it?"
+gold_files = ["src/main/java/org/jsoup/helper/W3CDom.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_read_chars"
+prompt = "How is the input text read character by character with lookahead and buffering while tokenising?"
+gold_files = ["src/main/java/org/jsoup/parser/CharacterReader.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_form_submit"
+prompt = "How are the fields of an HTML form gathered into name and value pairs ready to submit?"
+gold_files = ["src/main/java/org/jsoup/nodes/FormElement.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
+[[task]]
+id = "js_url_normalize"
+prompt = "Before connecting, how is a URL that contains spaces or non-ASCII characters made safe to request?"
+gold_files = ["src/main/java/org/jsoup/helper/UrlBuilder.java"]
+forbidden_files = []
+expect_seeds_missed = false
+
diff --git a/tests/third_party/concept-holdout5/repos.toml b/tests/third_party/concept-holdout5/repos.toml
new file mode 100644
index 0000000..70f8795
--- /dev/null
+++ b/tests/third_party/concept-holdout5/repos.toml
@@ -0,0 +1,11 @@
+# Fifth plain-language holdout (2026-10-10), Java: written to confirm the
+# short-question list fusion (S1) and any session-18 change on a language and
+# repository never run before. Gold written from reading the source before any
+# engine run; locked by this commit.
+#
+#   jsoup — jhy/jsoup 1.18.1: HTML parser, cleaner and HTTP client for Java
+
+[[repo]]
+name = "jsoup"
+url = "https://github.com/jhy/jsoup"
+rev = "19e8539fbfae80432fc4d8e9b562a39f786f547e"