From 86a73017a3d1321f8b1fc75d64597b929adbd9c6 Mon Sep 17 00:00:00 2001
From: sunerpy <nkuzhangshn@gmail.com>
Date: Fri, 17 Jul 2026 12:43:38 +0800
Subject: [PATCH] feat(godot): resolve UID-form autoloads and unify resource
 impact queries

Fixes the five findings from the Godot team's 0.36.0 feedback report.

- UID-form autoloads now register their reference. A `project.godot`
  `[autoload]` entry declared as `Name="*uid://..."` resolves to its backing
  script through the `<script>.gd.uid` sidecar and to its scene through the
  `.tscn` `uid=` header, so `impact`/`audit`/`affected` on the script surface
  the `project.godot` registration and `Autoload.method()` calls bind for
  sidecar-backed script autoloads (scene-header autoloads are registration
  only). A uid present in both maps resolves to the sidecar script. The
  `.gd.uid` sidecar itself stays unindexed.

- `impact` now agrees with `affected` and `audit --impact` on Godot resources.
  It no longer requires the resource to be a file node, and both `impact` and
  `affected` share one reverse-dependency fan-out over the unresolved-subkind,
  loader-import-name, and a new project.godot-scoped main-scene lane. So the
  `main_scene` UID target and statically `load()`-ed scenes are reported by all
  three commands, not just `audit`.

- Lookup commands (`node`, `query`, `callers`, `callees`, `impact`) gain
  `--strict`, which exits non-zero when nothing is found; the default exit code
  is unchanged. The not-found signal is structured (a `notFound` flag on the
  tool result), so a matched symbol whose source text happens to contain a
  not-found phrase still exits zero, and a missing file is correctly flagged.

- `affected --filter` documents that its value is a glob used to classify
  affectedTests and does not filter affectedFiles.

UID-map inputs (`.gd.uid`, `.tscn` headers) are read at extraction time, so a
fresh `index`/`index --force` is authoritative; keeping an incremental `sync`
in step with sidecar/header edits is a shared limitation with the existing
main_scene UID mapping and is tracked as a follow-up (documented in
docs/godot.md). Golden `.schema` and every non-Godot fixture are byte-identical;
only the godot fixture is extended and regenerated.
---
 AGENTS.md                                     |   4 +-
 .../fixtures/godot/combo_ui.tscn              |   3 +
 .../fixtures/godot/effect_manager.gd          |   4 +
 .../fixtures/godot/effect_manager.gd.uid      |   1 +
 .../fixtures/godot/project.godot              |   2 +
 .../fixtures/godot/stage_manager.gd           |   1 +
 crates/codegraph-cli/src/main.rs              | 107 ++++++--
 crates/codegraph-cli/tests/affected.rs        |  25 ++
 .../tests/cli_text_and_errors.rs              | 121 +++++++++
 crates/codegraph-extract/src/engine.rs        |  12 +
 crates/codegraph-mcp/src/engine.rs            |  14 +-
 crates/codegraph-mcp/src/protocol.rs          |  20 ++
 .../codegraph-resolve/src/frameworks/godot.rs |  15 +-
 .../src/frameworks/godot_project.rs           | 254 ++++++++++++++++--
 .../src/frameworks/godot_scene.rs             | 122 ++++++++-
 crates/codegraph-store/src/queries.rs         | 106 ++++++++
 docs/equivalence.md                           |  10 +-
 docs/godot.md                                 |  14 +
 reference/golden/godot/colby.db               | Bin 151552 -> 151552 bytes
 reference/golden/godot/edges.json             |  41 ++-
 reference/golden/godot/files.json             |  24 +-
 reference/golden/godot/nodes.json             | 128 ++++++++-
 reference/golden/godot/refs.json              |  32 +++
 23 files changed, 992 insertions(+), 68 deletions(-)
 create mode 100644 crates/codegraph-bench/fixtures/godot/combo_ui.tscn
 create mode 100644 crates/codegraph-bench/fixtures/godot/effect_manager.gd
 create mode 100644 crates/codegraph-bench/fixtures/godot/effect_manager.gd.uid

diff --git a/AGENTS.md b/AGENTS.md
index eb30253..e7f0510 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,7 +10,9 @@ Protocol) stdio server. No AI / vector / LLM anywhere in the binary — output i
 - **Golden `.schema` byte-stability** — verified by `crates/codegraph-bench/tests/equivalence.rs`
   against the fixed golden artifacts under `reference/golden/`. Fixtures: the existing upstream
   corpus plus `reference/golden/godot/` (corpus `crates/codegraph-bench/fixtures/godot/`;
-  guards F1 autoload-call edges + F2 signal-handler edges byte-for-byte) and
+  guards F1 autoload-call edges + F2 signal-handler edges + UID-form autoloads
+  — a sidecar-UID script autoload (`*.gd.uid`) and a header-UID scene autoload
+  (`.tscn` `uid=`) — byte-for-byte) and
   `reference/golden/ruby/` (corpus `crates/codegraph-bench/fixtures/ruby/`; guards #1110
   Ruby `receiver.method` extraction — instance/class-method Calls, `Const.new` Instantiates,
   bare `include` Implements — byte-for-byte) and `reference/golden/cpp/`
diff --git a/crates/codegraph-bench/fixtures/godot/combo_ui.tscn b/crates/codegraph-bench/fixtures/godot/combo_ui.tscn
new file mode 100644
index 0000000..f665e09
--- /dev/null
+++ b/crates/codegraph-bench/fixtures/godot/combo_ui.tscn
@@ -0,0 +1,3 @@
+[gd_scene format=3 uid="uid://bddoi8q2q2olp"]
+
+[node name="ComboUI" type="Node"]
diff --git a/crates/codegraph-bench/fixtures/godot/effect_manager.gd b/crates/codegraph-bench/fixtures/godot/effect_manager.gd
new file mode 100644
index 0000000..30a66b3
--- /dev/null
+++ b/crates/codegraph-bench/fixtures/godot/effect_manager.gd
@@ -0,0 +1,4 @@
+extends Node
+
+func apply_effect() -> void:
+	pass
diff --git a/crates/codegraph-bench/fixtures/godot/effect_manager.gd.uid b/crates/codegraph-bench/fixtures/godot/effect_manager.gd.uid
new file mode 100644
index 0000000..168ae14
--- /dev/null
+++ b/crates/codegraph-bench/fixtures/godot/effect_manager.gd.uid
@@ -0,0 +1 @@
+uid://bb1ewunp0bc47
diff --git a/crates/codegraph-bench/fixtures/godot/project.godot b/crates/codegraph-bench/fixtures/godot/project.godot
index 168b0cd..0e184c0 100644
--- a/crates/codegraph-bench/fixtures/godot/project.godot
+++ b/crates/codegraph-bench/fixtures/godot/project.godot
@@ -7,3 +7,5 @@ config/name="CodeGraph Godot Fixture"
 [autoload]
 
 GameFlow="*res://game_flow.gd"
+EffectManager="*uid://bb1ewunp0bc47"
+ComboUi="*uid://bddoi8q2q2olp"
diff --git a/crates/codegraph-bench/fixtures/godot/stage_manager.gd b/crates/codegraph-bench/fixtures/godot/stage_manager.gd
index 5483d90..2649f9b 100644
--- a/crates/codegraph-bench/fixtures/godot/stage_manager.gd
+++ b/crates/codegraph-bench/fixtures/godot/stage_manager.gd
@@ -7,6 +7,7 @@ func _ready() -> void:
 
 func _goto_map() -> void:
 	GameFlow.return_to_map()
+	EffectManager.apply_effect()
 
 func _on_pressed(source) -> void:
 	pass
diff --git a/crates/codegraph-cli/src/main.rs b/crates/codegraph-cli/src/main.rs
index e0ba566..814598e 100644
--- a/crates/codegraph-cli/src/main.rs
+++ b/crates/codegraph-cli/src/main.rs
@@ -176,6 +176,9 @@ enum Command {
         kind: Option<String>,
         #[arg(short = 'j', long = "json")]
         json: bool,
+        /// Exit non-zero when no result is found (default exits 0).
+        #[arg(long)]
+        strict: bool,
     },
     // Upstream flags/output shape: upstream bin/codegraph.ts:903-911, 939-1013.
     Files {
@@ -240,6 +243,9 @@ enum Command {
         limit: usize,
         #[arg(short = 'j', long = "json")]
         json: bool,
+        /// Exit non-zero when no callers are found (default exits 0).
+        #[arg(long)]
+        strict: bool,
     },
     // Upstream flags/output shape: upstream bin/codegraph.ts:1280-1284, 1298-1345.
     Callees {
@@ -250,6 +256,9 @@ enum Command {
         limit: usize,
         #[arg(short = 'j', long = "json")]
         json: bool,
+        /// Exit non-zero when no callees are found (default exits 0).
+        #[arg(long)]
+        strict: bool,
     },
     // Upstream flags/output shape: upstream bin/codegraph.ts:1358-1362, 1374-1439.
     Impact {
@@ -260,6 +269,9 @@ enum Command {
         depth: usize,
         #[arg(short = 'j', long = "json")]
         json: bool,
+        /// Exit non-zero when the symbol is not found (default exits 0).
+        #[arg(long)]
+        strict: bool,
     },
     // Upstream flags/output shape: upstream bin/codegraph.ts:1462-1469, 1479-1582.
     Affected {
@@ -268,7 +280,8 @@ enum Command {
         path: Option<PathBuf>,
         #[arg(short, long, default_value_t = 5)]
         depth: usize,
-        #[arg(short, long)]
+        /// glob used to classify affectedTests; does NOT filter affectedFiles. Example: tests/*
+        #[arg(short, long, value_name = "GLOB")]
         filter: Option<String>,
     },
     // New analysis surface (not in the v1.0.1 pin): forward file-dependency
@@ -345,6 +358,9 @@ enum Command {
         symbols_only: bool,
         #[arg(short = 'j', long = "json")]
         json: bool,
+        /// Exit non-zero when the symbol/file is not found (default exits 0).
+        #[arg(long)]
+        strict: bool,
     },
     // Upstream flags/output: upstream bin/codegraph.ts:1864-1870, 1871-1920.
     // `--global`/`--local` are convenience aliases for `--location` (task spec).
@@ -512,7 +528,8 @@ fn run(cli: Cli) -> Result<()> {
             limit,
             kind,
             json,
-        } => cmd_query(search, path, limit, kind, json),
+            strict,
+        } => cmd_query(search, path, limit, kind, json, strict),
         Command::Files {
             path,
             filter,
@@ -536,19 +553,22 @@ fn run(cli: Cli) -> Result<()> {
             path,
             limit,
             json,
-        } => cmd_callers(symbol, path, limit, json),
+            strict,
+        } => cmd_callers(symbol, path, limit, json, strict),
         Command::Callees {
             symbol,
             path,
             limit,
             json,
-        } => cmd_callees(symbol, path, limit, json),
+            strict,
+        } => cmd_callees(symbol, path, limit, json, strict),
         Command::Impact {
             symbol,
             path,
             depth,
             json,
-        } => cmd_impact(symbol, path, depth, json),
+            strict,
+        } => cmd_impact(symbol, path, depth, json, strict),
         Command::Affected {
             files,
             path,
@@ -591,7 +611,8 @@ fn run(cli: Cli) -> Result<()> {
             path,
             symbols_only,
             json,
-        } => cmd_node(target, path, symbols_only, json),
+            strict,
+        } => cmd_node(target, path, symbols_only, json, strict),
         Command::Install {
             target,
             location,
@@ -1340,6 +1361,7 @@ fn cmd_query(
     limit: i64,
     kind: Option<String>,
     json_output: bool,
+    strict: bool,
 ) -> Result<()> {
     let project = resolve_required_project(path)?;
     let store = open_store(&project)?;
@@ -1368,12 +1390,11 @@ fn cmd_query(
             .map(|node| SearchResult { node, score: 1.0 })
             .collect();
     }
+    let is_empty = results.is_empty();
     if json_output {
         let output = results.iter().map(SearchOutput::from).collect::<Vec<_>>();
         print_json_pretty(&output)?;
-        return Ok(());
-    }
-    if results.is_empty() {
+    } else if is_empty {
         println!("No results found for \"{search}\"");
     } else {
         println!("\nSearch Results for \"{search}\":\n");
@@ -1386,6 +1407,9 @@ fn cmd_query(
             println!();
         }
     }
+    if strict && is_empty {
+        bail!("codegraph query: no results found for \"{search}\"");
+    }
     Ok(())
 }
 
@@ -2679,6 +2703,7 @@ fn cmd_callers(
     path: Option<PathBuf>,
     limit: usize,
     json_output: bool,
+    strict: bool,
 ) -> Result<()> {
     let project = resolve_required_project(path)?;
     let store = open_store(&project)?;
@@ -2694,6 +2719,9 @@ fn cmd_callers(
         print_related("Callers", &symbol, &nodes);
         godot.print_cli(nodes.is_empty());
     }
+    if strict && nodes.is_empty() {
+        bail!("codegraph callers: no callers found for \"{symbol}\"");
+    }
     Ok(())
 }
 
@@ -2702,6 +2730,7 @@ fn cmd_callees(
     path: Option<PathBuf>,
     limit: usize,
     json_output: bool,
+    strict: bool,
 ) -> Result<()> {
     let project = resolve_required_project(path)?;
     let store = open_store(&project)?;
@@ -2711,14 +2740,33 @@ fn cmd_callees(
     } else {
         print_related("Callees", &symbol, &nodes);
     }
+    if strict && nodes.is_empty() {
+        bail!("codegraph callees: no callees found for \"{symbol}\"");
+    }
     Ok(())
 }
 
+/// The shared Godot reverse-referrer fan-out for `impact` and `affected`. A
+/// `.tscn`/`.tres`/`project.godot` target owns no `file:` node, so its
+/// referrers live only in the path-keyed reverse lanes. Fanning out to all
+/// three — the 6-subkind `unresolved_refs` lane, the untagged `main_scene`
+/// lane, and the loader `import:`-name lane — behind ONE helper keeps `impact`
+/// and `affected` from diverging. Sorted + deduped; deterministic.
+fn godot_reverse_referrers(store: &Store, file: &str) -> Result<Vec<String>> {
+    let mut referrers = store.dependent_file_paths_unresolved(file)?;
+    referrers.extend(store.dependent_file_paths_via_import_name(file)?);
+    referrers.extend(store.dependent_file_paths_main_scene(file)?);
+    referrers.sort();
+    referrers.dedup();
+    Ok(referrers)
+}
+
 fn cmd_impact(
     symbol: String,
     path: Option<PathBuf>,
     depth: usize,
     json_output: bool,
+    strict: bool,
 ) -> Result<()> {
     let project = resolve_required_project(path)?;
     let store = open_store(&project)?;
@@ -2726,6 +2774,9 @@ fn cmd_impact(
     let matches = symbol_matches(&store, &project, &symbol)?;
     if matches.is_empty() {
         println!("Symbol \"{symbol}\" not found");
+        if strict {
+            bail!("codegraph impact: symbol \"{symbol}\" not found");
+        }
         return Ok(());
     }
     let traverser = GraphTraverser::new(&store);
@@ -2740,17 +2791,14 @@ fn cmd_impact(
         for edge in impact.edges {
             edge_keys.insert((edge.source, edge.target, edge.kind));
         }
-        if node.kind == NodeKind::File
-            && is_godot_resource_path(&node.file_path)
-            && !godot_files.contains(&node.file_path)
-        {
+        if is_godot_resource_target_node(node) && !godot_files.contains(&node.file_path) {
             godot_files.push(node.file_path.clone());
         }
     }
     let mut affected = nodes.values().map(NodeSummary::from).collect::<Vec<_>>();
     let mut godot_referrers: Vec<String> = Vec::new();
     for file in &godot_files {
-        godot_referrers.extend(store.dependent_file_paths_unresolved(file)?);
+        godot_referrers.extend(godot_reverse_referrers(&store, file)?);
     }
     godot_referrers.sort();
     godot_referrers.dedup();
@@ -2797,7 +2845,7 @@ fn cmd_explore(
         args["maxFiles"] = json!(max_files);
     }
     let result = engine.execute("codegraph_explore", &args);
-    print_engine_result("explore", &query, &result, json_output)
+    print_engine_result("explore", &query, &result, json_output, false)
 }
 
 fn cmd_node(
@@ -2805,6 +2853,7 @@ fn cmd_node(
     path: Option<PathBuf>,
     symbols_only: bool,
     json_output: bool,
+    strict: bool,
 ) -> Result<()> {
     let project = resolve_required_project(path)?;
     let engine = codegraph_mcp::CodeGraphEngine::open(&project)?;
@@ -2814,7 +2863,7 @@ fn cmd_node(
         json!({ "symbol": target, "includeCode": true })
     };
     let result = engine.execute("codegraph_node", &args);
-    print_engine_result("node", &target, &result, json_output)
+    print_engine_result("node", &target, &result, json_output, strict)
 }
 
 /// Decide whether a `codegraph node <target>` argument names an indexed FILE (→
@@ -2843,6 +2892,7 @@ fn print_engine_result(
     query: &str,
     result: &codegraph_mcp::protocol::ToolResult,
     json_output: bool,
+    strict: bool,
 ) -> Result<()> {
     let text = result
         .content
@@ -2864,6 +2914,9 @@ fn print_engine_result(
     if is_error {
         bail!("codegraph {command} failed: {text}");
     }
+    if strict && result.not_found.unwrap_or(false) {
+        bail!("codegraph {command}: \"{query}\" not found");
+    }
     Ok(())
 }
 
@@ -2893,8 +2946,7 @@ fn cmd_affected(
                 continue;
             }
             let mut dependents = store.dependent_file_paths(&current)?;
-            dependents.extend(store.dependent_file_paths_unresolved(&current)?);
-            dependents.extend(store.dependent_file_paths_via_import_name(&current)?);
+            dependents.extend(godot_reverse_referrers(&store, &current)?);
             dependents.sort();
             dependents.dedup();
             for dependent in dependents {
@@ -3168,6 +3220,25 @@ fn is_godot_resource_path(path: &str) -> bool {
         || lower.ends_with(".gd")
 }
 
+/// Whether a matched `impact` node names a Godot RESOURCE whose reverse
+/// referrers should fold into the impact set — as opposed to a symbol that
+/// merely lives in a Godot file. A `.tscn`/`.tres`/`.res` owns no `file:` node,
+/// so its ONLY node is a scene-level `Constant` (the whole-resource target); a
+/// `.gd` folds only when the matched node is its `file:` node (a whole-file
+/// target), never when it is a symbol (function/class) inside that script — that
+/// would wrongly attach the script's scene/autoload referrers to a symbol-level
+/// query.
+fn is_godot_resource_target_node(node: &codegraph_core::types::Node) -> bool {
+    if !is_godot_resource_path(&node.file_path) {
+        return false;
+    }
+    let lower = node.file_path.to_ascii_lowercase();
+    if lower.ends_with(".gd") {
+        return node.kind == NodeKind::File;
+    }
+    true
+}
+
 fn print_audit_orphans(orphans: &[codegraph_graph::graph::OrphanResource]) {
     if orphans.is_empty() {
         println!("No orphan resources found");
diff --git a/crates/codegraph-cli/tests/affected.rs b/crates/codegraph-cli/tests/affected.rs
index 6d87da8..90caeb2 100644
--- a/crates/codegraph-cli/tests/affected.rs
+++ b/crates/codegraph-cli/tests/affected.rs
@@ -96,6 +96,31 @@ fn affected_json(p: &str, file: &str, extra: &[&str]) -> serde_json::Value {
     serde_json::from_str(&stdout).expect("affected emits valid JSON on stdout")
 }
 
+#[test]
+fn impact_and_affected_of_main_scene_list_project_godot() {
+    // Given the indexed godot_audit fixture, where project.godot declares
+    // `run/main_scene="res://main.tscn"` (an untagged main_scene ref).
+    let (_dir, project) = indexed_project("main-scene");
+    let p = project.to_str().unwrap();
+
+    // When impact runs on the main scene, project.godot is surfaced as a
+    // referrer (P2 — the untagged main_scene reverse lane).
+    let (impact_out, err, ok) = cli(&["impact", "main.tscn", "-p", p]);
+    assert!(ok, "impact failed: stdout={impact_out} stderr={err}");
+    assert!(
+        impact_out.contains("project.godot"),
+        "impact main.tscn must list project.godot: {impact_out}"
+    );
+
+    // And affected agrees at its own entrypoint (both route the shared helper).
+    let value = affected_json(p, "main.tscn", &["--depth", "5"]);
+    let affected_files = string_array(&value, "affectedFiles");
+    assert!(
+        affected_files.contains(&"project.godot".to_string()),
+        "affected main.tscn must list project.godot: {affected_files:?}"
+    );
+}
+
 fn string_array(value: &serde_json::Value, key: &str) -> Vec<String> {
     value[key]
         .as_array()
diff --git a/crates/codegraph-cli/tests/cli_text_and_errors.rs b/crates/codegraph-cli/tests/cli_text_and_errors.rs
index e222fa3..35431bc 100644
--- a/crates/codegraph-cli/tests/cli_text_and_errors.rs
+++ b/crates/codegraph-cli/tests/cli_text_and_errors.rs
@@ -314,6 +314,127 @@ fn affected_with_filter_treats_matches_as_tests() {
     );
 }
 
+#[test]
+fn node_missing_is_zero_but_strict_is_nonzero() {
+    let dir = TestDir::new("strict-node");
+    let project = indexed_project(&dir);
+    let p = project.to_str().unwrap();
+
+    let lax = run_in(dir.path(), &["node", "no_such_symbol_zzz", "-p", p]);
+    assert!(lax.ok, "node of a missing symbol must exit 0 by default");
+
+    let strict = run_in(
+        dir.path(),
+        &["node", "no_such_symbol_zzz", "-p", p, "--strict"],
+    );
+    assert!(
+        !strict.ok,
+        "node --strict of a missing symbol must exit non-zero: {}",
+        strict.stdout
+    );
+
+    let hit = run_in(dir.path(), &["node", "add", "-p", p, "--strict"]);
+    assert!(
+        hit.ok,
+        "node --strict of an existing symbol must exit 0: {}",
+        hit.stderr
+    );
+}
+
+#[test]
+fn query_and_impact_strict_flags_gate_exit_code() {
+    let dir = TestDir::new("strict-query-impact");
+    let project = indexed_project(&dir);
+    let p = project.to_str().unwrap();
+
+    let q_lax = run_in(dir.path(), &["query", "no_such_symbol_zzz", "-p", p]);
+    assert!(q_lax.ok, "query of a missing symbol must exit 0 by default");
+    let q_strict = run_in(
+        dir.path(),
+        &["query", "no_such_symbol_zzz", "-p", p, "--strict"],
+    );
+    assert!(
+        !q_strict.ok,
+        "query --strict must exit non-zero on no results"
+    );
+
+    let i_lax = run_in(dir.path(), &["impact", "no_such_symbol_zzz", "-p", p]);
+    assert!(
+        i_lax.ok,
+        "impact of a missing symbol must exit 0 by default"
+    );
+    let i_strict = run_in(
+        dir.path(),
+        &["impact", "no_such_symbol_zzz", "-p", p, "--strict"],
+    );
+    assert!(
+        !i_strict.ok,
+        "impact --strict must exit non-zero when not found"
+    );
+}
+
+#[test]
+fn node_strict_found_symbol_with_sentinel_body_exits_zero() {
+    let dir = TestDir::new("strict-sentinel-body");
+    let project = dir.path().join("mini");
+    copy_tree(&mini_fixture(), &project);
+    std::fs::write(
+        project.join("sentinel.ts"),
+        "export function sentinelCarrier(): string {\n  return \"No results found and not found in the codebase\";\n}\n",
+    )
+    .unwrap();
+    let p = project.to_str().unwrap();
+    let init = run_in(dir.path(), &["init", p]);
+    assert!(init.ok, "init failed: {} {}", init.stdout, init.stderr);
+    let idx = run_in(dir.path(), &["index", "--force", p]);
+    assert!(idx.ok, "index failed: {} {}", idx.stdout, idx.stderr);
+
+    let strict = run_in(
+        dir.path(),
+        &["node", "sentinelCarrier", "-p", p, "--strict"],
+    );
+    assert!(
+        strict.ok,
+        "node --strict of a FOUND symbol must exit 0 even when its source body contains a not-found sentinel phrase: {}",
+        strict.stdout
+    );
+}
+
+#[test]
+fn node_strict_missing_file_exits_nonzero() {
+    let dir = TestDir::new("strict-missing-file");
+    let project = indexed_project(&dir);
+    let p = project.to_str().unwrap();
+
+    let run = run_in(
+        dir.path(),
+        &["node", "some/missing_file.rs", "-p", p, "--strict"],
+    );
+    assert!(
+        !run.ok,
+        "node --strict of a missing file must exit non-zero (the missing-file sentinel is now flagged): {}",
+        run.stdout
+    );
+}
+
+#[test]
+fn affected_help_documents_the_filter_glob() {
+    let dir = TestDir::new("affected-help");
+    let run = run_in(dir.path(), &["affected", "--help"]);
+    assert!(run.ok, "affected --help must succeed: {}", run.stderr);
+    assert!(
+        run.stdout.contains("GLOB"),
+        "affected --help must show the GLOB value name: {}",
+        run.stdout
+    );
+    assert!(
+        run.stdout.contains("affectedTests")
+            && run.stdout.contains("does NOT filter affectedFiles"),
+        "affected --help must document that --filter classifies affectedTests only: {}",
+        run.stdout
+    );
+}
+
 #[test]
 fn index_without_init_errors() {
     let dir = TestDir::new("index-noinit");
diff --git a/crates/codegraph-extract/src/engine.rs b/crates/codegraph-extract/src/engine.rs
index 1e834e5..3a8729b 100644
--- a/crates/codegraph-extract/src/engine.rs
+++ b/crates/codegraph-extract/src/engine.rs
@@ -877,6 +877,18 @@ mod tests {
         assert_eq!(detect_language("src/lib.rs"), Language::Rust);
     }
 
+    #[test]
+    fn gd_uid_sidecar_never_becomes_file_record() {
+        assert_eq!(
+            detect_language("Scripts/effect_manager.gd.uid"),
+            Language::Unknown
+        );
+        assert!(
+            !is_extractable_source_path("Scripts/effect_manager.gd.uid"),
+            ".gd.uid sidecar must never be scanned into a file record"
+        );
+    }
+
     #[test]
     fn metal_cu_cuh_map_to_cpp() {
         assert_eq!(detect_language("s.metal"), Language::Cpp);
diff --git a/crates/codegraph-mcp/src/engine.rs b/crates/codegraph-mcp/src/engine.rs
index 9913e13..1e93d79 100644
--- a/crates/codegraph-mcp/src/engine.rs
+++ b/crates/codegraph-mcp/src/engine.rs
@@ -191,7 +191,7 @@ impl CodeGraphEngine {
         };
         let results = search_nodes(&self.store, &query, &options, &self.project_name_tokens())?;
         if results.is_empty() {
-            return Ok(ToolResult::text(format!(
+            return Ok(ToolResult::not_found_text(format!(
                 "No results found for \"{query}\""
             )));
         }
@@ -223,7 +223,7 @@ impl CodeGraphEngine {
 
         let all_matches = self.find_all_symbols(&symbol)?;
         if all_matches.nodes.is_empty() {
-            return Ok(ToolResult::text(format!(
+            return Ok(ToolResult::not_found_text(format!(
                 "Symbol \"{symbol}\" not found in the codebase"
             )));
         }
@@ -253,7 +253,7 @@ impl CodeGraphEngine {
                 CallDir::Callers => "callers",
                 CallDir::Callees => "callees",
             };
-            return Ok(ToolResult::text(format!(
+            return Ok(ToolResult::not_found_text(format!(
                 "No {label} found for \"{symbol}\"{}{}",
                 all_matches.note,
                 godot.annotation(true)
@@ -287,7 +287,7 @@ impl CodeGraphEngine {
 
         let all_matches = self.find_all_symbols(&symbol)?;
         if all_matches.nodes.is_empty() {
-            return Ok(ToolResult::text(format!(
+            return Ok(ToolResult::not_found_text(format!(
                 "Symbol \"{symbol}\" not found in the codebase"
             )));
         }
@@ -354,7 +354,7 @@ impl CodeGraphEngine {
 
         let matches = self.find_symbol_matches(symbol)?;
         if matches.is_empty() {
-            return Ok(ToolResult::text(format!(
+            return Ok(ToolResult::not_found_text(format!(
                 "Symbol \"{symbol}\" not found in the codebase"
             )));
         }
@@ -507,7 +507,7 @@ impl CodeGraphEngine {
 
         let files = self.store.all_files()?;
         if files.is_empty() {
-            return Ok(ToolResult::text(
+            return Ok(ToolResult::not_found_text(
                 "No files indexed. Run `codegraph index` first.",
             ));
         }
@@ -516,7 +516,7 @@ impl CodeGraphEngine {
         let file_path = match candidates.as_slice() {
             [one] => one.clone(),
             [] => {
-                return Ok(ToolResult::text(format!(
+                return Ok(ToolResult::not_found_text(format!(
                     "No indexed file matches \"{file_arg}\". Codegraph indexes source files; configs/docs it doesn't parse won't appear — Read those directly."
                 )));
             }
diff --git a/crates/codegraph-mcp/src/protocol.rs b/crates/codegraph-mcp/src/protocol.rs
index a8f64a0..4763d52 100644
--- a/crates/codegraph-mcp/src/protocol.rs
+++ b/crates/codegraph-mcp/src/protocol.rs
@@ -91,6 +91,14 @@ pub struct ToolResult {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(rename = "isError")]
     pub is_error: Option<bool>,
+    /// Structured "the lookup found nothing" signal for a non-error result — set
+    /// at the engine's genuine not-found/empty branches so callers can gate on
+    /// it (`--strict`) WITHOUT substring-matching the rendered text, which would
+    /// misfire on a matched node whose source body contains a sentinel phrase.
+    /// Skipped when None, so the MCP wire shape is unchanged.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "notFound")]
+    pub not_found: Option<bool>,
 }
 
 #[derive(Debug, Clone, Serialize, PartialEq, Eq)]
@@ -109,6 +117,17 @@ impl ToolResult {
                 text: text.into(),
             }],
             is_error: None,
+            not_found: None,
+        }
+    }
+
+    /// A non-error result whose text is a genuine "found nothing" sentinel;
+    /// flags `not_found` so `--strict` callers gate on it without inspecting the
+    /// text. Wire shape matches [`Self::text`] (the flag is skipped when None).
+    pub fn not_found_text(text: impl Into<String>) -> Self {
+        Self {
+            not_found: Some(true),
+            ..Self::text(text)
         }
     }
 
@@ -121,6 +140,7 @@ impl ToolResult {
                 text: format!("Error: {message}"),
             }],
             is_error: Some(true),
+            not_found: None,
         }
     }
 }
diff --git a/crates/codegraph-resolve/src/frameworks/godot.rs b/crates/codegraph-resolve/src/frameworks/godot.rs
index 28686c6..b2782f7 100644
--- a/crates/codegraph-resolve/src/frameworks/godot.rs
+++ b/crates/codegraph-resolve/src/frameworks/godot.rs
@@ -384,10 +384,13 @@ fn resolve_class_member(
 /// same-named `func` in the receiver's bound script (F1). Returns `None` — no
 /// edge — unless every determinism rule holds:
 ///
-/// 1. Single binding source: the target script is ONLY the `res://` path bound to
-///    `Receiver` in `project.godot`'s `[autoload]` section (via
-///    [`autoload_script_bindings`]). A receiver that is not a real `res://`-bound
-///    autoload (a built-in like `Vector2`, a `uid://`-bound autoload, a class
+/// 1. Single binding source: the target script is the path bound to `Receiver`
+///    in `project.godot`'s `[autoload]` section (via
+///    [`autoload_script_bindings`]) — a `res://` `.gd` path or a sidecar-UID
+///    (`*.gd.uid`) script autoload, both of which get full F1 binding. A
+///    scene-header-UID autoload is registration-only (bound to a `.tscn`, no F1
+///    binding to its attached script). A receiver that is not a real script-bound
+///    autoload (a built-in like `Vector2`, a scene-backed autoload, a class
 ///    global) has no binding here → `None`. No global cross-file matching.
 /// 2. Unique-candidate-only: `member` is searched for as a GDScript `Function`
 ///    ONLY inside that one bound script. Exactly one match → resolve to it; zero
@@ -451,7 +454,9 @@ fn autoload_script_bindings(
         let Some(content) = context.read_file(&file) else {
             continue;
         };
-        for (name, path) in godot_project::autoload_script_paths(&content) {
+        for (name, path) in
+            godot_project::autoload_script_paths(&content, context.get_project_root())
+        {
             out.entry(name).or_insert(path);
         }
     }
diff --git a/crates/codegraph-resolve/src/frameworks/godot_project.rs b/crates/codegraph-resolve/src/frameworks/godot_project.rs
index b26d1ec..b0bb837 100644
--- a/crates/codegraph-resolve/src/frameworks/godot_project.rs
+++ b/crates/codegraph-resolve/src/frameworks/godot_project.rs
@@ -48,11 +48,13 @@
 //! header), an unterminated value, or an unknown section is skipped, never
 //! panics. An empty or sectionless file yields an empty result.
 
+use std::collections::BTreeMap;
+
 use codegraph_core::node_id::generate_node_id;
 use codegraph_core::types::{EdgeKind, Language, Node, NodeKind, ReferenceSubkind};
 
 use super::framework_node;
-use super::godot_common::{map_res_path, map_res_path_inner, quoted_strings};
+use super::godot_common::{map_res_path, map_res_path_inner, quoted_strings, strip_quotes};
 use crate::types::{FrameworkResolverExtractionResult, RefView};
 
 /// The marker basename this parser handles.
@@ -79,11 +81,13 @@ pub(crate) fn parse_project_godot(
     let mut nodes: Vec<Node> = Vec::new();
     let mut references: Vec<RefView> = Vec::new();
 
-    // `run/main_scene` may be a `uid://…` (Godot 4.x default) rather than a
-    // `res://…` path. Resolving it needs the project-wide `uid → .tscn path`
-    // map, built lazily on first `uid://` main_scene so a project without one
-    // pays nothing.
-    let mut scene_uids: Option<std::collections::BTreeMap<String, String>> = None;
+    // `run/main_scene` and `[autoload]` values may be a `uid://…` (Godot 4.x
+    // default) rather than a `res://…` path. A scene uid resolves through the
+    // project-wide `uid → .tscn path` map; an autoload SCRIPT uid resolves
+    // through the `uid → .gd path` sidecar map. Both are built lazily on first
+    // `uid://` need so a project without one pays nothing.
+    let mut scene_uids: Option<BTreeMap<String, String>> = None;
+    let mut script_uids: Option<BTreeMap<String, String>> = None;
 
     let mut section: Option<Section> = None;
     // Track whether we are inside a multi-line `key={ ... }` value so its inner
@@ -121,9 +125,17 @@ pub(crate) fn parse_project_godot(
         };
 
         match section {
-            Section::Autoload => {
-                emit_autoload(file_path, line_no, key, value, &mut nodes, &mut references)
-            }
+            Section::Autoload => emit_autoload(
+                file_path,
+                line_no,
+                key,
+                value,
+                project_root,
+                &mut scene_uids,
+                &mut script_uids,
+                &mut nodes,
+                &mut references,
+            ),
             Section::Application => {
                 if key == "run/main_scene" {
                     emit_main_scene(
@@ -161,10 +173,11 @@ pub(crate) fn parse_project_godot(
 /// [`parse_project_godot`] uses, but yields only `(name, path)` pairs (no nodes
 /// / no clock), so it is pure and deterministic. An entry whose value is not a
 /// `res://` path is skipped. First-write-wins on a duplicate name.
-pub(crate) fn autoload_script_paths(content: &str) -> Vec<(String, String)> {
+pub(crate) fn autoload_script_paths(content: &str, project_root: &str) -> Vec<(String, String)> {
     let mut out: Vec<(String, String)> = Vec::new();
     let mut section: Option<Section> = None;
     let mut brace_depth: i32 = 0;
+    let mut script_uids: Option<BTreeMap<String, String>> = None;
 
     for raw_line in content.lines() {
         let line = raw_line.trim();
@@ -188,7 +201,8 @@ pub(crate) fn autoload_script_paths(content: &str) -> Vec<(String, String)> {
         match section {
             Section::Autoload => {
                 if !key.is_empty() {
-                    if let Some(path) = map_res_path(value) {
+                    if let Some(path) = autoload_script_path(value, project_root, &mut script_uids)
+                    {
                         if !out.iter().any(|(n, _)| n == key) {
                             out.push((key.to_string(), path));
                         }
@@ -202,6 +216,29 @@ pub(crate) fn autoload_script_paths(content: &str) -> Vec<(String, String)> {
     out
 }
 
+/// Resolve an `[autoload]` value to a repo-relative SCRIPT path for F1 binding.
+/// A `res://…` value maps via [`map_res_path`]; a `uid://…` value resolves ONLY
+/// through the `.gd.uid` sidecar map (a script autoload). A scene-backed uid
+/// (`.tscn` header) yields `None` here — F1 binds to a script's own `func`s, and
+/// a scene autoload has no such backing script (registration-only per the plan).
+fn autoload_script_path(
+    value: &str,
+    project_root: &str,
+    script_uids: &mut Option<BTreeMap<String, String>>,
+) -> Option<String> {
+    if let Some(path) = map_res_path(value) {
+        return Some(path);
+    }
+    let unquoted = strip_quotes(value).trim();
+    let uid = unquoted.strip_prefix('*').unwrap_or(unquoted);
+    if !uid.starts_with("uid://") {
+        return None;
+    }
+    let scripts =
+        script_uids.get_or_insert_with(|| super::godot_scene::gd_uid_sidecar_map(project_root));
+    scripts.get(uid).cloned()
+}
+
 /// The sections L1 understands.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Section {
@@ -225,11 +262,23 @@ impl Section {
 }
 
 /// Emit a singleton node + a `References` edge to its target script/scene.
+///
+/// A `res://…` value maps directly via [`map_res_path`]. A `uid://…` value
+/// (Godot 4.x default) resolves through a combined uid lookup: the `.gd.uid`
+/// SIDECAR map FIRST (a SCRIPT autoload), then the scene `uid → .tscn` map (a
+/// scene-backed autoload). Either resolution emits the SAME
+/// `Autoload`-subkind reference the `res://` form emits, so it enters the
+/// reverse-consume lanes with zero query change. An unresolvable uid emits the
+/// singleton node but NO reference (unknown-uid → no guess).
+#[allow(clippy::too_many_arguments)]
 fn emit_autoload(
     file_path: &str,
     line_no: i64,
     name: &str,
     value: &str,
+    project_root: &str,
+    scene_uids: &mut Option<BTreeMap<String, String>>,
+    script_uids: &mut Option<BTreeMap<String, String>>,
     nodes: &mut Vec<Node>,
     references: &mut Vec<RefView>,
 ) {
@@ -240,11 +289,38 @@ fn emit_autoload(
     let node_id = node.id.clone();
     nodes.push(node);
 
-    if let Some(target) = map_res_path(value) {
+    if let Some(target) = resolve_autoload_target(value, project_root, scene_uids, script_uids) {
         references.push(autoload_reference(node_id, target, line_no, file_path));
     }
 }
 
+/// Resolve an `[autoload]` value to a repo-relative target path. A `res://…`
+/// value maps via the shared [`map_res_path`]; a `uid://…` value is resolved
+/// through the `.gd.uid` sidecar map (script autoload) first, then the scene
+/// `uid → .tscn` map (scene-backed autoload). Any other form yields `None`.
+fn resolve_autoload_target(
+    value: &str,
+    project_root: &str,
+    scene_uids: &mut Option<BTreeMap<String, String>>,
+    script_uids: &mut Option<BTreeMap<String, String>>,
+) -> Option<String> {
+    if let Some(target) = map_res_path(value) {
+        return Some(target);
+    }
+    let unquoted = strip_quotes(value).trim();
+    let uid = unquoted.strip_prefix('*').unwrap_or(unquoted);
+    if !uid.starts_with("uid://") {
+        return None;
+    }
+    let scripts =
+        script_uids.get_or_insert_with(|| super::godot_scene::gd_uid_sidecar_map(project_root));
+    if let Some(path) = scripts.get(uid) {
+        return Some(path.clone());
+    }
+    let scenes = scene_uids.get_or_insert_with(|| super::godot_scene::scene_uid_map(project_root));
+    scenes.get(uid).cloned()
+}
+
 /// Emit a main-scene marker node + a `References` edge to the scene path.
 ///
 /// `run/main_scene` is either a `res://…` path (mapped directly) or, in Godot
@@ -433,7 +509,7 @@ mod tests {
     fn autoload_script_paths_maps_name_to_repo_relative() {
         let content =
             "[autoload]\nGameState=\"*res://globals/state.gd\"\nMusic=\"res://audio/m.gd\"\n";
-        let got = autoload_script_paths(content);
+        let got = autoload_script_paths(content, "");
         assert_eq!(
             got,
             vec![
@@ -446,14 +522,14 @@ mod tests {
     #[test]
     fn autoload_script_paths_first_write_wins_on_dup_name() {
         let content = "[autoload]\nX=\"res://a.gd\"\nX=\"res://b.gd\"\n";
-        let got = autoload_script_paths(content);
+        let got = autoload_script_paths(content, "");
         assert_eq!(got, vec![("X".to_string(), "a.gd".to_string())]);
     }
 
     #[test]
     fn autoload_script_paths_skips_non_res_value() {
         let content = "[autoload]\nX=\"user://a.gd\"\n";
-        assert!(autoload_script_paths(content).is_empty());
+        assert!(autoload_script_paths(content, "").is_empty());
     }
 
     #[test]
@@ -471,14 +547,14 @@ run/main_scene=\"res://main.tscn\"
 X=\"res://x.gd\"
 ";
         assert_eq!(
-            autoload_script_paths(content),
+            autoload_script_paths(content, ""),
             vec![("X".to_string(), "x.gd".to_string())]
         );
     }
 
     #[test]
     fn autoload_script_paths_empty_when_no_autoload() {
-        assert!(autoload_script_paths("; comment\nconfig_version=5\n").is_empty());
+        assert!(autoload_script_paths("; comment\nconfig_version=5\n", "").is_empty());
     }
 
     #[test]
@@ -550,4 +626,148 @@ X=\"res://x.gd\"
         );
         std::fs::remove_dir_all(&dir).ok();
     }
+
+    fn autoload_temp_dir(tag: &str) -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!(
+            "cg-autoload-uid-{tag}-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .expect("clock")
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&dir).expect("mkdir");
+        dir
+    }
+
+    #[test]
+    fn emit_autoload_uid_sidecar_form_emits_reference() {
+        let dir = autoload_temp_dir("sidecar");
+        std::fs::create_dir_all(dir.join("Scripts/Autoloads")).unwrap();
+        std::fs::write(
+            dir.join("Scripts/Autoloads/effect_manager.gd"),
+            "extends Node\n",
+        )
+        .unwrap();
+        std::fs::write(
+            dir.join("Scripts/Autoloads/effect_manager.gd.uid"),
+            "uid://bb1ewunp0bc47\n",
+        )
+        .unwrap();
+        let root = dir.to_string_lossy().to_string();
+
+        let content = "[autoload]\nEffectManager=\"*uid://bb1ewunp0bc47\"\n";
+        let result = parse_project_godot("project.godot", content, &root);
+
+        assert_eq!(result.references.len(), 1, "one autoload ref emitted");
+        let r = &result.references[0];
+        assert_eq!(r.reference_name, "Scripts/Autoloads/effect_manager.gd");
+        assert_eq!(r.reference_subkind, Some(ReferenceSubkind::Autoload));
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn emit_autoload_uid_scene_form_emits_reference() {
+        let dir = autoload_temp_dir("scene");
+        std::fs::create_dir_all(dir.join("Entities/UI")).unwrap();
+        std::fs::write(
+            dir.join("Entities/UI/ComboUI.tscn"),
+            "[gd_scene format=3 uid=\"uid://bddoi8q2q2olp\"]\n",
+        )
+        .unwrap();
+        let root = dir.to_string_lossy().to_string();
+
+        let content = "[autoload]\nComboUi=\"*uid://bddoi8q2q2olp\"\n";
+        let result = parse_project_godot("project.godot", content, &root);
+
+        assert_eq!(result.references.len(), 1, "one autoload ref emitted");
+        let r = &result.references[0];
+        assert_eq!(r.reference_name, "Entities/UI/ComboUI.tscn");
+        assert_eq!(r.reference_subkind, Some(ReferenceSubkind::Autoload));
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn gd_uid_collision_sidecar_wins_over_scene() {
+        let dir = autoload_temp_dir("collision");
+        std::fs::create_dir_all(dir.join("Scripts")).unwrap();
+        std::fs::write(dir.join("Scripts/effect_manager.gd"), "extends Node\n").unwrap();
+        std::fs::write(dir.join("Scripts/effect_manager.gd.uid"), "uid://collide\n").unwrap();
+        std::fs::write(
+            dir.join("Scripts/ComboUI.tscn"),
+            "[gd_scene format=3 uid=\"uid://collide\"]\n",
+        )
+        .unwrap();
+        let root = dir.to_string_lossy().to_string();
+
+        let content = "[autoload]\nShared=\"*uid://collide\"\n";
+        let result = parse_project_godot("project.godot", content, &root);
+
+        assert_eq!(result.references.len(), 1, "one autoload ref emitted");
+        assert_eq!(
+            result.references[0].reference_name, "Scripts/effect_manager.gd",
+            "on a uid present in BOTH the sidecar and the scene map, the sidecar .gd wins"
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn emit_autoload_unknown_uid_no_reference() {
+        let dir = autoload_temp_dir("miss");
+        let root = dir.to_string_lossy().to_string();
+
+        let content = "[autoload]\nGhost=\"*uid://nope\"\n";
+        let result = parse_project_godot("project.godot", content, &root);
+
+        assert_eq!(result.nodes.len(), 1, "singleton node still emitted");
+        assert!(
+            result.references.is_empty(),
+            "unknown uid emits no reference, got: {:?}",
+            result.references
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn autoload_script_paths_resolves_uid_sidecar_form() {
+        let dir = autoload_temp_dir("scriptpaths");
+        std::fs::create_dir_all(dir.join("Scripts")).unwrap();
+        std::fs::write(dir.join("Scripts/effect_manager.gd"), "extends Node\n").unwrap();
+        std::fs::write(
+            dir.join("Scripts/effect_manager.gd.uid"),
+            "uid://bb1ewunp0bc47\n",
+        )
+        .unwrap();
+        let root = dir.to_string_lossy().to_string();
+
+        let content = "[autoload]\nEffectManager=\"*uid://bb1ewunp0bc47\"\n";
+        let got = autoload_script_paths(content, &root);
+        assert_eq!(
+            got,
+            vec![(
+                "EffectManager".to_string(),
+                "Scripts/effect_manager.gd".to_string()
+            )]
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn autoload_script_paths_skips_scene_backed_uid() {
+        let dir = autoload_temp_dir("scriptpaths-scene");
+        std::fs::create_dir_all(dir.join("Entities")).unwrap();
+        std::fs::write(
+            dir.join("Entities/ComboUI.tscn"),
+            "[gd_scene format=3 uid=\"uid://bddoi8q2q2olp\"]\n",
+        )
+        .unwrap();
+        let root = dir.to_string_lossy().to_string();
+
+        let content = "[autoload]\nComboUi=\"*uid://bddoi8q2q2olp\"\n";
+        assert!(
+            autoload_script_paths(content, &root).is_empty(),
+            "scene-backed uid autoload has no F1 script binding"
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
 }
diff --git a/crates/codegraph-resolve/src/frameworks/godot_scene.rs b/crates/codegraph-resolve/src/frameworks/godot_scene.rs
index 7d29e2f..699407d 100644
--- a/crates/codegraph-resolve/src/frameworks/godot_scene.rs
+++ b/crates/codegraph-resolve/src/frameworks/godot_scene.rs
@@ -240,6 +240,72 @@ pub(crate) fn scene_uid_map(project_root: &str) -> BTreeMap<String, String> {
 /// `.godot/` cache and any hidden dir (`.git`, etc.). Errors are ignored
 /// (tolerant walk); ordering is imposed by the caller's sort.
 fn collect_tscn_files(dir: &Path, out: &mut Vec<PathBuf>) {
+    collect_files_with_suffix(dir, ".tscn", out);
+}
+
+/// Build a deterministic `uid://<id>` → repo-relative `.gd` script-path map by
+/// reading every `<script>.gd.uid` SIDECAR under `project_root`.
+///
+/// Godot writes a `<script>.gd.uid` sidecar next to each GDScript, whose sole
+/// content is that script's `uid://<id>` handle — the id an `[autoload]`
+/// `Name="*uid://<id>"` (script autoload) points at. This mirrors
+/// [`scene_uid_map`]: the discovered sidecars are sorted lexicographically
+/// before parsing and the map is FIRST-WRITE-WINS on a duplicate uid, so the
+/// result is independent of directory-iteration order. Each entry maps the uid
+/// to the sidecar's own path with the trailing `.uid` stripped (the `.gd`),
+/// repo-relative with `/`. An unreadable sidecar, or one whose content is not a
+/// `uid://…` line, contributes nothing. An empty or unreadable `project_root`
+/// yields an empty map.
+pub(crate) fn gd_uid_sidecar_map(project_root: &str) -> BTreeMap<String, String> {
+    let mut out: BTreeMap<String, String> = BTreeMap::new();
+    if project_root.is_empty() {
+        return out;
+    }
+    let root = Path::new(project_root);
+    let mut uid_files: Vec<PathBuf> = Vec::new();
+    collect_files_with_suffix(root, ".gd.uid", &mut uid_files);
+    uid_files.sort();
+    for full in uid_files {
+        let Ok(rel) = full.strip_prefix(root) else {
+            continue;
+        };
+        let rel = rel.to_string_lossy().replace('\\', "/");
+        let Some(gd_path) = rel.strip_suffix(".uid") else {
+            continue;
+        };
+        let Ok(content) = std::fs::read_to_string(&full) else {
+            continue;
+        };
+        if let Some(uid) = parse_uid_sidecar(&content) {
+            out.entry(uid).or_insert_with(|| gd_path.to_string());
+        }
+    }
+    out
+}
+
+/// Parse a `<script>.gd.uid` sidecar's content into its `uid://<id>` handle.
+/// The sidecar's only meaningful line is the full `uid://<id>` string; the
+/// first non-blank, non-comment line starting with `uid://` is returned (scheme
+/// kept, matching how the id appears in `[autoload]`). Any other content yields
+/// `None`.
+fn parse_uid_sidecar(content: &str) -> Option<String> {
+    for raw_line in content.lines() {
+        let line = raw_line.trim();
+        if line.is_empty() || is_comment(line) {
+            continue;
+        }
+        if line.starts_with("uid://") {
+            return Some(line.to_string());
+        }
+        return None;
+    }
+    None
+}
+
+/// Recursively collect files whose name ends in `suffix` under `dir`, skipping
+/// any hidden dir (`.godot/`, `.git`, etc.). Errors are ignored (tolerant
+/// walk); ordering is imposed by the caller's sort.
+fn collect_files_with_suffix(dir: &Path, suffix: &str, out: &mut Vec<PathBuf>) {
     let Ok(entries) = std::fs::read_dir(dir) else {
         return;
     };
@@ -254,9 +320,9 @@ fn collect_tscn_files(dir: &Path, out: &mut Vec<PathBuf>) {
                 .and_then(|n| n.to_str())
                 .is_some_and(|n| n.starts_with('.'));
             if !skip {
-                collect_tscn_files(&path, out);
+                collect_files_with_suffix(&path, suffix, out);
             }
-        } else if is_tscn(&path.to_string_lossy()) {
+        } else if path.to_string_lossy().ends_with(suffix) {
             out.push(path);
         }
     }
@@ -702,4 +768,56 @@ mod tests {
     fn scene_uid_map_empty_root_is_empty() {
         assert!(scene_uid_map("").is_empty());
     }
+
+    #[test]
+    fn gd_uid_sidecar_map_reads_uid_and_maps_to_gd() {
+        let dir = temp_dir("sidecar-basic");
+        std::fs::create_dir_all(dir.join("Scripts/Autoloads")).unwrap();
+        std::fs::write(
+            dir.join("Scripts/Autoloads/effect_manager.gd"),
+            "extends Node\n",
+        )
+        .unwrap();
+        std::fs::write(
+            dir.join("Scripts/Autoloads/effect_manager.gd.uid"),
+            "uid://bb1ewunp0bc47\n",
+        )
+        .unwrap();
+        let map = gd_uid_sidecar_map(&dir.to_string_lossy());
+        assert_eq!(
+            map.get("uid://bb1ewunp0bc47").map(String::as_str),
+            Some("Scripts/Autoloads/effect_manager.gd")
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn gd_uid_sidecar_map_first_write_wins_on_dup() {
+        let dir = temp_dir("sidecar-dup");
+        std::fs::write(dir.join("a.gd.uid"), "uid://same\n").unwrap();
+        std::fs::write(dir.join("b.gd.uid"), "uid://same\n").unwrap();
+        let map = gd_uid_sidecar_map(&dir.to_string_lossy());
+        assert_eq!(
+            map.get("uid://same").map(String::as_str),
+            Some("a.gd"),
+            "sorted walk + first-write-wins picks the lexicographically first path"
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn gd_uid_sidecar_map_unknown_uid_absent() {
+        let dir = temp_dir("sidecar-empty");
+        std::fs::write(dir.join("noise.gd.uid"), "not-a-uid-line\n").unwrap();
+        let map = gd_uid_sidecar_map(&dir.to_string_lossy());
+        assert!(
+            !map.contains_key("uid://missing"),
+            "an absent uid maps to nothing"
+        );
+        assert!(
+            map.is_empty(),
+            "a sidecar without a uid:// line contributes nothing"
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
 }
diff --git a/crates/codegraph-store/src/queries.rs b/crates/codegraph-store/src/queries.rs
index f92d220..d6377b3 100644
--- a/crates/codegraph-store/src/queries.rs
+++ b/crates/codegraph-store/src/queries.rs
@@ -1182,6 +1182,42 @@ impl Store {
         Ok(out)
     }
 
+    /// The Godot `run/main_scene` reverse-dependency lane. The main-scene ref is
+    /// emitted UNTAGGED (`reference_subkind = NULL`), so
+    /// [`Self::dependent_file_paths_unresolved`]'s 6-subkind allow-list — which
+    /// guards other-language byte-stability — deliberately excludes it. This
+    /// dedicated lane surfaces it without loosening that allow-list: it matches
+    /// only `unresolved_refs` rows whose OWNING file is a `project.godot`
+    /// (basename gate) AND whose `reference_subkind IS NULL` AND whose
+    /// `res://`-stripped, `/`-normalized `reference_name` equals `file_path`. The
+    /// `project.godot` origin gate means a non-Godot None-subkind ref is never
+    /// returned, so other languages stay byte-unchanged. Golden-neutral; returns
+    /// DISTINCT referrers in scan order (caller sorts/dedups).
+    pub fn dependent_file_paths_main_scene(
+        &self,
+        file_path: &str,
+    ) -> rusqlite::Result<Vec<String>> {
+        let target = strip_res_scheme(&file_path.replace('\\', "/")).to_string();
+        let mut stmt = self.conn.prepare(
+            "SELECT DISTINCT file_path, reference_name FROM unresolved_refs \
+             WHERE reference_subkind IS NULL",
+        )?;
+        let rows = stmt.query_map([], |row| {
+            Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
+        })?;
+        let mut out = Vec::new();
+        for row in rows {
+            let (from_file, reference_name) = row?;
+            if !is_project_godot_path(&from_file) {
+                continue;
+            }
+            if strip_res_scheme(&reference_name.replace('\\', "/")) == target {
+                out.push(from_file);
+            }
+        }
+        Ok(out)
+    }
+
     /// Godot loader-side reverse-dependency lane. A GDScript
     /// `preload/load("res://X")` RESOLVES to an `import:` node whose `name` is the
     /// `res://` path and whose `file_path` is the LOADER script. When `X` is a
@@ -1494,6 +1530,12 @@ fn strip_res_scheme(s: &str) -> &str {
     s.strip_prefix("res://").unwrap_or(s)
 }
 
+fn is_project_godot_path(path: &str) -> bool {
+    path.rsplit(['/', '\\'])
+        .next()
+        .is_some_and(|base| base == "project.godot")
+}
+
 fn parse_language(value: String) -> rusqlite::Result<Language> {
     let language = match value.as_str() {
         "typescript" => Language::TypeScript,
@@ -2686,6 +2728,70 @@ mod tests {
         );
     }
 
+    #[test]
+    fn dependent_file_paths_main_scene_surfaces_untagged_project_godot_only() {
+        let mut store = store("main-scene-lane");
+        store
+            .upsert_nodes(&[
+                node("godot:project", "project", "project.godot"),
+                node("function:rust", "user", "src/main.rs"),
+            ])
+            .unwrap();
+        let mk = |from: &str,
+                  name: &str,
+                  file: &str,
+                  lang: Language,
+                  subkind: Option<ReferenceSubkind>| UnresolvedRef {
+            id: None,
+            from_node_id: from.to_string(),
+            reference_name: name.to_string(),
+            reference_kind: EdgeKind::References,
+            line: 1,
+            col: 0,
+            candidates: None,
+            file_path: file.to_string(),
+            language: lang,
+            is_function_ref: false,
+            reference_subkind: subkind,
+        };
+        store
+            .insert_unresolved_refs(&[
+                mk(
+                    "godot:project",
+                    "res://scenes/main_menu.tscn",
+                    "project.godot",
+                    Language::GodotProject,
+                    None,
+                ),
+                mk(
+                    "function:rust",
+                    "scenes/main_menu.tscn",
+                    "src/main.rs",
+                    Language::Rust,
+                    None,
+                ),
+            ])
+            .unwrap();
+
+        let referrers = store
+            .dependent_file_paths_main_scene("scenes/main_menu.tscn")
+            .unwrap();
+        assert_eq!(
+            referrers,
+            vec!["project.godot".to_string()],
+            "the untagged main_scene ref surfaces its project.godot origin; the non-Godot None ref is excluded by the origin gate"
+        );
+
+        let mut unresolved = store
+            .dependent_file_paths_unresolved("scenes/main_menu.tscn")
+            .unwrap();
+        unresolved.sort();
+        assert!(
+            unresolved.is_empty(),
+            "the 6-subkind allow-list still excludes the untagged main_scene ref (byte-unchanged)"
+        );
+    }
+
     #[test]
     fn delete_resolved_edges_and_named_target_sources() {
         let mut store = store("resolved-edges");
diff --git a/docs/equivalence.md b/docs/equivalence.md
index 91d14d0..b929fd9 100644
--- a/docs/equivalence.md
+++ b/docs/equivalence.md
@@ -155,9 +155,17 @@ extraction that the mini fixture cannot reach — there are no `.gd`/`.tscn`/
   (`Calls` edges).
 - **F3** — a `.tscn` `ExtResource` script attachment (`main.tscn` →
   `stage_manager.gd`), captured as a `script_attach` unresolved-ref subkind.
+- **UID-form autoloads** — a sidecar-UID SCRIPT autoload
+  (`EffectManager="*uid://…"` resolved through `effect_manager.gd.uid` →
+  `effect_manager.gd`, with an `EffectManager.apply_effect()` F1 method edge) and
+  a header-UID SCENE autoload (`ComboUi="*uid://…"` resolved through
+  `combo_ui.tscn`'s `uid=` header, registration-only). Both emit an
+  `Autoload`-subkind UNRESOLVED ref; the `.gd.uid` sidecar is NOT indexed (it maps
+  to `Language::Unknown`, so it is neither a file record nor a node).
 
 The minimal source corpus lives at `crates/codegraph-bench/fixtures/godot/`
-(`project.godot`, `game_flow.gd`, `stage_manager.gd`, `main.tscn`).
+(`project.godot`, `game_flow.gd`, `stage_manager.gd`, `main.tscn`,
+`effect_manager.gd`, `effect_manager.gd.uid`, `combo_ui.tscn`).
 
 Regenerate the committed database + canonical JSON reproducibly from the corpus:
 
diff --git a/docs/godot.md b/docs/godot.md
index 6113a67..8a74d36 100644
--- a/docs/godot.md
+++ b/docs/godot.md
@@ -349,6 +349,20 @@ having no DSL config at all.
 
 ## Limitations
 
+- **UID-input edits need `index --force`, not incremental `sync`.** Autoload and
+  `run/main_scene` values may be `uid://…` handles resolved through the project's
+  `*.gd.uid` sidecars and `.tscn` `uid=` headers. Those UID inputs are read at
+  index time; `.gd.uid` sidecars are unindexed, so an incremental `codegraph
+sync` that touches only a `.gd.uid`, a `.tscn` uid header, or a file rename does
+  NOT re-extract `project.godot` and the UID→target edge can go stale. Re-run
+  `codegraph index --force` after editing autoload or main-scene UIDs. Tracked as
+  follow-up `godot-uid-incremental-invalidation` (covers both the autoload UID and
+  the pre-existing main_scene UID).
+- **Scene-backed autoloads are registration-only.** A `uid://…` autoload that
+  resolves to a `.tscn` (scene autoload) emits the `project.godot → .tscn`
+  registration reference but no F1 `Autoload.method()` binding to the scene's
+  attached script. Script autoloads (a `.gd.uid` sidecar or a `res://…` `.gd`
+  path) keep full F1 method binding.
 - **Computed targets are unresolved, not fabricated.** `get_node(var)`,
   `call(method_name_var)`, and similar patterns where the argument is not a
   string literal cannot be resolved statically. They appear as
diff --git a/reference/golden/godot/colby.db b/reference/golden/godot/colby.db
index 1352abf76f0eab5cc8992a8ea5b1ab69b75c5184..78a0dc85c452ca35b37a3ab12b654b88d30088ab 100644
GIT binary patch
delta 10221
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

delta 4571
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
Kyi}zqCI11T1D6K?

diff --git a/reference/golden/godot/edges.json b/reference/golden/godot/edges.json
index ac39053..7331aad 100644
--- a/reference/golden/godot/edges.json
+++ b/reference/golden/godot/edges.json
@@ -1,4 +1,28 @@
 [
+  {
+    "col": 0,
+    "kind": "calls",
+    "line": 10,
+    "metadata": {
+      "confidence": 0.9,
+      "resolvedBy": "framework"
+    },
+    "provenance": null,
+    "source": "function:e7d6028e334cefe390f5a7b17d18c2de",
+    "target": "constant:49315a6865ec360838012645ac4e5037"
+  },
+  {
+    "col": 0,
+    "kind": "calls",
+    "line": 10,
+    "metadata": {
+      "confidence": 0.9,
+      "resolvedBy": "framework"
+    },
+    "provenance": null,
+    "source": "function:e7d6028e334cefe390f5a7b17d18c2de",
+    "target": "function:579892a37e71bddf1fd52a37ca2f0738"
+  },
   {
     "col": 0,
     "kind": "calls",
@@ -9,7 +33,7 @@
     },
     "provenance": null,
     "source": "function:1f948ab9675bc7bfad6e4e9296fe0017",
-    "target": "function:3e7258a7b719c0eecf053f21cadf499b"
+    "target": "function:2fd9ae68b8cdbe2953bf12997d1e790d"
   },
   {
     "col": 0,
@@ -21,7 +45,7 @@
     },
     "provenance": null,
     "source": "function:1f948ab9675bc7bfad6e4e9296fe0017",
-    "target": "function:ded3bac40c3278b2e878c84f6fd25097"
+    "target": "function:9b775f9daa70467ddf403b28c920ad70"
   },
   {
     "col": 0,
@@ -47,6 +71,15 @@
     "source": "function:e7d6028e334cefe390f5a7b17d18c2de",
     "target": "function:0dba39278ee3bc0185ce741223429845"
   },
+  {
+    "col": null,
+    "kind": "contains",
+    "line": null,
+    "metadata": null,
+    "provenance": null,
+    "source": "file:effect_manager.gd",
+    "target": "function:579892a37e71bddf1fd52a37ca2f0738"
+  },
   {
     "col": null,
     "kind": "contains",
@@ -72,7 +105,7 @@
     "metadata": null,
     "provenance": null,
     "source": "file:stage_manager.gd",
-    "target": "function:3e7258a7b719c0eecf053f21cadf499b"
+    "target": "function:2fd9ae68b8cdbe2953bf12997d1e790d"
   },
   {
     "col": null,
@@ -81,7 +114,7 @@
     "metadata": null,
     "provenance": null,
     "source": "file:stage_manager.gd",
-    "target": "function:ded3bac40c3278b2e878c84f6fd25097"
+    "target": "function:9b775f9daa70467ddf403b28c920ad70"
   },
   {
     "col": null,
diff --git a/reference/golden/godot/files.json b/reference/golden/godot/files.json
index 2bb54ef..0ae0221 100644
--- a/reference/golden/godot/files.json
+++ b/reference/golden/godot/files.json
@@ -1,4 +1,20 @@
 [
+  {
+    "content_hash": "33a6ab1ac82701bd870b22dd52e8677fc23e4099d38947face8b931780fd20bc",
+    "errors": null,
+    "language": "godot_scene",
+    "node_count": 0,
+    "path": "combo_ui.tscn",
+    "size": 81
+  },
+  {
+    "content_hash": "6f5b810b12eeba2d908d628a74a55dd5da8997f2775681cc26c584650d7d5581",
+    "errors": null,
+    "language": "gdscript",
+    "node_count": 2,
+    "path": "effect_manager.gd",
+    "size": 49
+  },
   {
     "content_hash": "40f411be7a8b9048869b5a8902243a44fcb645c67e3c1d2fb05b0f20b5c7075c",
     "errors": null,
@@ -16,19 +32,19 @@
     "size": 170
   },
   {
-    "content_hash": "2c29a56104c250f916b6eefdf70d900e4c59febb9f13bf6b76d0545022c0789b",
+    "content_hash": "b01662a4255e8445a808378889ccf8b38b49d012cd8ed933fa540b5f9e097d60",
     "errors": null,
     "language": "godot_project",
     "node_count": 0,
     "path": "project.godot",
-    "size": 115
+    "size": 183
   },
   {
-    "content_hash": "0d871d1bfe4a545bb3c40492a9215e9927a0e7a32b946cb4fd30140b22ce2b19",
+    "content_hash": "5410c79a7bb764595c01f175fb3533956a84c884801660428bc032b000a01131",
     "errors": null,
     "language": "gdscript",
     "node_count": 6,
     "path": "stage_manager.gd",
-    "size": 302
+    "size": 332
   }
 ]
diff --git a/reference/golden/godot/nodes.json b/reference/golden/godot/nodes.json
index 02868f5..786e80f 100644
--- a/reference/golden/godot/nodes.json
+++ b/reference/golden/godot/nodes.json
@@ -21,6 +21,72 @@
     "type_parameters": null,
     "visibility": null
   },
+  {
+    "decorators": null,
+    "docstring": null,
+    "end_column": 0,
+    "end_line": 3,
+    "file_path": "combo_ui.tscn",
+    "id": "constant:25db4c122f7a0ed9193ff20d7efbc151",
+    "is_abstract": 0,
+    "is_async": 0,
+    "is_exported": 0,
+    "is_static": 0,
+    "kind": "constant",
+    "language": "godot_scene",
+    "name": "ComboUI",
+    "qualified_name": "combo_ui.tscn::ComboUI",
+    "return_type": null,
+    "signature": null,
+    "start_column": 0,
+    "start_line": 3,
+    "type_parameters": null,
+    "visibility": null
+  },
+  {
+    "decorators": null,
+    "docstring": null,
+    "end_column": 0,
+    "end_line": 10,
+    "file_path": "project.godot",
+    "id": "constant:49315a6865ec360838012645ac4e5037",
+    "is_abstract": 0,
+    "is_async": 0,
+    "is_exported": 0,
+    "is_static": 0,
+    "kind": "constant",
+    "language": "godot_project",
+    "name": "EffectManager",
+    "qualified_name": "project.godot::EffectManager",
+    "return_type": null,
+    "signature": "autoload -> effect_manager.gd",
+    "start_column": 0,
+    "start_line": 10,
+    "type_parameters": null,
+    "visibility": null
+  },
+  {
+    "decorators": null,
+    "docstring": null,
+    "end_column": 0,
+    "end_line": 11,
+    "file_path": "project.godot",
+    "id": "constant:6e80876e97762b0f0a93037c431cf364",
+    "is_abstract": 0,
+    "is_async": 0,
+    "is_exported": 0,
+    "is_static": 0,
+    "kind": "constant",
+    "language": "godot_project",
+    "name": "ComboUi",
+    "qualified_name": "project.godot::ComboUi",
+    "return_type": null,
+    "signature": null,
+    "start_column": 0,
+    "start_line": 11,
+    "type_parameters": null,
+    "visibility": null
+  },
   {
     "decorators": null,
     "docstring": null,
@@ -43,6 +109,28 @@
     "type_parameters": null,
     "visibility": null
   },
+  {
+    "decorators": null,
+    "docstring": null,
+    "end_column": 0,
+    "end_line": 5,
+    "file_path": "effect_manager.gd",
+    "id": "file:effect_manager.gd",
+    "is_abstract": 0,
+    "is_async": 0,
+    "is_exported": 0,
+    "is_static": 0,
+    "kind": "file",
+    "language": "gdscript",
+    "name": "effect_manager.gd",
+    "qualified_name": "effect_manager.gd",
+    "return_type": null,
+    "signature": null,
+    "start_column": 0,
+    "start_line": 1,
+    "type_parameters": null,
+    "visibility": null
+  },
   {
     "decorators": null,
     "docstring": null,
@@ -69,7 +157,7 @@
     "decorators": null,
     "docstring": null,
     "end_column": 0,
-    "end_line": 16,
+    "end_line": 17,
     "file_path": "stage_manager.gd",
     "id": "file:stage_manager.gd",
     "is_abstract": 0,
@@ -135,9 +223,9 @@
     "decorators": null,
     "docstring": null,
     "end_column": 5,
-    "end_line": 12,
+    "end_line": 13,
     "file_path": "stage_manager.gd",
-    "id": "function:3e7258a7b719c0eecf053f21cadf499b",
+    "id": "function:2fd9ae68b8cdbe2953bf12997d1e790d",
     "is_abstract": 0,
     "is_async": 0,
     "is_exported": 0,
@@ -149,7 +237,29 @@
     "return_type": "void",
     "signature": "(source)",
     "start_column": 0,
-    "start_line": 11,
+    "start_line": 12,
+    "type_parameters": null,
+    "visibility": null
+  },
+  {
+    "decorators": null,
+    "docstring": null,
+    "end_column": 5,
+    "end_line": 4,
+    "file_path": "effect_manager.gd",
+    "id": "function:579892a37e71bddf1fd52a37ca2f0738",
+    "is_abstract": 0,
+    "is_async": 0,
+    "is_exported": 0,
+    "is_static": 0,
+    "kind": "function",
+    "language": "gdscript",
+    "name": "apply_effect",
+    "qualified_name": "apply_effect",
+    "return_type": "void",
+    "signature": "()",
+    "start_column": 0,
+    "start_line": 3,
     "type_parameters": null,
     "visibility": null
   },
@@ -157,9 +267,9 @@
     "decorators": null,
     "docstring": null,
     "end_column": 5,
-    "end_line": 15,
+    "end_line": 16,
     "file_path": "stage_manager.gd",
-    "id": "function:ded3bac40c3278b2e878c84f6fd25097",
+    "id": "function:9b775f9daa70467ddf403b28c920ad70",
     "is_abstract": 0,
     "is_async": 0,
     "is_exported": 0,
@@ -171,15 +281,15 @@
     "return_type": "void",
     "signature": "(event)",
     "start_column": 0,
-    "start_line": 14,
+    "start_line": 15,
     "type_parameters": null,
     "visibility": null
   },
   {
     "decorators": null,
     "docstring": null,
-    "end_column": 25,
-    "end_line": 9,
+    "end_column": 29,
+    "end_line": 10,
     "file_path": "stage_manager.gd",
     "id": "function:e7d6028e334cefe390f5a7b17d18c2de",
     "is_abstract": 0,
diff --git a/reference/golden/godot/refs.json b/reference/golden/godot/refs.json
index bf1c084..291e9f8 100644
--- a/reference/golden/godot/refs.json
+++ b/reference/golden/godot/refs.json
@@ -10,6 +10,28 @@
     "reference_name": "stage_manager.gd",
     "reference_subkind": "script_attach"
   },
+  {
+    "candidates": null,
+    "col": 0,
+    "file_path": "project.godot",
+    "from_node_id": "constant:49315a6865ec360838012645ac4e5037",
+    "language": "godot_project",
+    "line": 10,
+    "reference_kind": "references",
+    "reference_name": "effect_manager.gd",
+    "reference_subkind": "autoload"
+  },
+  {
+    "candidates": null,
+    "col": 0,
+    "file_path": "project.godot",
+    "from_node_id": "constant:6e80876e97762b0f0a93037c431cf364",
+    "language": "godot_project",
+    "line": 11,
+    "reference_kind": "references",
+    "reference_name": "combo_ui.tscn",
+    "reference_subkind": "autoload"
+  },
   {
     "candidates": null,
     "col": 0,
@@ -51,6 +73,16 @@
     "reference_kind": "calls",
     "reference_name": "Callable"
   },
+  {
+    "candidates": null,
+    "col": 8,
+    "file_path": "effect_manager.gd",
+    "from_node_id": "file:effect_manager.gd",
+    "language": "gdscript",
+    "line": 1,
+    "reference_kind": "extends",
+    "reference_name": "Node"
+  },
   {
     "candidates": null,
     "col": 8,