fix: resolve merge conflicts with main (docs check acknowledged)

Owned scope confirmed via this PR's own single commit diff-stat: the
typeOnlyNames sparse field on Import (types.ts/types.rs) and its
propagation through both extractors (javascript.ts/javascript.rs),
both JS edge-building paths (build-edges.ts/incremental.ts, relocated
to the shared import-utils.ts importNamePairs since that extraction
landed on main after this branch was cut), the native FFI pipeline
(build_edges.rs), the pure-native pipeline (import_edges.rs), and
pipeline.rs's tuple-destructure call site all merged in cleanly
alongside main's independent changes (barrel-reachability, #1849
wildcard-reexport, #1781 satisfies_expression, #1930 value-ref filter
docs, and this branch's own upstream #1812/#1957 hierarchy-edge
scoping fix). The remaining conflicting files were unrelated stack
noise, resolved by taking main's content.

All 11 owned files verified byte-exact against both this PR's own
diff (vs main) and main's independent additions (vs ORIG_HEAD).

Impact: 55 functions changed, 190 affected

Author: carlos-alm

.claude/skills/titan-grind/SKILL.md

@@ -109,7 +109,7 @@ Forge shapes the metal. Grind smooths the rough edges. Your goal: find helpers t
 
 12. **Capture dead-symbol baseline** (only if `grind.deadSymbolBaseline` is null):
     ```bash
-    codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count,byRole:data.summary}));})"
+    codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{try{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count??0,byRole:data.summary??{}}));}catch(e){console.error('Failed to parse roles --json output: '+e.message);process.exit(1);}})"
     ```
     `codegraph roles --json` returns `{ count, summary, symbols }` (not a bare array) — `summary` is already the per-role breakdown (e.g. `dead-leaf`, `dead-entry`, `dead-ffi`, `dead-unresolved`), so no manual reduce is needed.
     Store the total in `grind.deadSymbolBaseline`. Write `titan-state.json` immediately.
@@ -580,7 +580,7 @@ After all targets in the phase are processed:
 
 ```bash
 codegraph build
-codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count,byRole:data.summary}));})"
+codegraph roles --role dead -T --json | node -e "const d=[];process.stdin.on('data',c=>d.push(c));process.stdin.on('end',()=>{try{const data=JSON.parse(Buffer.concat(d));console.log(JSON.stringify({total:data.count??0,byRole:data.summary??{}}));}catch(e){console.error('Failed to parse roles --json output: '+e.message);process.exit(1);}})"
 ```
 
 Store in `grind.deadSymbolCurrent`. Write `titan-state.json`.

crates/codegraph-core/src/ast_analysis/complexity.rs

@@ -1748,6 +1748,22 @@ mod tests {
         assert_eq!(m.cyclomatic, 3);
     }
 
+    #[test]
+    fn lua_method_declaration() {
+        // Greptile follow-up to #1782: colon-syntax method declarations
+        // (`function Obj:method(x)`) have a `method_index_expression` name
+        // field but are still `function_declaration` nodes, so `function_nodes`
+        // already covers them — this pins that native/TS parity explicitly.
+        // Mirrors the TS test 'method declaration (colon syntax) is
+        // recognized as a function'.
+        let m = compute_lua(
+            "local Obj = {}\nfunction Obj:method(x)\n  if x > 0 then\n    return x\n  end\nend",
+        );
+        assert_eq!(m.cognitive, 1);
+        assert_eq!(m.cyclomatic, 2);
+        assert_eq!(m.max_nesting, 1);
+    }
+
     #[test]
     fn lua_nested_if() {
         let m = compute_lua(

crates/codegraph-core/src/db/connection.rs

@@ -880,10 +880,13 @@ impl NativeDatabase {
         let insert_ok = insert_nodes::do_insert_nodes(conn, &batches, &removed_files)
             .inspect_err(|e| eprintln!("[NativeDatabase] bulk_insert_nodes failed: {e}"))
             .is_ok();
+        if !insert_ok {
+            return Ok(false);
+        }
         let hashes_ok = insert_nodes::commit_file_hashes(conn, &file_hashes)
             .inspect_err(|e| eprintln!("[NativeDatabase] bulk_insert_nodes hash commit failed: {e}"))
             .is_ok();
-        Ok(insert_ok && hashes_ok)
+        Ok(hashes_ok)
     }
 
     /// Bulk-insert edge rows using chunked multi-value INSERT statements.

crates/codegraph-core/src/domain/graph/builder/stages/build_edges.rs

@@ -791,13 +791,14 @@ fn process_file<'a>(
         // of these positions is as likely to be a plain data reference
         // (`{ name: SOME_CONSTANT }`) as a real function/class, so drop any
         // other-kind match rather than fabricating a "calls" edge to a
-        // constant. `class` is included alongside function/method because
-        // `instanceof`'s right operand is always a class/constructor
-        // (#1784) — unlike the original #1771 object-literal case, which is
-        // function/method only. Applied once here (after all
-        // resolve_call_targets tiers), mirroring the
-        // `dynamicKind === 'value-ref'` filter in resolveFallbackTargets
-        // (stages/build-edges.ts).
+        // constant. `class` was added because `instanceof`'s right operand
+        // is always a class/constructor (#1784). The filter is keyed on
+        // `dynamic_kind`, not on which site produced the call, so the #1771
+        // object-literal and #1776 Lua sites also gain class-kind
+        // resolution as a side effect — not because either idiom commonly
+        // names a class. Applied once here (after all resolve_call_targets
+        // tiers), mirroring the `dynamicKind === 'value-ref'` filter in
+        // resolveFallbackTargets (stages/build-edges.ts).
         if call.dynamic_kind.as_deref() == Some("value-ref") {
             targets.retain(|t| t.kind == "function" || t.kind == "method" || t.kind == "class");
         }
@@ -837,7 +838,7 @@ fn process_file<'a>(
         }
     }
 
-    emit_hierarchy_edges(ctx, file_input, fc.rel_path, &fc.imported_names, edges);
+    emit_hierarchy_edges(ctx, file_input, fc.rel_path, &fc.imported_names, &fc.imported_original_names, edges);
 }
 
 /// Callable definition kinds — only function/method bodies act as enclosing
@@ -1381,7 +1382,11 @@ fn emit_receiver_edge(
 /// the graph regardless of file or language, producing false cross-file
 /// (even cross-language) hierarchy edges for common type names. Priority:
 /// 1. Same-file declaration, when `name` is not itself an import artifact.
-/// 2. The file's actually-resolved import for `name` (barrel-traced).
+/// 2. The file's actually-resolved import for `name` (barrel-traced). For a
+///    renamed import (`import { Base as MyBase }`), the imported file stores
+///    the symbol under its original exported name, not the local alias — so
+///    `imported_original_name` resolves `MyBase` back to `Base` before the
+///    lookup, mirroring `resolve_call_targets` (#1730).
 /// 3. Last resort: a same-language-family global-by-name match (#1783),
 ///    first candidate only — a heritage clause names exactly one type.
 fn resolve_hierarchy_targets<'a>(
@@ -1390,6 +1395,7 @@ fn resolve_hierarchy_targets<'a>(
     rel_path: &str,
     imported_names: &HashMap<&str, &str>,
     target_kinds: &[&str],
+    imported_original_names: &HashMap<&str, &str>,
 ) -> Vec<&'a NodeInfo> {
     let samefile_all: Vec<&NodeInfo> = ctx.nodes_by_name_and_file
         .get(&(name, rel_path))
@@ -1402,8 +1408,9 @@ fn resolve_hierarchy_targets<'a>(
     }
 
     if let Some(imported_from) = imported_names.get(name) {
+        let target_name = imported_original_names.get(name).copied().unwrap_or(name);
         let imported_candidates: Vec<&NodeInfo> = ctx.nodes_by_name_and_file
-            .get(&(name, *imported_from))
+            .get(&(target_name, *imported_from))
             .cloned().unwrap_or_default()
             .into_iter()
             .filter(|n| target_kinds.contains(&n.kind.as_str()))
@@ -1424,6 +1431,7 @@ fn resolve_hierarchy_targets<'a>(
 fn emit_hierarchy_edges(
     ctx: &EdgeContext, file_input: &FileEdgeInput, rel_path: &str,
     imported_names: &HashMap<&str, &str>,
+    imported_original_names: &HashMap<&str, &str>,
     edges: &mut Vec<ComputedEdge>,
 ) {
     for cls in &file_input.classes {
@@ -1434,7 +1442,7 @@ fn emit_hierarchy_edges(
         let Some(source) = source_row else { continue };
 
         if let Some(ref extends_name) = cls.extends {
-            let targets = resolve_hierarchy_targets(ctx, extends_name, rel_path, imported_names, EXTENDS_TARGET_KINDS);
+            let targets = resolve_hierarchy_targets(ctx, extends_name, rel_path, imported_names, EXTENDS_TARGET_KINDS, imported_original_names);
             for t in targets {
                 edges.push(ComputedEdge {
                     source_id: source.id, target_id: t.id,
@@ -1444,7 +1452,7 @@ fn emit_hierarchy_edges(
             }
         }
         if let Some(ref implements_name) = cls.implements {
-            let targets = resolve_hierarchy_targets(ctx, implements_name, rel_path, imported_names, IMPLEMENTS_TARGET_KINDS);
+            let targets = resolve_hierarchy_targets(ctx, implements_name, rel_path, imported_names, IMPLEMENTS_TARGET_KINDS, imported_original_names);
             for t in targets {
                 edges.push(ComputedEdge {
                     source_id: source.id, target_id: t.id,
@@ -1682,6 +1690,16 @@ fn has_type_only_names(imp: &ImportInfo) -> bool {
     imp.type_only || !imp.type_only_names.is_empty()
 }
 
+/// True for a genuine wildcard re-export (`export * from 'Y'`). Emitted as a
+/// distinct file-level marker edge (`reexports-wildcard`) alongside the
+/// generic `reexports` edge so the query layer can tell a target reached
+/// only by named specifiers apart from one that's also reached by a
+/// wildcard — even when a *different* statement in the same file names
+/// specific symbols from that exact target (#1849 review).
+fn is_wildcard_reexport(imp: &ImportInfo) -> bool {
+    imp.reexport && imp.wildcard_reexport
+}
+
 /// For a `type` import or a named re-export targeting a barrel or resolved
 /// file, emit one symbol-level edge per named symbol so the target symbols
 /// receive fan-in credit and aren't misclassified as dead code
@@ -1826,6 +1844,15 @@ fn process_single_import(
     }
     if is_named_reexport(imp) {
         emit_named_symbol_edges(edges, file_input, imp, resolved_path, "reexports", ctx);
+    } else if is_wildcard_reexport(imp) {
+        edges.push(ComputedEdge {
+            source_id: file_input.file_node_id,
+            target_id: target_node_id,
+            kind: "reexports-wildcard".to_string(),
+            confidence: 1.0,
+            dynamic: 0,
+            dynamic_kind: None,
+        });
     }
     emit_barrel_through_edges(edges, file_input, imp, resolved_path, edge_kind, ctx);
 }
@@ -1951,9 +1978,12 @@ mod import_edge_tests {
 
     #[test]
     fn wildcard_reexport_emits_no_symbol_level_edge() {
-        // `export * from './utils'` carries no specific names, so only the
-        // file-level `reexports` edge is emitted — the query layer falls
-        // back to the target's full export list for genuine wildcards.
+        // `export * from './utils'` carries no specific names, so no
+        // symbol-level edge is emitted. It does get the dedicated
+        // `reexports-wildcard` file-level marker (alongside the generic
+        // `reexports` edge) so the query layer can always apply full-export
+        // semantics for genuine wildcards, even when a *different* statement
+        // to the same target also names specific symbols (#1849 review).
         let files = vec![make_file("src/index.ts", 1, vec![
             ImportInfo {
                 source: "./utils".to_string(),
@@ -1982,9 +2012,62 @@ mod import_edge_tests {
             "/root".to_string(),
             Some(symbol_nodes),
         );
-        assert_eq!(edges.len(), 1);
+        assert_eq!(edges.len(), 2);
+        assert_eq!(edges[0].kind, "reexports");
+        assert_eq!(edges[0].target_id, 2);
+        assert_eq!(edges[1].kind, "reexports-wildcard");
+        assert_eq!(edges[1].target_id, 2);
+    }
+
+    #[test]
+    fn named_and_wildcard_reexport_of_same_target_both_marked() {
+        // `export { foo } from './utils'` AND `export * from './utils'` in
+        // the same file, both targeting utils.ts. The wildcard's full-export
+        // semantics must stay independently signalled (via the dedicated
+        // `reexports-wildcard` marker) rather than being suppressed by the
+        // named specifier's symbol-level edge — otherwise the query layer
+        // would report only `foo` and silently drop every other export of
+        // utils.ts that the wildcard was meant to surface (#1849 review).
+        let files = vec![make_file("src/index.ts", 1, vec![
+            make_import("./utils", vec!["foo"], true, false, false),
+            ImportInfo {
+                source: "./utils".to_string(),
+                names: vec![],
+                reexport: true,
+                type_only: false,
+                dynamic_import: false,
+                wildcard_reexport: true,
+                type_only_names: vec![],
+            },
+        ], vec![])];
+        let resolved = vec![make_resolved("/root/src/index.ts", "./utils", "src/utils.ts")];
+        let node_ids = vec![make_node_entry("src/index.ts", 1), make_node_entry("src/utils.ts", 2)];
+        let symbol_nodes = vec![SymbolNodeEntry {
+            name: "foo".to_string(),
+            file: "src/utils.ts".to_string(),
+            node_id: 99,
+        }];
+
+        let edges = build_import_edges(
+            files,
+            resolved,
+            vec![],
+            node_ids,
+            vec![],
+            "/root".to_string(),
+            Some(symbol_nodes),
+        );
+        assert_eq!(edges.len(), 4);
+        // Named statement: file-level `reexports` + symbol-level `reexports` to foo.
         assert_eq!(edges[0].kind, "reexports");
         assert_eq!(edges[0].target_id, 2);
+        assert_eq!(edges[1].kind, "reexports");
+        assert_eq!(edges[1].target_id, 99);
+        // Wildcard statement: file-level `reexports` + the `reexports-wildcard` marker.
+        assert_eq!(edges[2].kind, "reexports");
+        assert_eq!(edges[2].target_id, 2);
+        assert_eq!(edges[3].kind, "reexports-wildcard");
+        assert_eq!(edges[3].target_id, 2);
     }
 
     #[test]

crates/codegraph-core/src/domain/graph/builder/stages/import_edges.rs

@@ -289,6 +289,17 @@ fn is_named_reexport(imp: &crate::types::Import) -> bool {
     imp.reexport.unwrap_or(false) && !imp.wildcard_reexport.unwrap_or(false)
 }
 
+/// True for a genuine wildcard re-export (`export * from 'Y'`). Emitted as a
+/// distinct file-level marker edge (`reexports-wildcard`) alongside the
+/// generic `reexports` edge so the query layer can tell a target reached
+/// only by named specifiers apart from one that's also reached by a
+/// wildcard — even when a *different* statement in the same file names
+/// specific symbols from that exact target (#1849 review). Mirrors
+/// `is_wildcard_reexport` in build_edges.rs (FFI fallback path).
+fn is_wildcard_reexport(imp: &crate::types::Import) -> bool {
+    imp.reexport.unwrap_or(false) && imp.wildcard_reexport.unwrap_or(false)
+}
+
 /// Walk type-only imports and named re-exports in `ctx.file_symbols` and
 /// return the distinct `(name, file)` pairs that `build_import_edges` will
 /// need to look up. Resolves barrel files the same way the edge-building
@@ -484,6 +495,14 @@ fn emit_edges_for_import(
             ctx,
             symbol_node_ids,
         );
+    } else if is_wildcard_reexport(imp) {
+        edges.push(EdgeRow {
+            source_id: file_node_id,
+            target_id,
+            kind: "reexports-wildcard".to_string(),
+            confidence: 1.0,
+            dynamic: 0,
+        });
     }
     emit_barrel_through_rows(
         edges,

crates/codegraph-core/src/domain/graph/resolve.rs

@@ -260,6 +260,22 @@ fn ancestor_chain(dir: &str) -> Vec<String> {
     chain
 }
 
+// directory_distance is on the hot path for every call-edge confidence
+// score, invoked from inside compute_confidence's rayon `.par_iter()` caller
+// (line ~330 below). The same directory pairs recur constantly across a
+// build, so memoizing avoids rebuilding both ancestor chains and the lookup
+// map every call. Thread-local (not a shared Mutex/DashMap) because rayon's
+// worker pool is reused across the whole build — each worker accumulates its
+// own useful cache with zero lock contention, at the cost of some redundant
+// computation the first time a given pair is seen on each thread.
+// distance(a, b) === distance(b, a) (symmetric tree distance), so the key is
+// order-independent to halve the effective cache size per thread (#1769
+// perf regression).
+thread_local! {
+    static DIRECTORY_DISTANCE_CACHE: std::cell::RefCell<std::collections::HashMap<(String, String), usize>> =
+        std::cell::RefCell::new(std::collections::HashMap::new());
+}
+
 /// Directory-tree distance between two directories: hops up from `a` to the
 /// nearest ancestor shared with `b`, plus hops down from there to `b`.
 ///
@@ -272,14 +288,24 @@ fn ancestor_chain(dir: &str) -> Vec<String> {
 /// so e.g. a file in `graph/algorithms/*.rs` calling a method declared in
 /// the shallower `graph/model.rs` was scored as maximally distant (issue #1769).
 fn directory_distance(a: &str, b: &str) -> usize {
+    let key = if a <= b { (a.to_string(), b.to_string()) } else { (b.to_string(), a.to_string()) };
+    if let Some(cached) = DIRECTORY_DISTANCE_CACHE.with(|c| c.borrow().get(&key).copied()) {
+        return cached;
+    }
+
     let chain_a = ancestor_chain(a);
     let chain_b = ancestor_chain(b);
+    let index_in_b: std::collections::HashMap<&str, usize> =
+        chain_b.iter().enumerate().map(|(j, d)| (d.as_str(), j)).collect();
+    let mut dist = usize::MAX;
     for (i, dir_a) in chain_a.iter().enumerate() {
-        if let Some(j) = chain_b.iter().position(|dir_b| dir_b == dir_a) {
-            return i + j;
+        if let Some(&j) = index_in_b.get(dir_a.as_str()) {
+            dist = i + j;
+            break;
         }
     }
-    usize::MAX
+    DIRECTORY_DISTANCE_CACHE.with(|c| c.borrow_mut().insert(key, dist));
+    dist
 }
 
 /// Coarse "language family" for a file, derived from its extension via
@@ -291,8 +317,21 @@ fn directory_distance(a: &str, b: &str) -> usize {
 /// separate families would reject huge amounts of legitimate same-project
 /// resolution. Every other `LanguageKind` variant keeps its own family,
 /// preserving `from_extension`'s existing per-language extension groupings
-/// (e.g. C's `.c`+`.h`, C++'s `.cpp`/`.cc`/`.cxx`/`.hpp`).
+/// (e.g. C's `.c`+`.h`, C++'s `.cpp`/`.cc`/`.cxx`/`.hpp`) — EXCEPT `.h`,
+/// treated as ambiguous (returns `None`) rather than inheriting
+/// `from_extension`'s C-only mapping: `from_extension` needs one canonical
+/// grammar per extension, but a `.h` header is real-world ambiguous between
+/// C and C++, and the extremely common case of a `.cpp` file calling into
+/// its own project's `.h` header would otherwise be misclassified as
+/// cross-language and rejected outright — a real regression from the
+/// pre-#1783 same-directory score of 0.7 (Greptile review). This keeps the
+/// C/C++-header case working without merging C and C++ source-file families
+/// wholesale (`.c` vs `.cpp` intentionally do NOT merge — see
+/// is_same_language_family_does_not_merge_c_and_cpp).
 fn language_family(file: &str) -> Option<LanguageKind> {
+    if file.to_ascii_lowercase().ends_with(".h") {
+        return None;
+    }
     match LanguageKind::from_extension(file) {
         Some(LanguageKind::TypeScript) | Some(LanguageKind::Tsx) => Some(LanguageKind::JavaScript),
         other => other,
@@ -609,6 +648,15 @@ mod tests {
         assert!(is_same_language_family("src/a.c", "src/a.h"));
     }
 
+    #[test]
+    fn is_same_language_family_treats_h_as_ambiguous_with_cpp() {
+        // Greptile follow-up to #1783: `.h` is real-world ambiguous between C
+        // and C++ (LANGUAGE_REGISTRY/from_extension assigns it to C alone for
+        // grammar-selection purposes), so a `.cpp` file calling into its own
+        // project's `.h` header must not be rejected as cross-language.
+        assert!(is_same_language_family("src/widget.cpp", "src/widget.h"));
+    }
+
     #[test]
     fn is_same_language_family_merges_cpp_source_and_header_variants() {
         assert!(is_same_language_family("src/a.cpp", "src/a.hpp"));