fix: resolve merge conflicts with main

docs check acknowledged — conflict resolution only, no new functionality.

Impact: 47 functions changed, 175 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

@@ -1621,6 +1621,16 @@ fn is_named_reexport(imp: &ImportInfo) -> bool {
     imp.reexport && !imp.wildcard_reexport
 }
 
+/// 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
@@ -1755,6 +1765,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);
 }
@@ -1861,9 +1880,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(),
@@ -1891,9 +1913,61 @@ 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,
+            },
+        ], 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

@@ -266,6 +266,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
@@ -450,6 +461,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

crates/codegraph-core/src/extractors/javascript.rs

@@ -2333,6 +2333,11 @@ const HTTP_VERB_CALLEES: &[&str] = &[
 /// separate `CALLBACK_ACCEPTING_CALLEES` entry needed); only the arg at its
 /// listed index is eligible.
 ///
+/// Invariant: this map and `CALLBACK_ACCEPTING_CALLEES` must stay disjoint.
+/// A callee name present in both would have its any-position intent silently
+/// narrowed to the single listed index (positional wins — see the gate in
+/// `extract_callback_reference_calls`), with no error or warning.
+///
 /// Name-based, not receiver-typed, so it can't distinguish `Array.from(x,
 /// mapFn)` from an unrelated `.from(x, y)` shaped differently (e.g.
 /// `Buffer.from(data, encoding)`) — that residual risk is far narrower than
@@ -3033,13 +3038,19 @@ fn find_parent_class_no_fn_boundary(node: &Node, source: &[u8]) -> Option<String
 
 /// Wrapper node kinds that can sit between a dynamic `import()` call and its
 /// enclosing `variable_declarator` without changing which value gets bound —
-/// `await`, redundant parentheses, and TypeScript `as` casts. Real-world call
-/// sites often combine several of these, e.g.
+/// `await`, redundant parentheses, and TypeScript `as`/`satisfies` casts.
+/// Real-world call sites often combine several of these, e.g.
 /// `const { X } = (await import('./mod.js')) as { X: Fn }` nests
 /// await_expression → parenthesized_expression → as_expression before
-/// reaching the declarator (#1781).
-const DYNAMIC_IMPORT_WRAPPER_KINDS: &[&str] =
-    &["await_expression", "parenthesized_expression", "as_expression"];
+/// reaching the declarator (#1781). `satisfies_expression` (TS 4.9+
+/// `... satisfies { X: Fn }`) is structurally identical to `as_expression`
+/// here — Greptile follow-up, mirrors the TS extractor.
+const DYNAMIC_IMPORT_WRAPPER_KINDS: &[&str] = &[
+    "await_expression",
+    "parenthesized_expression",
+    "as_expression",
+    "satisfies_expression",
+];
 
 /// Extract named bindings from a dynamic `import()` call expression.
 /// Handles: `const { a, b } = await import(...)`, `const mod = await import(...)`,
@@ -4242,6 +4253,17 @@ mod tests {
         assert!(dyn_imports[0].names.contains(&"b".to_string()));
     }
 
+    #[test]
+    fn finds_dynamic_import_with_satisfies_cast_destructuring() {
+        // TS 4.9+ `satisfies` is structurally identical to `as` here (Greptile
+        // follow-up to #1781) — same walk-up gap would otherwise reproduce.
+        let s = parse_ts("const { a, b } = await import('./foo.js') satisfies { a: Fn; b: Fn };");
+        let dyn_imports: Vec<_> = s.imports.iter().filter(|i| i.dynamic_import == Some(true)).collect();
+        assert_eq!(dyn_imports.len(), 1);
+        assert!(dyn_imports[0].names.contains(&"a".to_string()));
+        assert!(dyn_imports[0].names.contains(&"b".to_string()));
+    }
+
     #[test]
     fn finds_dynamic_import_with_parenthesized_as_cast_destructuring() {
         // Exact repro shape from #1781 (native-orchestrator.ts):
@@ -4625,6 +4647,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn applies_array_from_positional_gate_to_member_expression_args_too() {
+        // Mirrors the TS test of the same intent: the old member_expression
+        // guard was an explicit `&& memberExprArgsAllowed` inline check; the
+        // positional restructuring moved that responsibility to the shared
+        // early-return above the loop. `Array.from(arr, obj.mapper)` exercises
+        // that a member_expression at the positional index (1) is still
+        // emitted with its receiver, while one at index 0 is not.
+        let s = parse_js("Array.from(arr, obj.mapper);");
+        assert!(
+            s.calls.iter().any(|c| c.dynamic == Some(true) && c.name == "mapper" && c.receiver.as_deref() == Some("obj")),
+            "Array.from(arr, obj.mapper) must emit mapper with receiver obj; got: {:?}",
+            s.calls,
+        );
+        assert!(
+            !s.calls.iter().any(|c| c.dynamic == Some(true) && c.name == "arr"),
+            "Array.from(arr, obj.mapper) must not emit `arr` (index 0); got: {:?}",
+            s.calls,
+        );
+
+        let s2 = parse_js("Array.from(obj.arrayLike, mapCallback);");
+        assert!(
+            !s2.calls.iter().any(|c| c.dynamic == Some(true) && c.name == "arrayLike"),
+            "Array.from(obj.arrayLike, mapCallback) must not emit `arrayLike` (index 0); got: {:?}",
+            s2.calls,
+        );
+        assert!(
+            s2.calls.iter().any(|c| c.dynamic == Some(true) && c.name == "mapCallback"),
+            "Array.from(obj.arrayLike, mapCallback) must emit mapCallback; got: {:?}",
+            s2.calls,
+        );
+    }
+
     #[test]
     fn no_dynamic_call_for_dynamic_import_arg() {
         // Parity with TS walk path: callback-reference extraction must be skipped