diff --git a/crates/codegraph-core/src/db/repository/graph_read.rs b/crates/codegraph-core/src/db/repository/graph_read.rs
index b55bec051..5f36382e8 100644
--- a/crates/codegraph-core/src/db/repository/graph_read.rs
+++ b/crates/codegraph-core/src/db/repository/graph_read.rs
@@ -28,6 +28,41 @@ fn escape_like(s: &str) -> String {
     out
 }
 
+/// Append an `AND (col LIKE ? [OR col LIKE ? ...])` fragment for a multi-value
+/// file filter and push the corresponding escaped LIKE params. Mirrors
+/// `buildFileConditionSQL()` / `NodeQuery.fileFilter()` in
+/// `src/db/query-builder.ts`, which is why callers must accept `Vec<String>`
+/// (repeatable `-f/--file`) rather than a single `String`. No-op when `files`
+/// is empty. Advances `*idx` past the placeholders it consumes.
+fn push_file_filter(
+    sql: &mut String,
+    params_v: &mut Vec<Box<dyn rusqlite::types::ToSql>>,
+    idx: &mut usize,
+    column: &str,
+    files: &[String],
+) {
+    if files.is_empty() {
+        return;
+    }
+    let start = *idx;
+    if files.len() == 1 {
+        sql.push_str(&format!(" AND {column} LIKE ?{start} ESCAPE '\\'"));
+        params_v.push(Box::new(format!("%{}%", escape_like(&files[0]))));
+        *idx += 1;
+        return;
+    }
+    let clauses: Vec<String> = files
+        .iter()
+        .enumerate()
+        .map(|(i, _)| format!("{column} LIKE ?{} ESCAPE '\\'", start + i))
+        .collect();
+    sql.push_str(&format!(" AND ({})", clauses.join(" OR ")));
+    for f in files {
+        params_v.push(Box::new(format!("%{}%", escape_like(f))));
+    }
+    *idx += files.len();
+}
+
 /// Check if a file path looks like a test file (mirrors `isTestFile` in JS).
 fn is_test_file(file: &str) -> bool {
     file.contains(".test.")
@@ -143,7 +178,7 @@ struct FnDepsCallerWithId {
 fn build_fn_deps_match_query(
     name: &str,
     kind: Option<&str>,
-    file: Option<&str>,
+    file: Option<&[String]>,
 ) -> (String, Vec<Box<dyn rusqlite::types::ToSql>>) {
     let default_kinds: Vec<String> = vec![
         "function".to_string(),
@@ -180,8 +215,7 @@ fn build_fn_deps_match_query(
         idx += kinds.len();
     }
     if let Some(f) = file {
-        sql.push_str(&format!(" AND n.file LIKE ?{idx} ESCAPE '\\'"));
-        params_v.push(Box::new(format!("%{}%", escape_like(f))));
+        push_file_filter(&mut sql, &mut params_v, &mut idx, "n.file", f);
     }
 
     (sql, params_v)
@@ -1086,7 +1120,7 @@ impl NativeDatabase {
         &self,
         name_pattern: String,
         kinds: Option<Vec<String>>,
-        file: Option<String>,
+        file: Option<Vec<String>>,
     ) -> napi::Result<Vec<NativeNodeRowWithFanIn>> {
         let conn = self.conn()?;
 
@@ -1112,8 +1146,7 @@ impl NativeDatabase {
             }
         }
         if let Some(ref f) = file {
-            sql.push_str(&format!(" AND n.file LIKE ?{idx} ESCAPE '\\'"));
-            param_values.push(Box::new(format!("%{}%", escape_like(f))));
+            push_file_filter(&mut sql, &mut param_values, &mut idx, "n.file", f);
         }
 
         let mut stmt = conn
@@ -2114,7 +2147,7 @@ impl NativeDatabase {
         name: String,
         depth: Option<i32>,
         no_tests: Option<bool>,
-        file: Option<String>,
+        file: Option<Vec<String>>,
         kind: Option<String>,
     ) -> napi::Result<FnDepsResult> {
         let conn = self.conn()?;
diff --git a/crates/codegraph-core/src/graph/classifiers/roles.rs b/crates/codegraph-core/src/graph/classifiers/roles.rs
index c45184650..1b45f03bc 100644
--- a/crates/codegraph-core/src/graph/classifiers/roles.rs
+++ b/crates/codegraph-core/src/graph/classifiers/roles.rs
@@ -106,6 +106,55 @@ fn median(sorted: &[u32]) -> f64 {
     }
 }
 
+/// Compute, per file, the set of symbol names that are `TYPE_DEF_KINDS`-kind
+/// declarations (interface/type/struct/enum/trait/record). Mirrors JS
+/// `computeTypeDefNamesByFile` in `graph/classifiers/roles.ts`.
+fn compute_type_def_names_by_file(
+    rows: &[(i64, String, String, String, u32, u32)],
+) -> HashMap<String, std::collections::HashSet<String>> {
+    let mut by_file: HashMap<String, std::collections::HashSet<String>> = HashMap::new();
+    for (_id, name, kind, file, _fan_in, _fan_out) in rows {
+        if TYPE_DEF_KINDS.iter().any(|k| *k == kind.as_str()) {
+            by_file
+                .entry(file.clone())
+                .or_default()
+                .insert(name.clone());
+        }
+    }
+    by_file
+}
+
+/// True when `name`/`kind` is a `method`/`property` member of an interface/type
+/// declared in the same file — e.g. TS `interface Foo { bar: string }` extracts
+/// `bar` as a top-level `method`-kind definition named `Foo.bar` (#1723). Every
+/// language extractor qualifies interface/type members as `Owner.member`
+/// (mirroring class method qualification), so the owner name is recovered from
+/// the prefix before the first `.` and looked up against same-file
+/// `TYPE_DEF_KINDS` declarations. Class methods use the identical `Owner.member`
+/// convention but are unaffected here because `class` is not in `TYPE_DEF_KINDS`
+/// — they remain subject to normal dead-code detection.
+///
+/// These members can never gain inbound call edges by construction, so a
+/// `fan_in == 0` reading carries zero dead-code signal for them, unlike a real
+/// function/method where it does. Mirrors JS `isTypeDeclarationMember`.
+fn is_type_declaration_member(
+    name: &str,
+    kind: &str,
+    file: &str,
+    type_def_names_by_file: &HashMap<String, std::collections::HashSet<String>>,
+) -> bool {
+    if kind != "method" && kind != "property" {
+        return false;
+    }
+    let Some(dot_idx) = name.find('.') else {
+        return false;
+    };
+    let owner_name = &name[..dot_idx];
+    type_def_names_by_file
+        .get(file)
+        .is_some_and(|names| names.contains(owner_name))
+}
+
 /// Dead sub-role classification matching JS `classifyDeadSubRole`.
 fn classify_dead_sub_role(_name: &str, kind: &str, file: &str) -> &'static str {
     // Leaf kinds
@@ -126,6 +175,7 @@ fn classify_dead_sub_role(_name: &str, kind: &str, file: &str) -> &'static str {
 }
 
 /// Classify a single node into a role.
+#[allow(clippy::too_many_arguments)]
 fn classify_node(
     name: &str,
     kind: &str,
@@ -135,9 +185,16 @@ fn classify_node(
     is_exported: bool,
     production_fan_in: u32,
     has_active_file_siblings: bool,
+    is_type_member: bool,
     median_fan_in: f64,
     median_fan_out: f64,
 ) -> &'static str {
+    // Interface/type members (#1723) — never subject to call-graph dead-code
+    // detection, regardless of fan-in/fan-out/export status.
+    if is_type_member {
+        return "leaf";
+    }
+
     // Framework entry
     if FRAMEWORK_ENTRY_PREFIXES.iter().any(|p| name.starts_with(p)) {
         return "entry";
@@ -267,10 +324,14 @@ pub(crate) fn do_classify_full(conn: &Connection) -> rusqlite::Result<RoleSummar
     let tx = conn.unchecked_transaction()?;
     let mut summary = RoleSummary::default();
 
-    // 1. Leaf kinds -> dead-leaf
+    // 1. Property kind (class/struct fields) -> dead-leaf.
+    // `parameter` is deliberately NOT included here (#1723): a parameter's liveness
+    // is a local dataflow question, not a call-graph reachability question, so
+    // "no incoming call edges" carries zero dead-code signal for it. Parameters are
+    // also excluded from the main rows query below, so they never receive a role
+    // at all — the same treatment as `file`/`directory` nodes.
     let leaf_ids: Vec<i64> = {
-        let mut stmt =
-            tx.prepare("SELECT id FROM nodes WHERE kind IN ('parameter', 'property')")?;
+        let mut stmt = tx.prepare("SELECT id FROM nodes WHERE kind = 'property'")?;
         let rows = stmt.query_map([], |row| row.get::<_, i64>(0))?;
         rows.filter_map(|r| r.ok()).collect()
     };
@@ -408,6 +469,11 @@ pub(crate) fn do_classify_full(conn: &Connection) -> rusqlite::Result<RoleSummar
     // 5b. Compute active files (files with non-constant callables connected to the graph)
     let (active_files, called_active_files) = compute_active_files(&rows);
 
+    // 5c. Compute interface/type owner names per file (#1723) — used to recognize
+    // method/property members of type-level declarations, which must never be
+    // judged dead by call-graph reachability.
+    let type_def_names_by_file = compute_type_def_names_by_file(&rows);
+
     // 6. Classify and collect IDs by role
     let mut ids_by_role: HashMap<&str, Vec<i64>> = HashMap::new();
 
@@ -423,6 +489,7 @@ pub(crate) fn do_classify_full(conn: &Connection) -> rusqlite::Result<RoleSummar
         &prod_fan_in,
         &active_files,
         &called_active_files,
+        &type_def_names_by_file,
         median_fan_in,
         median_fan_out,
         &mut ids_by_role,
@@ -541,12 +608,14 @@ fn query_id_counts(
 }
 
 /// Classify rows and accumulate into ids_by_role and summary.
+#[allow(clippy::too_many_arguments)]
 fn classify_rows(
     rows: &[(i64, String, String, String, u32, u32)],
     exported_ids: &std::collections::HashSet<i64>,
     prod_fan_in: &HashMap<i64, u32>,
     active_files: &std::collections::HashSet<String>,
     called_active_files: &std::collections::HashSet<String>,
+    type_def_names_by_file: &HashMap<String, std::collections::HashSet<String>>,
     median_fan_in: f64,
     median_fan_out: f64,
     ids_by_role: &mut HashMap<&'static str, Vec<i64>>,
@@ -573,6 +642,7 @@ fn classify_rows(
         } else {
             false
         };
+        let is_type_member = is_type_declaration_member(name, kind, file, type_def_names_by_file);
         let role = classify_node(
             name,
             kind,
@@ -582,6 +652,7 @@ fn classify_rows(
             is_exported,
             prod_fi,
             has_active_siblings,
+            is_type_member,
             median_fan_in,
             median_fan_out,
         );
@@ -629,16 +700,15 @@ fn find_neighbour_files(
 }
 
 /// Query leaf kind node IDs and callable node rows for a set of files.
+/// `parameter` is intentionally excluded from the leaf query (#1723) — see
+/// `do_classify_full`'s leaf_ids comment for the rationale.
 fn query_nodes_for_files(
     tx: &rusqlite::Transaction,
     files: &[&str],
 ) -> rusqlite::Result<(Vec<i64>, Vec<(i64, String, String, String, u32, u32)>)> {
     let ph: String = files.iter().map(|_| "?").collect::<Vec<_>>().join(",");
 
-    let leaf_sql = format!(
-        "SELECT id FROM nodes WHERE kind IN ('parameter', 'property') AND file IN ({})",
-        ph
-    );
+    let leaf_sql = format!("SELECT id FROM nodes WHERE kind = 'property' AND file IN ({})", ph);
     let leaf_ids: Vec<i64> = {
         let mut stmt = tx.prepare(&leaf_sql)?;
         for (i, f) in files.iter().enumerate() {
@@ -804,6 +874,9 @@ pub(crate) fn do_classify_incremental(
 
     let (active_files, called_active_files) = compute_active_files(&rows);
 
+    // Compute interface/type owner names per file (#1723) — see do_classify_full.
+    let type_def_names_by_file = compute_type_def_names_by_file(&rows);
+
     let mut ids_by_role: HashMap<&str, Vec<i64>> = HashMap::new();
 
     if !leaf_ids.is_empty() {
@@ -818,6 +891,7 @@ pub(crate) fn do_classify_incremental(
         &prod_fan_in,
         &active_files,
         &called_active_files,
+        &type_def_names_by_file,
         median_fan_in,
         median_fan_out,
         &mut ids_by_role,
diff --git a/src/db/repository/base.ts b/src/db/repository/base.ts
index 4c1546c2e..9ab137a86 100644
--- a/src/db/repository/base.ts
+++ b/src/db/repository/base.ts
@@ -231,7 +231,7 @@ export class Repository implements IRepository {
    */
   fnDeps(
     _name: string,
-    _opts?: { depth?: number; noTests?: boolean; file?: string; kind?: string },
+    _opts?: { depth?: number; noTests?: boolean; file?: string | string[]; kind?: string },
   ): FnDepsResult | null {
     return null;
   }
diff --git a/src/db/repository/native-repository.ts b/src/db/repository/native-repository.ts
index a822c6912..a6a35ad4e 100644
--- a/src/db/repository/native-repository.ts
+++ b/src/db/repository/native-repository.ts
@@ -9,6 +9,7 @@
  */
 
 import Database from 'better-sqlite3';
+import { warn } from '../../infrastructure/logger.js';
 import { ConfigError } from '../../shared/errors.js';
 import type {
   AdjacentEdgeRow,
@@ -45,6 +46,7 @@ import type {
   TriageNodeRow,
   TriageQueryOpts,
 } from '../../types.js';
+import { normalizeFileFilter } from '../query-builder.js';
 import {
   type FnDepsCallerNode,
   type FnDepsEntry,
@@ -267,8 +269,9 @@ export class NativeRepository extends Repository {
   }
 
   findNodesWithFanIn(namePattern: string, opts: QueryOpts = {}): NodeRowWithFanIn[] {
+    const files = normalizeFileFilter(opts.file);
     return this.#ndb
-      .findNodesWithFanIn(namePattern, opts.kinds ?? null, opts.file ?? null)
+      .findNodesWithFanIn(namePattern, opts.kinds ?? null, files.length > 0 ? files : null)
       .map(toNodeRowWithFanIn);
   }
 
@@ -301,9 +304,19 @@ export class NativeRepository extends Repository {
   }
 
   findNodesByScope(scopeName: string, opts: QueryOpts = {}): NodeRow[] {
-    return this.#ndb
-      .findNodesByScope(scopeName, opts.kind ?? null, opts.file ?? null)
-      .map(toNodeRow);
+    // Unlike findNodesWithFanIn/fnDeps, this native binding only accepts a single
+    // file (no CLI command currently wires -f/--file to it); take the first value
+    // rather than crash if a caller ever passes the repeatable-flag array form.
+    // TODO(#1815): widen the native binding to Vec<String> so multi-file scoping
+    // isn't silently truncated once a caller wires -f/--file to this method.
+    const files = normalizeFileFilter(opts.file);
+    if (files.length > 1) {
+      warn(
+        `findNodesByScope: received ${files.length} files, only using the first ("${files[0]}") — multi-file scoping not yet supported natively (see #1815)`,
+      );
+    }
+    const [file] = files;
+    return this.#ndb.findNodesByScope(scopeName, opts.kind ?? null, file ?? null).map(toNodeRow);
   }
 
   findNodeByQualifiedName(qualifiedName: string, opts: { file?: string } = {}): NodeRow[] {
@@ -526,14 +539,15 @@ export class NativeRepository extends Repository {
   // ── Composite queries ──────────────────────────────────────────────
   fnDeps(
     name: string,
-    opts?: { depth?: number; noTests?: boolean; file?: string; kind?: string },
+    opts?: { depth?: number; noTests?: boolean; file?: string | string[]; kind?: string },
   ): FnDepsResult | null {
     if (typeof this.#ndb.fnDeps !== 'function') return null;
+    const files = normalizeFileFilter(opts?.file);
     const raw = this.#ndb.fnDeps(
       name,
       opts?.depth ?? undefined,
       opts?.noTests ?? undefined,
-      opts?.file ?? undefined,
+      files.length > 0 ? files : undefined,
       opts?.kind ?? undefined,
     );
     // Convert from native format (transitive_callers as array of groups)
diff --git a/src/domain/analysis/dependencies.ts b/src/domain/analysis/dependencies.ts
index 4a759e6e1..e602f0ab6 100644
--- a/src/domain/analysis/dependencies.ts
+++ b/src/domain/analysis/dependencies.ts
@@ -175,7 +175,7 @@ export function fnDepsData(
   opts: {
     depth?: number;
     noTests?: boolean;
-    file?: string;
+    file?: string | string[];
     kind?: string;
     limit?: number;
     offset?: number;
diff --git a/src/domain/analysis/exports.ts b/src/domain/analysis/exports.ts
index 62f97c434..3c9710df6 100644
--- a/src/domain/analysis/exports.ts
+++ b/src/domain/analysis/exports.ts
@@ -164,11 +164,24 @@ function exportsFileImpl(
         "SELECT * FROM nodes WHERE file = ? AND kind != 'file' AND exported = 1 ORDER BY line",
       )
     : null;
+  // Consumers include real call/construct edges plus `imports-type` edges —
+  // the symbol-level edge emitted for `import type { X }` statements (source
+  // is the importing *file* node, since the import statement references the
+  // type rather than a specific function). Without this, interfaces/types
+  // that are only ever used as type annotations are misclassified as dead
+  // exports even though `codegraph deps` already reports the importing file
+  // via this same edge (#1724).
+  //
+  // `extends`/`implements` edges are deliberately NOT included here: they are
+  // resolved by symbol name only, with no file/import scoping (see
+  // buildClassHierarchyEdges), so they can link same-named declarations
+  // across unrelated files — crediting them as consumers would surface false
+  // positives instead of fixing false negatives.
   const consumersStmt = cachedStmt(
     _consumersStmtCache,
     db,
     `SELECT n.name, n.file, n.line FROM edges e JOIN nodes n ON e.source_id = n.id
-         WHERE e.target_id = ? AND e.kind = 'calls'`,
+         WHERE e.target_id = ? AND e.kind IN ('calls', 'imports-type')`,
   );
   const reexportsFromStmt = cachedStmt(
     _reexportsFromStmtCache,
diff --git a/src/domain/analysis/fn-impact.ts b/src/domain/analysis/fn-impact.ts
index 148cf5b59..d7cfc2901 100644
--- a/src/domain/analysis/fn-impact.ts
+++ b/src/domain/analysis/fn-impact.ts
@@ -268,7 +268,7 @@ export function fnImpactData(
   opts: {
     depth?: number;
     noTests?: boolean;
-    file?: string;
+    file?: string | string[];
     kind?: string;
     includeImplementors?: boolean;
     limit?: number;
diff --git a/src/domain/analysis/symbol-lookup.ts b/src/domain/analysis/symbol-lookup.ts
index 5009d043a..065c11f4e 100644
--- a/src/domain/analysis/symbol-lookup.ts
+++ b/src/domain/analysis/symbol-lookup.ts
@@ -38,7 +38,12 @@ const FUNCTION_KINDS: SymbolKind[] = ['function', 'method', 'class', 'constant']
 export function findMatchingNodes(
   dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
   name: string,
-  opts: { noTests?: boolean; file?: string; kind?: string; kinds?: readonly string[] } = {},
+  opts: {
+    noTests?: boolean;
+    file?: string | string[];
+    kind?: string;
+    kinds?: readonly string[];
+  } = {},
 ): Array<NodeRowWithFanIn & { _relevance: number }> {
   const kinds = (
     opts.kind ? [opts.kind] : opts.kinds?.length ? [...opts.kinds] : FUNCTION_KINDS
diff --git a/src/features/structure.ts b/src/features/structure.ts
index 74b88ef4a..85f3afff9 100644
--- a/src/features/structure.ts
+++ b/src/features/structure.ts
@@ -777,13 +777,20 @@ function writeMedianCache(
 }
 
 function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSummary): RoleSummary {
-  // Leaf kinds (parameter, property) can never have callers/callees.
+  // Property kind (class/struct fields) can never have callers/callees.
   // Classify them directly as dead-leaf without the expensive fan-in/fan-out JOINs.
+  //
+  // `parameter` is deliberately NOT included here (#1723): a parameter's liveness
+  // is a local dataflow question (is it referenced within its own function body),
+  // not a call-graph reachability question, so "no incoming call edges" carries
+  // zero dead-code signal for it. Parameters are also excluded from the main
+  // query below, so they never receive a role at all — the same treatment as
+  // `file`/`directory` nodes.
   const leafRows = db
     .prepare(
       `SELECT n.id
       FROM nodes n
-      WHERE n.kind IN ('parameter', 'property')`,
+      WHERE n.kind = 'property'`,
     )
     .all() as { id: number }[];
 
@@ -967,11 +974,13 @@ function classifyNodeRolesIncremental(
     globalMedians = computed;
   }
 
-  // 2a. Leaf kinds (parameter, property) in affected files — always dead-leaf
+  // 2a. Property kind (class/struct fields) in affected files — always dead-leaf.
+  // `parameter` is intentionally excluded (#1723) — see classifyNodeRolesFull for
+  // the rationale. Parameters stay unclassified (role = NULL) after the reset below.
   const leafRows = db
     .prepare(
       `SELECT n.id FROM nodes n
-      WHERE n.kind IN ('parameter', 'property')
+      WHERE n.kind = 'property'
         AND n.file IN (${placeholders})`,
     )
     .all(...allAffectedFiles) as { id: number }[];
diff --git a/src/graph/classifiers/roles.ts b/src/graph/classifiers/roles.ts
index 2b17c33ba..fe278ff31 100644
--- a/src/graph/classifiers/roles.ts
+++ b/src/graph/classifiers/roles.ts
@@ -4,10 +4,23 @@
  * Roles: entry, core, utility, adapter, leaf, dead-*, test-only
  *
  * Dead sub-categories refine the coarse "dead" bucket:
- *   dead-leaf       — parameters, properties, constants (leaf nodes by definition)
+ *   dead-leaf       — properties, constants (leaf nodes by definition)
  *   dead-entry      — framework dispatch: CLI commands, MCP tools, event handlers
  *   dead-ffi        — cross-language FFI boundaries (e.g. Rust napi-rs bindings)
  *   dead-unresolved — genuinely unreferenced callables (the real dead code)
+ *
+ * `parameter`-kind nodes never reach this module in production — callers
+ * (`features/structure.ts`, native `graph/classifiers/roles.rs`) exclude them
+ * entirely, leaving `role` unset, the same treatment as `file`/`directory`
+ * nodes. A parameter's liveness is a local dataflow question (is it referenced
+ * within its own function body), not a call-graph reachability question, so
+ * "no incoming call edges" carries zero dead-code signal for it (#1723).
+ *
+ * `method`/`property`-kind members of an interface/type declaration (e.g.
+ * `interface Foo { bar: string }`) DO reach this module, but are recognized by
+ * `isTypeDeclarationMember` and classified `leaf` unconditionally — they can
+ * never gain inbound call edges by construction, so call-graph reachability
+ * doesn't apply to them either (#1723).
  */
 
 import type { DeadSubRole, Role } from '../../types.js';
@@ -53,6 +66,56 @@ export interface ClassifiableNode {
   file?: string;
 }
 
+/**
+ * Compute, per file, the set of symbol names that are `TYPE_DEF_KINDS`-kind
+ * declarations (interface/type/struct/enum/trait/record). Used by
+ * `isTypeDeclarationMember` to recognize `Owner.member`-qualified nodes whose
+ * owner is a type-level declaration rather than a class.
+ */
+function computeTypeDefNamesByFile(nodes: RoleClassificationNode[]): Map<string, Set<string>> {
+  const byFile = new Map<string, Set<string>>();
+  for (const n of nodes) {
+    if (n.file && n.kind && TYPE_DEF_KINDS.has(n.kind)) {
+      let names = byFile.get(n.file);
+      if (!names) {
+        names = new Set();
+        byFile.set(n.file, names);
+      }
+      names.add(n.name);
+    }
+  }
+  return byFile;
+}
+
+/**
+ * True when `node` is a `method`/`property`-kind member of an interface/type
+ * declared in the same file — e.g. TS `interface Foo { bar: string }` extracts
+ * `bar` as a top-level `method`-kind definition named `Foo.bar` (#1723). Every
+ * language extractor qualifies interface/type members as `Owner.member`
+ * (mirroring class method qualification), so the owner name is recovered from
+ * the prefix before the first `.` and looked up against same-file
+ * `TYPE_DEF_KINDS` declarations. Class methods use the identical `Owner.member`
+ * convention but are unaffected here because `class` is not in `TYPE_DEF_KINDS`
+ * — they remain subject to normal dead-code detection.
+ *
+ * These members can never gain inbound call edges by construction — they are
+ * consumed via type annotations and structural typing, never calls — so a
+ * `fanIn === 0` reading carries zero dead-code signal for them, unlike a real
+ * function/method where it does. Call-edge-based reachability just doesn't
+ * apply to type-level declarations, so they must never be judged dead by it.
+ */
+function isTypeDeclarationMember(
+  node: RoleClassificationNode,
+  typeDefNamesByFile: Map<string, Set<string>>,
+): boolean {
+  if (node.kind !== 'method' && node.kind !== 'property') return false;
+  if (!node.file) return false;
+  const dotIdx = node.name.indexOf('.');
+  if (dotIdx === -1) return false;
+  const ownerName = node.name.slice(0, dotIdx);
+  return typeDefNamesByFile.get(node.file)?.has(ownerName) ?? false;
+}
+
 /**
  * Refine a "dead" classification into a sub-category.
  */
@@ -176,10 +239,21 @@ function classifyByFanShape(highIn: boolean, highOut: boolean): Role {
 
 /**
  * Apply role-classification rules to a single node.
- * Order matters — framework entries are tagged first, then dead/test cases,
- * then the fan-in/fan-out shape decides among the structural roles.
+ * Order matters — type-level members are ruled out first (they can never be
+ * judged by call-graph reachability at all), then framework entries, then
+ * dead/test cases, then the fan-in/fan-out shape decides among the structural
+ * roles.
  */
-function classifyNodeRole(node: RoleClassificationNode, medFanIn: number, medFanOut: number): Role {
+function classifyNodeRole(
+  node: RoleClassificationNode,
+  medFanIn: number,
+  medFanOut: number,
+  typeDefNamesByFile: Map<string, Set<string>>,
+): Role {
+  // Interface/type members (#1723) — never subject to call-graph dead-code
+  // detection, regardless of fan-in/fan-out/export status.
+  if (isTypeDeclarationMember(node, typeDefNamesByFile)) return 'leaf';
+
   if (FRAMEWORK_ENTRY_PREFIXES.some((p) => node.name.startsWith(p))) return 'entry';
 
   if (node.fanIn === 0) {
@@ -217,10 +291,11 @@ export function classifyRoles(
   if (nodes.length === 0) return new Map();
 
   const { fanIn: medFanIn, fanOut: medFanOut } = medianOverrides ?? computeFanMedians(nodes);
+  const typeDefNamesByFile = computeTypeDefNamesByFile(nodes);
 
   const result = new Map<string, Role>();
   for (const node of nodes) {
-    result.set(node.id, classifyNodeRole(node, medFanIn, medFanOut));
+    result.set(node.id, classifyNodeRole(node, medFanIn, medFanOut, typeDefNamesByFile));
   }
   return result;
 }
diff --git a/src/presentation/queries-cli/impact.ts b/src/presentation/queries-cli/impact.ts
index e9eafe052..94b1fa64d 100644
--- a/src/presentation/queries-cli/impact.ts
+++ b/src/presentation/queries-cli/impact.ts
@@ -118,7 +118,7 @@ interface OutputOpts {
   format?: string;
   staged?: boolean;
   ref?: string;
-  file?: string;
+  file?: string | string[];
   kind?: string;
   [key: string]: unknown;
 }
diff --git a/src/types.ts b/src/types.ts
index 980713528..8374a2a0c 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -265,7 +265,8 @@ export interface ComplexityMetrics {
 export interface QueryOpts {
   kind?: SymbolKind;
   kinds?: SymbolKind[];
-  file?: string;
+  /** Partial-match file filter. Repeatable on the CLI (`-f/--file`), so a single value arrives as a one-element array. */
+  file?: string | string[];
   noTests?: boolean;
 }
 
@@ -346,7 +347,7 @@ export interface Repository {
   // ── Composite queries ──────────────────────────────────────────────
   fnDeps(
     name: string,
-    opts?: { depth?: number; noTests?: boolean; file?: string; kind?: string },
+    opts?: { depth?: number; noTests?: boolean; file?: string | string[]; kind?: string },
   ): {
     name: string;
     results: Array<{
@@ -2496,7 +2497,7 @@ export interface NativeDatabase {
   findNodesWithFanIn(
     namePattern: string,
     kinds: string[] | null | undefined,
-    file: string | null | undefined,
+    file: string[] | null | undefined,
   ): NativeNodeRowWithFanIn[];
   findNodesForTriage(
     kind: string | null | undefined,
@@ -2553,7 +2554,7 @@ export interface NativeDatabase {
     name: string,
     depth: number | null | undefined,
     noTests: boolean | null | undefined,
-    file: string | null | undefined,
+    file: string[] | null | undefined,
     kind: string | null | undefined,
   ): NativeFnDepsResult;
 
diff --git a/tests/graph/classifiers/roles.test.ts b/tests/graph/classifiers/roles.test.ts
index 03ae894c7..b1de630ee 100644
--- a/tests/graph/classifiers/roles.test.ts
+++ b/tests/graph/classifiers/roles.test.ts
@@ -515,4 +515,117 @@ describe('classifyRoles', () => {
     const roles = classifyRoles(nodes);
     expect(roles.get('1')).toBe('dead-unresolved');
   });
+
+  // ── Interface/type member exemption (#1723) ─────────────────────────
+
+  it('classifies interface method-signature member as leaf, not dead', () => {
+    // TS `interface Foo { bar(): void }` extracts `bar` as a top-level
+    // `method`-kind definition named `Foo.bar`. It can never gain an inbound
+    // call edge (nothing "calls" a type-level declaration), so fanIn === 0
+    // carries zero dead-code signal here — unlike a real function/method.
+    const nodes = [
+      {
+        id: '1',
+        name: 'Foo',
+        kind: 'interface',
+        file: 'src/a.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+      {
+        id: '2',
+        name: 'Foo.bar',
+        kind: 'method',
+        file: 'src/a.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+    ];
+    const roles = classifyRoles(nodes);
+    expect(roles.get('2')).toBe('leaf');
+  });
+
+  it('classifies type-alias property-signature member as leaf, not dead', () => {
+    // TS `type Foo = { bar: string }` — a property-kind member of a `type` owner.
+    const nodes = [
+      {
+        id: '1',
+        name: 'Foo',
+        kind: 'type',
+        file: 'src/a.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+      {
+        id: '2',
+        name: 'Foo.bar',
+        kind: 'property',
+        file: 'src/a.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+    ];
+    const roles = classifyRoles(nodes);
+    expect(roles.get('2')).toBe('leaf');
+  });
+
+  it('classifies interface member as leaf even when the interface is isolated (no active siblings)', () => {
+    // Unlike bare TYPE_DEF_KINDS nodes (which need hasActiveFileSiblings to
+    // avoid being marked dead), members are exempt unconditionally — "no call
+    // edges" is a structural certainty for them, not merely a likelihood.
+    const nodes = [
+      {
+        id: '1',
+        name: 'Isolated',
+        kind: 'interface',
+        file: 'src/isolated.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+      {
+        id: '2',
+        name: 'Isolated.onlyMember',
+        kind: 'method',
+        file: 'src/isolated.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+    ];
+    const roles = classifyRoles(nodes);
+    expect(roles.get('2')).toBe('leaf');
+  });
+
+  it('does not exempt class methods sharing the Owner.member naming convention', () => {
+    // Class methods are qualified identically to interface members
+    // (`ClassName.method`), but `class` is not in TYPE_DEF_KINDS — they must
+    // remain subject to normal dead-code detection.
+    const nodes = [
+      {
+        id: '1',
+        name: 'Foo',
+        kind: 'class',
+        file: 'src/a.ts',
+        fanIn: 5,
+        fanOut: 0,
+        isExported: true,
+      },
+      {
+        id: '2',
+        name: 'Foo.deadMethod',
+        kind: 'method',
+        file: 'src/a.ts',
+        fanIn: 0,
+        fanOut: 0,
+        isExported: false,
+      },
+    ];
+    const roles = classifyRoles(nodes);
+    expect(roles.get('2')).toBe('dead-unresolved');
+  });
 });
diff --git a/tests/integration/cli.test.ts b/tests/integration/cli.test.ts
index f61b69153..6ff06f02a 100644
--- a/tests/integration/cli.test.ts
+++ b/tests/integration/cli.test.ts
@@ -110,6 +110,40 @@ describe('CLI smoke tests', () => {
     expect(data).toHaveProperty('results');
   });
 
+  // Regression test for #1726: `-f/--file` is a repeatable Commander option
+  // (collectFile) that always produces a string[], even for a single use.
+  // query's native composite path used to forward that array straight into
+  // a napi binding typed for a single String and crash.
+  test('query -f scopes results to a single file without crashing', () => {
+    const out = run('query', 'add', '-f', 'math.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    expect(data.results.length).toBeGreaterThan(0);
+    for (const r of data.results) expect(r.file).toContain('math.js');
+  });
+
+  test('query --file (long form) scopes results to a single file without crashing', () => {
+    const out = run('query', 'add', '--file', 'math.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    expect(data.results.length).toBeGreaterThan(0);
+    for (const r of data.results) expect(r.file).toContain('math.js');
+  });
+
+  test('query with a single -f excludes non-matching files', () => {
+    // `add` is only defined in math.js, so scoping to utils.js must be empty.
+    const out = run('query', 'add', '-f', 'utils.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    expect(data.results).toHaveLength(0);
+  });
+
+  test('query supports repeated -f (multi-file scoping)', () => {
+    // "square" substring-matches square() in math.js and sumOfSquares() in utils.js.
+    const out = run('query', 'square', '-f', 'math.js', '-f', 'utils.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    const names = data.results.map((r) => r.name);
+    expect(names).toContain('square');
+    expect(names).toContain('sumOfSquares');
+  });
+
   // ─── Fn-Impact ───────────────────────────────────────────────────────
   test('fn-impact --json returns valid JSON with results', () => {
     const out = run('fn-impact', 'add', '--db', dbPath, '--json');
@@ -117,6 +151,45 @@ describe('CLI smoke tests', () => {
     expect(data).toHaveProperty('results');
   });
 
+  // Regression test for #1726 (see query -f test above for full context).
+  test('fn-impact -f scopes results to a single file without crashing', () => {
+    const out = run('fn-impact', 'add', '-f', 'math.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    expect(data.results.length).toBeGreaterThan(0);
+    for (const r of data.results) expect(r.file).toContain('math.js');
+  });
+
+  test('fn-impact --file (long form) scopes results to a single file without crashing', () => {
+    const out = run('fn-impact', 'add', '--file', 'math.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    expect(data.results.length).toBeGreaterThan(0);
+    for (const r of data.results) expect(r.file).toContain('math.js');
+  });
+
+  test('fn-impact with a single -f excludes non-matching files', () => {
+    const out = run('fn-impact', 'add', '-f', 'utils.js', '--db', dbPath, '--json');
+    const data = JSON.parse(out);
+    expect(data.results).toHaveLength(0);
+  });
+
+  test('fn-impact supports repeated -f (multi-file scoping)', () => {
+    const out = run(
+      'fn-impact',
+      'square',
+      '-f',
+      'math.js',
+      '-f',
+      'utils.js',
+      '--db',
+      dbPath,
+      '--json',
+    );
+    const data = JSON.parse(out);
+    const names = data.results.map((r) => r.name);
+    expect(names).toContain('square');
+    expect(names).toContain('sumOfSquares');
+  });
+
   // ─── Query (path mode, formerly path) ────────────────────────────────
   test('query --path --json returns valid JSON with path info', () => {
     const out = run('query', 'sumOfSquares', '--path', 'add', '--db', dbPath, '--json');
diff --git a/tests/integration/exports.test.ts b/tests/integration/exports.test.ts
index 467621280..f869ec115 100644
--- a/tests/integration/exports.test.ts
+++ b/tests/integration/exports.test.ts
@@ -240,3 +240,76 @@ describe('exportsData', () => {
     expect(data.totalReexportedUnused).toBe(0);
   });
 });
+
+// ─── import type / type-only consumer crediting (#1724) ──────────────────
+//
+// Regression coverage for: interfaces/types that are only ever consumed via
+// `import type { X }` (never called/constructed) were reported as zero-
+// consumer dead exports, even though the builder already emits a
+// symbol-level `imports-type` edge (source = importing file node, target =
+// the specific imported symbol) for exactly this case. `codegraph deps`
+// already surfaced the file-level import correctly; `exportsData`'s
+// per-symbol consumer query only looked at `kind = 'calls'` and missed it.
+
+describe('exportsData — import type consumer crediting (#1724)', () => {
+  let tmpDir2: string, dbPath2: string;
+
+  beforeAll(() => {
+    tmpDir2 = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-exports-typeonly-'));
+    fs.mkdirSync(path.join(tmpDir2, '.codegraph'));
+    dbPath2 = path.join(tmpDir2, '.codegraph', 'graph.db');
+
+    const db = new Database(dbPath2);
+    db.pragma('journal_mode = WAL');
+    initSchema(db);
+
+    // File nodes
+    insertNode(db, 'types.ts', 'file', 'types.ts', 0);
+    const fConsumer = insertNode(db, 'consumer.ts', 'file', 'consumer.ts', 0);
+
+    // Interface exported from types.ts, referenced elsewhere only via a type
+    // annotation (never called/constructed).
+    const configIface = insertNode(db, 'Config', 'interface', 'types.ts', 1);
+    // Interface exported from types.ts, genuinely never referenced anywhere.
+    const unusedIface = insertNode(db, 'Unused', 'interface', 'types.ts', 10);
+
+    const markExported = db.prepare('UPDATE nodes SET exported = 1 WHERE id = ?');
+    markExported.run(configIface);
+    markExported.run(unusedIface);
+
+    // consumer.ts does `import type { Config } from './types'`. The builder
+    // emits the symbol-level edge with the importing *file* as source (see
+    // emitTypeOnlySymbolEdges in domain/graph/builder/stages/build-edges.ts
+    // and incremental.ts) since the import statement — not a specific
+    // function — is what references the type.
+    insertEdge(db, fConsumer, configIface, 'imports-type');
+
+    db.close();
+  });
+
+  afterAll(() => {
+    if (tmpDir2) fs.rmSync(tmpDir2, { recursive: true, force: true });
+  });
+
+  test('interface consumed only via `import type` is credited with a consumer', () => {
+    const data = exportsData('types.ts', dbPath2);
+    const config = data.results.find((r) => r.name === 'Config');
+    expect(config).toBeDefined();
+    expect(config.consumerCount).toBe(1);
+    expect(config.consumers.length).toBe(1);
+    expect(config.consumers[0].file).toBe('consumer.ts');
+  });
+
+  test('interface consumed only via `import type` is excluded from --unused', () => {
+    const data = exportsData('types.ts', dbPath2, { unused: true });
+    expect(data.results.find((r) => r.name === 'Config')).toBeUndefined();
+  });
+
+  test('interface with no references anywhere is still classified unused', () => {
+    const data = exportsData('types.ts', dbPath2, { unused: true });
+    const unused = data.results.find((r) => r.name === 'Unused');
+    expect(unused).toBeDefined();
+    expect(unused.consumerCount).toBe(0);
+    expect(unused.consumers).toEqual([]);
+  });
+});
diff --git a/tests/integration/queries.test.ts b/tests/integration/queries.test.ts
index 11fe0190c..c76d4ac86 100644
--- a/tests/integration/queries.test.ts
+++ b/tests/integration/queries.test.ts
@@ -361,6 +361,31 @@ describe('fnDepsData', () => {
     expect(names).not.toContain('authMiddleware');
   });
 
+  // Regression test for #1726: the CLI's `-f/--file` option is a repeatable
+  // Commander accumulator (collectFile) that always produces a string[], even
+  // for a single use. The native composite fnDeps() path used to forward that
+  // array straight into a napi binding typed for a single String and crash
+  // with "Failed to convert JavaScript value ... into rust type `String`".
+  test('--file as a single-element array (real CLI shape) scopes to a single file', () => {
+    const data = fnDepsData('auth', dbPath, { file: ['auth.js'] });
+    for (const r of data.results) {
+      expect(r.file).toContain('auth.js');
+    }
+    const names = data.results.map((r) => r.name);
+    expect(names).not.toContain('authMiddleware');
+  });
+
+  test('--file with multiple values (repeated -f) scopes across all of them', () => {
+    const data = fnDepsData('auth', dbPath, { file: ['auth.js', 'middleware.js'] });
+    const names = data.results.map((r) => r.name);
+    expect(names).toContain('authenticate'); // auth.js
+    expect(names).toContain('authMiddleware'); // middleware.js
+    // routes.js/utils.js should still be excluded
+    for (const r of data.results) {
+      expect(['auth.js', 'middleware.js']).toContain(r.file);
+    }
+  });
+
   test('--kind method filters to methods only', () => {
     // All fixtures are functions, so filtering by method should return empty
     const data = fnDepsData('auth', dbPath, { kind: 'method' });
@@ -414,6 +439,28 @@ describe('fnImpactData', () => {
     expect(r.direct + r.transitive).toBe(r.totalDependents);
   });
 
+  // Regression test for #1726 — see the equivalent fnDepsData test above for
+  // full context. fnImpactData's native path (findNodesWithFanIn) forwards
+  // the file filter used to resolve the *matched root symbol(s)* (not their
+  // callers) into rusqlite, and used to crash on the array shape the CLI
+  // always sends.
+  test('--file as a single-element array scopes matched root symbols to that file', () => {
+    const data = fnImpactData('auth', dbPath, { file: ['auth.js'] });
+    const names = data.results.map((r) => r.name);
+    expect(names).toContain('authenticate');
+    expect(names).not.toContain('authMiddleware'); // middleware.js
+    for (const r of data.results) expect(r.file).toBe('auth.js');
+  });
+
+  test('--file with multiple values scopes matched root symbols across all of them', () => {
+    const data = fnImpactData('auth', dbPath, { file: ['auth.js', 'middleware.js'] });
+    const names = data.results.map((r) => r.name);
+    expect(names).toContain('authenticate'); // auth.js
+    expect(names).toContain('authMiddleware'); // middleware.js
+    // preAuthenticate (utils.js) also substring-matches "auth" — must stay excluded
+    for (const r of data.results) expect(['auth.js', 'middleware.js']).toContain(r.file);
+  });
+
   test('direct and transitive are 0 for a function with no callers', () => {
     // handleRoute is the root of the call graph — nothing calls it
     const data = fnImpactData('handleRoute', dbPath);
diff --git a/tests/unit/roles.test.ts b/tests/unit/roles.test.ts
index 110e1c7bd..88d5ee1e0 100644
--- a/tests/unit/roles.test.ts
+++ b/tests/unit/roles.test.ts
@@ -380,4 +380,73 @@ describe('classifyNodeRoles', () => {
     // Should be entry (exported, fan-in 0), not dead-unresolved
     expect(role.role).toBe('entry');
   });
+
+  // ── Parameters and interface members are not dead-code targets (#1723) ──
+
+  it('excludes parameter-kind nodes from role classification entirely', () => {
+    // A parameter's liveness is a local dataflow question (is it referenced
+    // within its own function body), not a call-graph reachability question.
+    // "No incoming call edges" is guaranteed for every parameter regardless of
+    // usage, so parameters must never receive a `dead-*` role — or any role at
+    // all, the same treatment as file/directory nodes.
+    insertNode('src/helpers.ts', 'file', 'src/helpers.ts', 0);
+    const fn = insertNode('findChild', 'function', 'src/helpers.ts', 26);
+    insertNode('node', 'parameter', 'src/helpers.ts', 26);
+    insertNode('type', 'parameter', 'src/helpers.ts', 26);
+    // An external caller so findChild itself is not incidentally dead too —
+    // isolates the assertion to parameter handling specifically.
+    const caller = insertNode('caller', 'function', 'other.ts', 1);
+    insertEdge(caller, fn, 'calls');
+
+    classifyNodeRoles(db);
+
+    const paramRoles = db.prepare("SELECT role FROM nodes WHERE kind = 'parameter'").all() as {
+      role: string | null;
+    }[];
+    expect(paramRoles).toHaveLength(2);
+    for (const row of paramRoles) {
+      expect(row.role).toBeNull();
+    }
+  });
+
+  it('does not classify interface members as dead', () => {
+    // TS `interface ExtractParametersOptions { typeMap?: Map<...> }` extracts
+    // `typeMap` as a top-level `method`-kind definition named
+    // `ExtractParametersOptions.typeMap` (property-signature members are
+    // currently mislabeled `method` by the extractor — tracked separately).
+    // It has no callers by construction; it must not be flagged dead.
+    insertNode('src/helpers.ts', 'file', 'src/helpers.ts', 0);
+    insertNode('ExtractParametersOptions', 'interface', 'src/helpers.ts', 359);
+    insertNode('ExtractParametersOptions.typeMap', 'method', 'src/helpers.ts', 361);
+
+    classifyNodeRoles(db);
+
+    const role = db
+      .prepare("SELECT role FROM nodes WHERE name = 'ExtractParametersOptions.typeMap'")
+      .get() as { role: string | null };
+    expect(role.role).toBe('leaf');
+  });
+
+  it('regression: used parameters, interface members, and a genuinely dead function are classified correctly together', () => {
+    // Mirrors the exact issue #1723 repro: `findChild(node, type)` in
+    // src/extractors/helpers.ts, alongside an interface and a truly dead function.
+    insertNode('src/helpers.ts', 'file', 'src/helpers.ts', 0);
+    const findChildFn = insertNode('findChild', 'function', 'src/helpers.ts', 26);
+    insertNode('node', 'parameter', 'src/helpers.ts', 26);
+    insertNode('type', 'parameter', 'src/helpers.ts', 26);
+    insertNode('ChaContext', 'interface', 'src/helpers.ts', 18);
+    insertNode('ChaContext.implementors', 'method', 'src/helpers.ts', 20);
+    insertNode('trulyDeadHelper', 'function', 'src/helpers.ts', 400);
+
+    const caller = insertNode('caller', 'function', 'other.ts', 1);
+    insertEdge(caller, findChildFn, 'calls');
+
+    classifyNodeRoles(db);
+    const getRole = (name) => db.prepare('SELECT role FROM nodes WHERE name = ?').get(name)?.role;
+
+    expect(getRole('node')).toBeNull();
+    expect(getRole('type')).toBeNull();
+    expect(getRole('ChaContext.implementors')).toBe('leaf');
+    expect(getRole('trulyDeadHelper')).toBe('dead-unresolved');
+  });
 });