fix: resolve merge conflicts with main

docs check acknowledged — conflict resolution only, no new
functionality beyond what the original PRs already documented.

Impact: 43 functions changed, 162 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/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

@@ -1606,6 +1606,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
@@ -1740,6 +1750,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);
 }
@@ -1846,9 +1865,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(),
@@ -1876,9 +1898,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/extractors/javascript.rs

@@ -2327,6 +2327,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
@@ -4373,6 +4378,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

crates/codegraph-core/src/features/structure.rs

@@ -141,29 +141,42 @@ pub fn get_existing_file_count(conn: &Connection) -> i64 {
     .unwrap_or(0)
 }
 
-/// Directories connected to `dir` via a live import/imports-type edge in
-/// either direction — the cross-directory neighbours whose own fan-in/out
-/// may have shifted even though none of their files changed. Used by
+/// Files connected to `file` via a live import/imports-type edge in either
+/// direction — the cross-directory neighbours whose own fan-in/out may have
+/// shifted even though `file` is the only one that actually changed. Used by
 /// `refresh_affected_directory_metrics` to expand its affected-directory set
 /// by exactly one hop.
-fn find_neighbor_files(conn: &Connection, dir: &str) -> Vec<String> {
-    let lo = format!("{dir}/");
-    let hi = format!("{dir}0");
+///
+/// Scoped to the exact touched `file`, not its containing directory. An
+/// earlier version scoped this to the whole leaf directory (`dir >= x/ AND
+/// dir < x0`), which also pulled in edges belonging to unrelated sibling
+/// files that happen to live alongside `file` — harmless when the directory
+/// is small, but when the touched file sits in a widely-imported "hub"
+/// directory (e.g. `src/domain`, imported from dozens of unrelated
+/// directories via sibling files), that range scan discovers hundreds of
+/// neighbour files that have nothing to do with `file`'s own edges, which
+/// then balloon the affected-directory set to include broad, expensive-to-
+/// recompute ancestors like the repo-root `src` (measured: 251 neighbour
+/// files / 29 affected dirs for a single-file change to this repo's own
+/// `src/domain/queries.ts`, a ~55ms hit on the "1-file rebuild" benchmark —
+/// #1855). Scoping to the exact file preserves the cross-directory
+/// detection this function exists for (#1738) while only considering edges
+/// that could plausibly have changed as a result of editing `file` itself
+/// (251 -> 46 neighbour files / 29 -> 13 affected dirs for the same probe).
+fn find_neighbor_files(conn: &Connection, file: &str) -> Vec<String> {
     let mut stmt = match conn.prepare(
         "SELECT n2.file AS other FROM edges e \
            JOIN nodes n1 ON e.source_id = n1.id JOIN nodes n2 ON e.target_id = n2.id \
-           WHERE e.kind IN ('imports', 'imports-type') AND n1.file != n2.file \
-             AND n1.file >= ?1 AND n1.file < ?2 \
+           WHERE e.kind IN ('imports', 'imports-type') AND n1.file = ?1 AND n2.file != ?1 \
          UNION \
          SELECT n1.file AS other FROM edges e \
            JOIN nodes n1 ON e.source_id = n1.id JOIN nodes n2 ON e.target_id = n2.id \
-           WHERE e.kind IN ('imports', 'imports-type') AND n1.file != n2.file \
-             AND n2.file >= ?1 AND n2.file < ?2",
+           WHERE e.kind IN ('imports', 'imports-type') AND n2.file = ?1 AND n1.file != ?1",
     ) {
         Ok(s) => s,
         Err(_) => return Vec::new(),
     };
-    let result = match stmt.query_map(rusqlite::params![lo, hi], |row| row.get::<_, String>(0)) {
+    let result = match stmt.query_map(rusqlite::params![file], |row| row.get::<_, String>(0)) {
         Ok(rows) => rows.flatten().collect(),
         Err(_) => Vec::new(),
     };
@@ -181,14 +194,25 @@ fn find_neighbor_files(conn: &Connection, dir: &str) -> Vec<String> {
 ///
 /// This recomputes metrics for the ancestor directories of the files that
 /// changed in this build (added, removed, or modified), PLUS any directory
-/// reachable from them via a live cross-directory import edge — a changed
-/// file that gains (or loses) an import into a sibling package shifts that
-/// package's fan-in/fan-out/cohesion even though none of its own files were
-/// touched. One level of expansion only (mirrors the neighbour-expansion
-/// `classifyNodeRolesIncremental`/`do_classify_incremental` already does for
-/// role classification) — bounded by (changed files × path depth) rather
-/// than the size of the repo, so it stays cheap enough to run
-/// unconditionally alongside the fast path.
+/// reachable from the touched files' *immediate* (most specific) directory
+/// via a live cross-directory import edge — a changed file that gains (or
+/// loses) an import into a sibling package shifts that package's
+/// fan-in/fan-out/cohesion even though none of its own files were touched.
+///
+/// The neighbor-discovery step is seeded from each touched file itself, not
+/// from every ancestor up to root, and not from the touched file's whole
+/// containing directory either — `find_neighbor_files` is now bounded by the
+/// import edges attached to that ONE file. Seeding from every ancestor
+/// turned a single touched file into 50+ affected directories on this
+/// repo's own `src/` tree — a measured 70-90ms hit on the "1-file rebuild"
+/// benchmark (#1738 follow-up). Seeding from the touched file's *directory*
+/// (an intermediate fix) was still broad enough to pull in unrelated
+/// sibling files' edges whenever that directory was itself a widely-
+/// imported hub (e.g. `src/domain`) — measured 251 neighbour files / 29
+/// affected dirs (~55ms) for a single-file change there, cut to 46 / 13 by
+/// scoping to the exact file (#1855). Ancestor rollup (ancestors' own
+/// aggregates still get recomputed) is unaffected; only the expensive
+/// cross-directory neighbor lookup is scoped down.
 ///
 /// Removed files need no edge/node cleanup of their own — the purge step
 /// already deleted their nodes and every edge referencing them (including
@@ -211,9 +235,14 @@ pub fn refresh_affected_directory_metrics(
         return;
     }
 
-    let seed_dirs: Vec<String> = affected_dirs.iter().cloned().collect();
-    for dir in &seed_dirs {
-        let neighbor_files = find_neighbor_files(conn, dir);
+    // Seed neighbor-discovery from each touched file individually — NOT its
+    // containing directory, and NOT every entry in `affected_dirs` (which
+    // includes the full ancestor chain up to root). See the function doc
+    // comment: expanding from a broad ancestor like `src`, or from every
+    // sibling in the touched file's own directory, is effectively repo-wide
+    // whenever that directory is a widely-imported hub.
+    for file in &touched {
+        let neighbor_files = find_neighbor_files(conn, file);
         for ancestor in get_ancestor_dirs(&neighbor_files) {
             affected_dirs.insert(ancestor);
         }

crates/codegraph-core/src/graph/algorithms/louvain.rs

@@ -148,18 +148,21 @@ fn local_move_phase(
     }
 
     let mut any_moved = false;
+    // BTreeMap (not HashMap) so the best-move scan below visits candidate
+    // communities in a fixed, deterministic order — otherwise a genuine tie
+    // in `gain` would be broken by Rust's per-process-randomized HashMap
+    // iteration order instead of a reproducible rule (#1734). Hoisted out of
+    // the node loop and cleared per-iteration instead of reallocated, since
+    // `cur_n * LOUVAIN_MAX_PASSES` fresh allocations would otherwise show up
+    // on very high-degree hub nodes.
+    let mut comm_w: BTreeMap<usize, f64> = BTreeMap::new();
     for _pass in 0..LOUVAIN_MAX_PASSES {
         let mut pass_moved = false;
         for &node in &order {
             let node_comm = level_comm[node];
             let node_deg = state.cur_degree[node];
 
-            // BTreeMap (not HashMap) so the best-move scan below visits
-            // candidate communities in a fixed, deterministic order —
-            // otherwise a genuine tie in `gain` would be broken by Rust's
-            // per-process-randomized HashMap iteration order instead of a
-            // reproducible rule (#1734).
-            let mut comm_w: BTreeMap<usize, f64> = BTreeMap::new();
+            comm_w.clear();
             for &(neighbor, w) in &adj[node] {
                 *comm_w.entry(level_comm[neighbor]).or_insert(0.0) += w;
             }