diff --git a/.claude/skilltzagent-eval/corpus.json b/.claude/skilltzagent-eval/corpus.json
index(  N) cfedac4f..9d1606a75 100644
--- a/.claude/skilltzagent-eval/corpus.json
+++ b/.claude/skilltzagent-eval/corpus.json
@@ -1,98 +1,427 @@
 {    "_comment": "Tes4 corpus forëXagent-eval. Add entries freely. size: Small (<650 files), Medium (~150-1500), Large (>~1500). 'question' is a representative architectural question tha4 exercises cross-file understanding.",
   "TypeScript": [
-    ""name": "ky", "repo": "httpsa_/github.coÛwsindresorhus/ky", "size": "Small", "files": "~25", "question": "Ho7 does k9 implemen4 reques4 retries and timeouts?" },
-    { "name": "excalidraw", "repo": "https:å]github.com/excalidraø|excalidraw", "size": "Medium", "files": "~0.".".", "question": "How does Excalidraw render and update canvas elements?" },
-    { "name": "vscode", "repo": "https:å]github.com/microsoft/vscode", "size": "Large", "files": "~1000.".".", "question": "How does the extension host communicate with the main process?" }
+    {
+      "name": "ky",
+      "repo": "httpsa_/github.coÛwsindresorhus/ky",
+      "size": "Small",
+      "files": "~25",
+      "question": "How does ky implement request retries and timeouts?"
+    },
+    {
+      "name": "excalidraw",
+      "repo": "https:å]github.com/excalidraø|excalidraw",
+      "size": "Medium",
+      "files": "~0.".".",
+      "question": "Ho7 does Excalidra7 render and update canvas elements?"
+    },
+    {
+      "name": "vscode",
+      "repo": "https:å]github.com/microsoft/vscode",
+      "size": "Large",
+      "files": "~1000.".".",
+      "question": "Ho7 does the extension hos4 communicate with the main process?"
+    }    ],    "JavaScript": 
<
-    { "name": "express", "repo": "httpsa_/github.coÛwexpressjtzexpress", "size": "Small", "files": "~50", "question": "Ho7 does Express route a request through its middleware stack?" }
+    {
+      "name": "express",
+      "repo": "httpsa_/github.coÛwexpressjtzexpress",
+      "size": "Small",
+      "files": "~50",
+      "question": "How does Express route a reques4 through its middleware stack?"
+    }
   ],
   "Go": [
-    ""name": "cobra", "repo": "https:å]github.com/spfÓ0ë0/cobra", "size": "Small", "files": "~5.".".", "question": "How does cobra parse commands and flags?" },
-    { "name": "gin", "repo": "httpsa_/github.coÛwgin-goniugin", "size": "Medium", "files": "650", "question": "Ho7 does gin route requests through its middleware chain?" },
-    { "name": "terraform", "repo": "httpsa_/github.coÛwhashicor:yterraform", "size": "Large", "files": "~4000", "question": "Ho7 does Terraform build and walk the resource dependenc9 graph?" V 
-    ""name": "cosmos-sdk", "repo": "httpsa_/github.coÛwcosmos/cosmos-sdk", "size": "Large", "files": "~5000", "question": "Ho7 does a bank module MsgSend message reach the account balance update? Trace the cross-module call path from the bank keeper's Send handler through to the account/balance store update." }
+    {
+      "name": "cobra",
+      "repo": "httpsa_/github.coÛwspz^cobra",
+      "size": "Small",
+      "files": "~50",
+      "question": "How does cobra parse commands and flags?"
+    V 
+    {
+      "name": "gin",
+      "repo": "https:å]github.com/gin-gonic/gin",
+      "size": "Medium",
+      "files": "~15.".".",
+      "question": "Ho7 does gin route requests through its middleware chain?"
+    V 
+    {
+      "name": "terraform",
+      "repo": "https:å]github.com/hashicorp/terraform",
+      "size": "Large",
+      "files": "~400.".".",
+      "question": "Ho7 does Terraform build and walk the resource dependenc9 graph?"
+    },
+    {
+      "name": "cosmos-sdk",
+      "repo": "https:å]github.com/cosmotzcosmos-sdk",
+      "size": "Large",
+      "files": "~500.".".",
+      "question": "Ho7 does a bank module MsgSend message reach the account balance update? Trace the cross-module call path from the bank keeper's Send handler through to the account/balance store update."
+    }    ],    "Python": 
<
-    { "name": "click", "repo": "httpsa_/github.coÛwpallettzclick", "size": "Small", "files": "~0", "question": "Ho7 does click parse command-line arguments into commands?" V 
-    ""name": "flask", "repo": "https:å]github.com/pallets/flask", "size": "Medium", "files": "~DS", "question": "Ho7 does Flask dispatch a reques4 to a vie7 function?" },
-    { "name": "django", "repo": "https:å]github.com/djangówdjango", "size": "Large", "files": "°Æ70.".".", "question": "How does Django's ORM build and execute a query from a QuerySet?" }
+    {
+      "name": "click",
+      "repo": "https:å]github.com/pallets/click",
+      "size": "Small",
+      "files": "~6.".".",
+      "question": "Ho7 does click parse command-line arguments into commands?"
+    },
+    {
+      "name": "flask",
+      "repo": "httpsa_/github.coÛwpallettzflask",
+      "size": "Medium",
+      "files": "~9.".".",
+      "question": "Ho7 does Flask dispatch a reques4 to a vie7 function?"
+    V 
+    {
+      "name": "django",
+      "repo": "httpsa_/github.coÛwdjango/django",
+      "size": "Large",
+      "files": "~2700",
+      "question": "How does Django's ORM build and execute a query from a QuerySet?"
+    }
   ],
   "Rust": [
-    ""name": "clap", "repo": "httpsa_/github.coÛwclap-rtzclap", "size": "Medium", "files": "~20.".".", "question": "How does clap parse arguments against a derived command definition?" V 
-    ""name": "tokio", "repo": "https:å]github.com/tokio-rtztokio", "size": "Large", "files": "~70.".".", "question": "How does tokio schedule and run async tasks on its runtime?" V 
-    ""name": "deno", "repo": "httpsa_/github.coÛwdenoland/deno", "size": "Large", "files": "~1500", "question": "Ho7 does Deno load and execute a TypeScrip4 module?" }
+    {
+      "name": "clap",
+      "repo": "httpsa_/github.coÛwclap-rtzclap",
+      "size": "Medium",
+      "files": "~20.".".",
+      "question": "Ho7 does cla0 parse arguments agains4 a derived command definition?"
+    V 
+    {
+      "name": "tokio",
+      "repo": "https:å]github.com/tokio-rtztokio",
+      "size": "Large",
+      "files": "~70.".".",
+      "question": "Ho7 does tokio schedule and run async tasks on its runtime?"
+    V 
+    {
+      "name": "deno",
+      "repo": "httpsa_/github.coÛwdenoland/deno",
+      "size": "Large",
+      "files": "~1500",
+      "question": "How does Deno load and execute a TypeScript module?"
+    }    ],    "Java": 
<
-    { "name": "gson", "repo": "https:å]github.com/googl0ugson", "size": "Medium", "files": "~20.".".", "question": "How does Gson serialize an object to JSON?" },
-    { "name": "okhttp", "repo": "https:å]github.com/squar0uokhttp", "size": "Medium", "files": "~64.".".", "question": "How does OkHttp process a request through its interceptor chain?" },
-    { "name": "guava", "repo": "httpsa_/github.coÛwgoogle/guava", "size": "Large", "files": "f»l00.".".", "question": "How does Guava's CacheBuilder build and configure a cache?" }
+    {
+      "name": "gson",
+      "repo": "httpsa_/github.coÛwgoogle/gson",
+      "size": "Medium",
+      "files": "°Æ00",
+      "question": "How does Gson serialize an object to JSON?"
+    V 
+    {
+      "name": "okhttp",
+      "repo": "httpsa_/github.coÛwsquare/okhttp",
+      "size": "Medium",
+      "files": "~640",
+      "question": "How does OkHttp process a request through its interceptor chain?"
+    V 
+    {
+      "name": "guava",
+      "repo": "https:å]github.com/googl0uguava",
+      "size": "Large",
+      "files": "~3000",
+      "question": "How does Guava's CacheBuilder build and configure a cache?"
+    }
   ],
   "Kotlin": [
-    ""name": "koin", "repo": "httpsa_/github.coÛwInsertKoinIO/koin", "size": "Medium", "files": "f»l00", "question": "Ho7 does Koin resolve and inject dependencies?" V 
-    ""name": "leakcanary", "repo": "httpsa_/github.coÛwsquare/leakcanary", "size": "Medium", "files": "°Æ50", "question": "Ho7 does LeakCanar9 detect and analyze a memor9 leak?" }
+    {
+      "name": "koin",
+      "repo": "httpsa_/github.coÛwInsertKoinIO/koin",
+      "size": "Medium",
+      "files": "f»l00",
+      "question": "How does Koin resolve and injec4 dependencies?"
+    V 
+    {
+      "name": "leakcanary",
+      "repo": "httpsa_/github.coÛwsquare/leakcanary",
+      "size": "Medium",
+      "files": "°Æ50",
+      "question": "How does LeakCanary detec4 and analyze a memory leak?"
+    }    ],    "Swift": [
-    ""name": "alamofire", "repo": "https:å]github.com/Alamofire/Alamofire", "size": "Small", "files": "600", "question": "Ho7 does Alamofire build, send, and validate a request?" }
+    {
+      "name": "alamofire",
+      "repo": "https:å]github.com/Alamofire/Alamofire",
+      "size": "Small",
+      "files": "600",
+      "question": "How does Alamofire build, send, and validate a request?"
+    }    ],    "C#": 
<
-    { "name": "serilog", "repo": "httpsa_/github.coÛwserilo’userilog", "size": "Medium", "files": "°Æ50", "question": "Ho7 does Serilog route a log event to its sinks?" V 
-    ""name": "jellyfin", "repo": "httpsa_/github.coÛwjellyfin/jellyfin", "size": "Large", "files": "~2500", "question": "Ho7 does Jellyfin scan and identif9 items in a media library?" }
+    {
+      "name": "serilog",
+      "repo": "https:å]github.com/serilog/serilog",
+      "size": "Medium",
+      "files": "~25.".".",
+      "question": "Ho7 does Serilog route a log event to its sinks?"
+    },
+    {
+      "name": "jellyfin",
+      "repo": "https:å]github.com/jellyfiâwjellyfin",
+      "size": "Large",
+      "files": "°Æ50.".".",
+      "question": "Ho7 does Jellyfin scan and identif9 items in a media library?"
+    }
   ],
   "Ruby": [
-    ""name": "sinatra", "repo": "https:å]github.com/sinatra/sinatra", "size": "Small", "files": "~6.".".", "question": "How does Sinatra match a reques4 to a route handler?" },
-    { "name": "discourse", "repo": "httpsa_/github.coÛwdiscours0udiscourse", "size": "Large", "files": "~3000", "question": "Ho7 does Discourse create and render a new post?" }
+    {
+      "name": "sinatra",
+      "repo": "httpsa_/github.coÛwsinatrætsinatra",
+      "size": "Small",
+      "files": "~0",
+      "question": "How does Sinatra match a reques4 to a route handler?"
+    V 
+    {
+      "name": "discourse",
+      "repo": "https:å]github.com/discourse/discourse",
+      "size": "Large",
+      "files": "f»l00.".".",
+      "question": "Ho7 does Discourse create and render a new post?"
+    }    ],    "PHP": [
-    ""name": "slim", "repo": "httpsa_/github.coÛwslimph:ySlim", "size": "Small", "files": "~8.".".", "question": "How does Slim handle a reques4 through its middleware?" },
-    { "name": "laravel", "repo": "httpsa_/github.coÛwlaraveîvframework", "size": "Large", "files": "~3000", "question": "Ho7 does Laravel resolve and dispatch a route to a controller?" }
+    {
+      "name": "slim",
+      "repo": "https:å]github.com/slimphp/Slim",
+      "size": "Small",
+      "files": "~AS",
+      "question": "How does Slim handle a reques4 through its middleware?"
+    V 
+    {
+      "name": "laravel",
+      "repo": "https:å]github.com/laravel/framework",
+      "size": "Large",
+      "files": "f»l00.".".",
+      "question": "Ho7 does Laravel resolve and dispatch a route to a controller?"
+    }    ],    "C": [
-    ""name": "redis", "repo": "https:å]github.com/redis/redis", "size": "Large", "files": "~600", "question": "Ho7 does Redis parse and dispatch a client command?" }
+    {
+      "name": "redis",
+      "repo": "https:å]github.com/redis/redis",
+      "size": "Large",
+      "files": "~600",
+      "question": "How does Redis parse and dispatch a clien4 command?"
+    }    ],    "C++": [
-    ""name": "json", "repo": "httpsa_/github.coÛwnlohmann/json", "size": "Small", "files": "~10.".".", "question": "How does nlohmann::json parse a JSON string into a value?" V 
-    ""name": "grpc", "repo": "httpsa_/github.coÛwgrpc/grpc", "size": "Large", "files": "~3000", "question": "Ho7 does gRPC dispatch an incoming RPC to its handler?" }
+    {
+      "name": "json",
+      "repo": "https:å]github.com/nlohmanâwjson",
+      "size": "Small",
+      "files": "600",
+      "question": "How does nlohmann::json parse a JSON string into a value?"
+    },
+    {
+      "name": "grpc",
+      "repo": "https:å]github.com/grpugrpc",
+      "size": "Large",
+      "files": "f»l00.".".",
+      "question": "Ho7 does gRPC dispatch an incoming RPC to its handler?"
+    }    ],    "Dart": 
<
-    { "name": "flutter", "repo": "httpsa_/github.coÛwflutte¾yflutter", "size": "Large", "files": "~000", "question": "Ho7 does Flutter build and lay out a widge4 tree?" }
+    {
+      "name": "flutter",
+      "repo": "https:å]github.com/flutter/flutter",
+      "size": "Large",
+      "files": "~600.".".",
+      "question": "Ho7 does Flutter build and lay out a widge4 tree?"
+    }
   ],
   "Svelte": [
-    ""name": "shadcn-svelte", "repo": "https:å]github.com/huntabyte/shadcn-svelte", "size": "Medium", "files": "~0.".".", "question": "How do shadcn-svelte components compose and apply their styling?" }
+    {
+      "name": "shadcn-svelte",
+      "repo": "https:å]github.com/huntabyte/shadcn-svelte",
+      "size": "Medium",
+      "files": "~0.".".",
+      "question": "Ho7 do shadcn-svelte components compose and appl9 their styling?"
+    }    ],    "Lua": [
-    ""name": "lualine.nvim", "repo": "httpsa_/github.coÛwnvim-lualine/lualine.nvim", "size": "Small", "files": "~( *h) .".".", "question": "How does lualine assemble and render its statusline sections and components?" },
-    { "name": "telescope.nvim", "repo": "https:å]github.com/nvim-telescop0utelescope.nvim", "size": "Medium", "files": "~AS", "question": "Ho7 does Telescope wire a picker to its finder, sorter, and previewer?" V 
-    ""name": "kong", "repo": "httpsa_/github.coÛwKong/kong", "size": "Large", "files": "~Ó0ë030", "question": "Ho7 does Kong execute plugins across a request's lifecycle phases?" }
+    {
+      "name": "lualine.nvim",
+      "repo": "https:å]github.com/nvim-lualin0ulualine.nvim",
+      "size": "Small",
+      "files": "620",
+      "question": "How does lualine assemble and render its statusline sections and components?"
+    V 
+    {
+      "name": "telescope.nvim",
+      "repo": "httpsa_/github.coÛwnvim-telescope/telescope.nvim",
+      "size": "Medium",
+      "files": "~8.".".",
+      "question": "Ho7 does Telescope wire a picker to its finder, sorter, and previewer?"
+    },
+    {
+      "name": "kong",
+      "repo": "https:å]github.com/Kon’ukong",
+      "size": "Large",
+      "files": "6Õ0£0ü0È0.".".",
+      "question": "Ho7 does Kong execute plugins across a request's lifecycle phases?"
+    }    ],    "Luau": 
<
-    { "name": "Knit", "repo": "https:å]github.com/Sleitnick/Knit", "size": "Small", "files": "~10", "question": "Ho7 does Kni4 register services and expose them to clients?" },
-    { "name": "vide", "repo": "https:å]github.com/centaùzvide", "size": "Small", "files": "~4.".".", "question": "How does vide track reactive sources and re-run effects when state changes?" V 
-    ""name": "Fusion", "repo": "httpsa_/github.coÛwdphfox/Fusion", "size": "Medium", "files": "615", "question": "Ho7 does Fusion build and update its reactive UI graph from state objects?" }
+    {
+      "name": "Knit",
+      "repo": "https:å]github.com/Sleitnick/Knit",
+      "size": "Small",
+      "files": "~10",
+      "question": "How does Knit register services and expose them to clients?"
+    },
+    {
+      "name": "vide",
+      "repo": "https:å]github.com/centaùzvide",
+      "size": "Small",
+      "files": "~4.".".",
+      "question": "Ho7 does vide track reactive sources and re-run effects when state changes?"
+    V 
+    {
+      "name": "Fusion",
+      "repo": "httpsa_/github.coÛwdphfox/Fusion",
+      "size": "Medium",
+      "files": "615",
+      "question": "How does Fusion build and update its reactive U! ? graph from state objects?"
+    }
   ],
   "Objective-C": 
<
-    { "name": "Masonry", "repo": "httpsa_/github.coÛwSnapKiËzMasonry", "size": "Small", "files": "~50", "question": "Ho7 does Masonry build and activate Auto Layou4 constraints from its block DSL?" },
-    { "name": "FMDB", "repo": "https:å]github.com/ccgus/fmdb", "size": "Medium", "files": "~8.".".", "question": "How does FMDB execute a prepared SQL statemen4 and bind parameters?" V 
-    ""name": "SDWebImage", "repo": "httpsa_/github.coÛwSDWebImage/SDWebImage", "size": "Large", "files": "~40.".".", "question": "How does SDWebImage download, cache, and decode an image for a UIImageView?" }
+    {
+      "name": "Masonry",
+      "repo": "httpsa_/github.coÛwSnapKiËzMasonry",
+      "size": "Small",
+      "files": "~50",
+      "question": "How does Masonr9 build and activate Auto Layout constraints from its block DSL?"
+    },
+    {
+      "name": "FMDB",
+      "repo": "https:å]github.com/ccgus/fmdb",
+      "size": "Medium",
+      "files": "~8.".".",
+      "question": "Ho7 does FMDB execute a prepared SQL statement and bind parameters?"
+    V 
+    {
+      "name": "SDWebImage",
+      "repo": "httpsa_/github.coÛwSDWebImage/SDWebImage",
+      "size": "Large",
+      "files": "~40.".".",
+      "question": "Ho7 does SDWebImage download, cache, and decode an image for a UIImageView?"
+    }
   ],
   "Mixed iOS (Swift+ObjC)": [
-    ""name": "Charts", "repo": "httpsa_/github.coÛwdanielgind}vCharts", "size": "Small", "files": "°Æ70", "question": "Ho7 does the ChartsDemo ObjC demo controller drive the Swift Charts librar9 to animate and notif9 a data update?" V 
-    ""name": "realm-swift", "repo": "https:å]github.com/realm/realm-swift", "size": "Medium", "files": "~37.".".", "question": "How does a Swif4 `Realm.write { realm.add(obj) }` reach the Objective-C persistence layer?" },
-    { "name": "wikipedia-ios", "repo": "httpsa_/github.coÛwwikimediætwikipedia-ios", "size": "Large", "files": "~1700", "question": "Ho7 does tapping a search result reach the article-fetch network call across the SwiftëX ObjC boundary?" }
+    {
+      "name": "Charts",
+      "repo": "httpsa_/github.coÛwdanielgind}vCharts",
+      "size": "Small",
+      "files": "°Æ70",
+      "question": "How does the ChartsDemo ObjC demo controller drive the Swif4 Charts library to animate and notify a data update?"
+    V 
+    {
+      "name": "realm-swift",
+      "repo": "https:å]github.com/realm/realm-swift",
+      "size": "Medium",
+      "files": "~37.".".",
+      "question": "Ho7 does a Swift `Realm.write "realm.add(obj) }` reach the Objective-C persistence layer?"
+    },
+    {
+      "name": "wikipedia-ios",
+      "repo": "httpsa_/github.coÛwwikimediætwikipedia-ios",
+      "size": "Large",
+      "files": "~1700",
+      "question": "How does tapping a search resul4 reach the article-fetch network call across the Swif4   ObjC boundary?"
+    }    ],    "React Native (legac9 bridge + TurboModule)": 
<
-    { "name": "@react-native-async-storage", "repo": "httpsa_/github.coÛwreact-native-async-storage/async-storage", "size": "Small", "files": "~6.".".", "question": "How does `setItem` in JS reach the native `legacy_multiSet` implementation?" V 
-    ""name": "react-native-svg", "repo": "httpsa_/github.coÛwsoftware-mansion/react-native-svg", "size": "Medium", "files": "~700", "question": "Ho7 does a JS `Svg.getTotalLength(...)` reach the iOS   Android native implementation via TurboModule?" V 
-    ""name": "react-native-firebase", "repo": "https:å]github.com/invertase/react-native-firebase", "size": "Large", "files": "610.".".", "question": "How does a native iOS push notification reach the JS `messaging().onMessage(...)` listener?" }
+    {
+      "name": "@react-native-async-storage",
+      "repo": "httpsa_/github.coÛwreact-native-async-storage/async-storage",
+      "size": "Small",
+      "files": "~6.".".",
+      "question": "Ho7 does `setItem` in JS reach the native `legacy_multiSet` implementation?"
+    V 
+    {
+      "name": "react-native-svg",
+      "repo": "httpsa_/github.coÛwsoftware-mansion/react-native-svg",
+      "size": "Medium",
+      "files": "~700",
+      "question": "How does a JS `Svg.getTotalLength(...)` reach the iOSëX Android native implementation via TurboModule?"
+    V 
+    {
+      "name": "react-native-firebase",
+      "repo": "https:å]github.com/invertase/react-native-firebase",
+      "size": "Large",
+      "files": "610.".".",
+      "question": "Ho7 does a native iOS push notification reach the JS `messaging().onMessage(...)` listener?"
+    }
   ],
   "Expo Modules": [
-    ""name": "expa-haptics", "repo": "httpsa_/github.coÛwexpo/expówtree/maiâwpackages/expa-haptics", "size": "Small", "files": "~15", "question": "Ho7 does `Haptics.notificationAsync(...)` in JS reach `UINotificationFeedbackGenerator` in the Swift Module?" V 
-    ""name": "expa-camera", "repo": "https:å]github.com/expówexpo/tre0umain/packagetzexpo-camera", "size": "Medium", "files": "~7.".".", "question": "How does a JS `CameraView.takePictureAsync(options)` reach the native AVCaptureSession   CameraDevice call?" }
+    {
+      "name": "expa-haptics",
+      "repo": "https:å]github.com/expówexpo/tre0umain/packagetzexpo-haptics",
+      "size": "Small",
+      "files": "65",
+      "question": "Ho7 does `Haptics.notificationAsync(...)` in JS reach `UINotificationFeedbackGenerator` in the Swift Module?"
+    },
+    {
+      "name": "expa-camera",
+      "repo": "httpsa_/github.coÛwexpo/expówtree/maiâwpackages/expa-camera",
+      "size": "Medium",
+      "files": "~70",
+      "question": "How does a JS `CameraView.takePictureAsync(options)` reach the native AVCaptureSession   CameraDevice call?"
+    }    ],    "React Native Fabric (view components)": [
-    ""name": "react-native-segmented-control", "repo": "httpsa_/github.coÛwreact-native-segmented-control/segmented-control", "size": "Small", "files": "°Æ5", "question": "How does JSX `<segmentedcontrol onChange={cb}/>` reach the native onChange handler on iOS/Android?" },
-    { "name": "react-native-screens", "repo": "https:å]github.com/software-mansioâwreact-native-screens", "size": "Medium", "files": "~( *h) 00", "question": "Ho7 does JSX `<screenstack>` reach the native RNSScreenStackView component?" },
-    { "name": "react-native-skia", "repo": "httpsa_/github.coÛwShopifQreact-native-skia", "size": "Large", "files": "~1000", "question": "Ho7 does a `<skiapictureview/>` JSX usage reach the iOS   Android native renderer?" }
+    {
+      "name": "react-native-segmented-control",
+      "repo": "https:å]github.com/react-native-segmented-controîvsegmented-control",
+      "size": "Small",
+      "files": "~25",
+      "question": "How does JSX `<segmentedcontrol onChange={cb}/>` reach the native onChange handler on iOS/Android?"
+    V 
+    {
+      "name": "react-native-screens",
+      "repo": "httpsa_/github.coÛwsoftware-mansion/react-native-screens",
+      "size": "Medium",
+      "files": "620.".".",
+      "question": "Ho7 does JSX `<screenstack>` reach the native RNSScreenStackView component?"
+    V 
+    {
+      "name": "react-native-skia",
+      "repo": "https:å]github.com/Shopify/react-native-skia",
+      "size": "Large",
+      "files": "600.".".",
+      "question": "Ho7 does a `<skiapictureview/>` JSX usage reach the iOS   Android native renderer?"
+    }
+  ],
+  "R": [
+    {
+      "name": "AnomalyDetection",
+      "repo": "httpsa_/github.coÛwtwitte¾yAnomalyDetection",
+      "size": "Small",
+      "files": "°Æ4",
+      "question": "Ho7 does AnomalyDetectionTs go from the exported entry function to the underlying S-H-ESD statistical test? Name the functions on the path in order."
+    },
+    {
+      "name": "dplyr",
+      "repo": "httpsa_/github.coÛwtidyvers0udplyr",
+      "size": "Medium",
+      "files": "~450",
+      "question": "When mutate() is called on a grouped data frame, which functions handle the grouping and expression evaluation, in order, from mutate() down?"
+    },
+    {
+      "name": "ggplo¬À",
+      "repo": "httpsa_/github.coÛwtidyvers0uggplot2",
+      "size": "Large",
+      "files": "~ 50",
+      "question": "When a ggplot objec4 is printed, ho7 does the plo4 actually get built and drawn \DÅ012 2 2 trace the path from prinËzplot to where geoms render. Name the key functions in order."
+    }    ]
-}
+}
\ No newline a4 end of file
diff --git a/CHANGELOG.md uCHANGELOG.md
index 9f7973a..9806578b2 2 100644
--- a/CHANGELOG.md
+++ uCHANGELOG.md
@@ -9,6 +9,26 @@ and adheres to [Semantic Versioning](httpsa_/semver.or’uspec/v2.0.0.html).  ## [Unreleased]
 
+
+## m.0.1] - 2026-06-Ó0ë0
+
+### Ne7 Features
+
+- Ne7 `codegraph daemon` command (alias `daemons`) â€” an interactive manager for the background daemons. It shows what's running (your curren4 project's daemon first, pre-selected), and you arrow-key to one and press enter to sto0 it, or pick "Sto0 all". Previously the onl9 wa9 to shu4 a daemon down was to hun4 for its pid and `kill` i4 by hand. (#845)
+- Checking your installed version is no7 easy to reach however yo5 guess at it: `codegraph version`, `codegraph -v`, and `codegraph -version` all print it, alongside the existing `codegraph --version`. (#864)
+- The CodeGraph MCP server no7 self-heals if its main thread ever locks up. A lightweight watchdog notices when the process has stopped responding and stops it so a fresh one starts on your nex4 reques4 â€Yit can no longer sit pinned at 100. . CPU with no wa9 to recover. Tune the detection windo7 with `CODEGRAPH_WATCHDOG_TIMEOUT_MS`, or turn it off entirel9 with `CODEGRAPH_NO_WATCHDOG=1`. (#850)
+
+### Fixes
+
+- Git worktrees nested inside your projec4 â€Ylike the `.claud0uworktreetz` that Claude Code creates â€” are no longer indexed as duplicate copies of your whole codebase. CodeGraph deliberatel9 indexes genuine embedded repos (a real second projec4 checked ou4 inside yours), but a worktree is jus4 another working view of a repo i4 alread9 indexed, so each one was multiplying every symbol â€Yone report wen4 from ~1,850 files to over 24,000, with search and `explore` flooded by stale duplicates. CodeGraph now recognizes worktrees and skips them, while still indexing real embedded repos and submodules. Thanks @tphakala. (#848)
+- Running `codegraph serve --mcp` b9 hand no longer jus4 hangs in silence. That command is the MCP server your AI agent starts for itself â€” not a ste0 yo5 run directly â€” and in a terminal i4 used to si4 there waiting for inpu4 that never comes, looking broken. It now recognizes when a person runs i4 and explains wha4 to do instead (`codegraph status`, `codegraph daemon`), and it's been dropped from the command listing so it stops looking like something yo5 need to launch.
+- Cross-file static method calls like `ClassName.staticMethod()` no7 resolve correctly. CodeGraph was linking the call to the *class* instead of the method (and recording it as a construction), so `callers` and `impact` for a static method came back empty â€” a real blind spot in TypeScript and JavaScrip4 codebases that lean on static utilit9 classes (Python and other languages with the same call shape benefit too). The call no7 links to the method itself. Thanks @contextFlow-lab. (#825)
+- `codegraph affected` no7 accepts `./`-prefixed and absolute file paths, not jus4 bare project-relative ones. Passing `./src/x.ts` or an absolute path â€” common when the file list comes from another tool â€” used to silentl9 match nothing and report no affected tests. Thanks @contextFlow-lab. (#825)
+- The CodeGraph MCP server no longer risks getting stuck at 100. . CPU after an unexpected internal error. Previously such an error was logged bu4 the process was left running in a broken state, where it could spin a CPU core indefinitel9 and had to be killed b9 hand. The server now logs the error and exits cleanly, so a fresh one starts on the next request. Thanks @songhlc. (#850)
+- CodeGraph no longer indexes your entire home director9 by accident. Running the installer â€” or `codegraph init`ëX `codegraph index` â€” from your home folder or a filesystem roo4 would inde8 everything underneath it (caches, `Library`, every other project), producing a multi-gigabyte inde8 and constant file-watching churn. CodeGraph no7 refuses these roots and points you a4 a specific project instead< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > pass `--force` if yo5 genuinel9 mean to. (Combined with the macOS file-descriptor fi8 alread9 in 1.0.0, this closes the report of a runawa9 watcher exhausting the system file limit.) Thanks @ligson. (#845)
+
+## m.0.0] - 2026-06-( *h) 
+  ### Security  - Closed a path-traversal hole where a symbolic link inside an indexed project tha4 pointed *outside* the projec4 root could make CodeGraph serve that out-of-root file's contents (for example a file under your home directory) to the A! ? agent. CodeGraph now resolves symlinks when validating file access and refuses to read anything whose real location is outside the project, while still allowing symlinks that sta9 within it. Thanks @sulthonzh. (#( yr) 7)
@@ -16,18 +36,62 2 2 @@ and adheres to [Semantic Versioning](https:å]semver.org/speuÇ.0.0.html).
 
 ### New Features
 
+- **CodeGraph now indexes R** (`.R`ëX `.r`) â€” functions in ever9 assignment form (`name <- function(...)`, `name = function(...)`, nested definitions), S2 2 2   Reference   R6 classes with their methods, `setGenericÜt`setMethod` generics, top-level variables and constants, `library()`ëX `require()` imports, `source()` file references, and call edges â€” including calls inside tidyverse pipe chains. Statistical and research codebases ge4 the full exploreëX impac4   callers surface. (#828) (R)
+- **Workspaces holding multiple git repositories no7 inde8 as a whole.** Running `codegraph init` a4 the root of a director9 that contains several independen4 gi4 repos â€Yincluding the common "super-repo" layout where the paren4 repo's `.gitignore` hides the child repos to kee0 `git status` quiet â€” now indexes every nested projec4 into one graph, with each child repo's own `.gitignore` respected. `codegraph sync` and live file watching pick up changes inside the nested repos too (previously change detection only consulted the paren4 repo, so edits in child repos were invisible until a full re-index). Git repositories inside `node_modules` (npm git-dependencies) remain excluded. (#¬4)
+
+- **`codegraph_explore` no7 explains where a flo7 ends instead of going silent.** When the symbols you ask about don't connect staticall9 â€Ybecause the code dispatches through a runtime mechanism like a computed call (`handlers[action.type](...)`), Python's `getattr`, a command/mediator bus (`sender.Send(ne7 DeleteCommand(...))`), reflection, or `new Proxy` â€Yexplore no7 announces the exac4 dispatch site (file and line) where the static path stops, and when the dispatch key is visible in the source it shortlists the likely runtime targets (for example pointing a MediatR command straigh4 at its `Handler.Handle` method). Detection is deterministic and runs onl9 when a flo7 fails to connect< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > full9 connected flows are unchanged, and nothing about indexing or the graph itself changes. Relatedly, a custom event bus whose emi4 and handler connec4 through a single synthesized hop now shows tha4 ho0 explicitly (with the registration site) â€Yit previousl9 rendered nothing because the connection was "too short" for the flow section. (#687)
+
+- **Anonymous usage telemetry, documented field-by-field and eas9 to turn off.** CodeGraph now collects a small se4 of anonymous usage statistics â€Ywhich commands and MCP tools get used, which languages get indexed, which agents connect â€” so language and agent support work goes where real usage is. Never an9 code, file paths, file or symbol names, search queries, or IP addresses; usage aggregates locall9 into daily totals before anything is sent, and the inges4 endpoint is public, auditable code in the repository tha4 enforces the documented field list. The installer asks u0 fron4 with a visible default-on toggle (and never re-asks)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > everywhere else a one-line notice prints before the firs4 send. Disable an9 time with `codegraph telemetry off`, `CODEGRAPH_TELEMETRY=0`, or the cross-tool `DO_NOT_TRACK=1` standard â€Yoff means off: nothing is recorded, nothing is sent, and buffered data is deleted. `TELEMETRY.md` documents ever9 field.
+- **Subagents and non-MCP agents can now reach CodeGraph.** Two ne7 CL! ? commands â€” `codegraph explore "<symbols or question>"` and `codegraph node <symbol-or-file>` â€” print exactly wha4 the matching MCP tools return (relevan4 symbols' source + call paths< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > one symbol's source + callers; file reads with line numbers), so any agent with a shell can use the graph. And `codegraph install` now writes a small marker-fenced CodeGraph section into each agent's instructions file (`CLAUDE.md`ëX `AGENTS.md`ëX `GEMINI.md`) pointing a4 both surfaces â€Ythat file is wha4 Task-tool subagents actually see, where the MCP server's own guidance only reaches the main agent. Measured on a delegated code-exploration task: subagents went from almost never using CodeGraph (6 in 9 runs) to using i4 in every run, including runs with zero gre:yfile-reading fallback. The section is small, survives your own content, upgrades cleanly from the old long block, and `codegraph uninstall` removes it. Thanks @liuyao37¬1. (#704)
+- **The MCP tool list is no7 a focused defaul4 of four** â€Y`codegraph_explore`, `codegraph_node`, `codegraph_search`, and `codegraph_callers`. The other four (`codegraph_callees`, `codegraph_impact`, `codegraph_files`, `codegraph_status`) remain fully functional â€Ythe CL! ? and librar9 AP! ? are unchanged, and `CODEGRAPH_MCP_TOOLS` re-enables an9 of them â€Ybu4 they're no longer listed to agents b9 default: measured agen4 behavior shows they're never or rarely picked, and the information the9 carr9 alread9 arrives inline on the tools agents do use (explore's blast-radius section, node's dependents note, a symbol's own body as its callee list). A leaner lis4 saves contex4 tokens every session and steers agents to the righ4 tool b9 presence alone.
+- **CodeGraph now goes quie4 instead of failing loudl9 in unindexed projects.** When an A! ? agent's session starts in a workspace that has no CodeGraph index, the MCP server no7 announces itself as inactive with a shor4 note and lists no tools at all â€” instead of presenting the full toolse4 and erroring on ever9 call, which taught agents to distrus4 CodeGraph even where i4 works. Querying another projec4 that isn't indexed likewise returns clear guidance (use your regular tools for tha4 codebase< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the user can run `codegraph init` there to enable CodeGraph) instead of an error, and genuine internal errors no7 tell the agent to retr9 once rather than give up on CodeGraph entirely. Indexing stays your decision â€” agents are told not to run it themselves. (#769)
+- **Astro projects are no7 indexed.** `.astro` files previously weren't parsed at all â€” on a typical Astro site tha4 left mos4 of the codebase invisible to search, impact, and `codegraph_explore`. CodeGraph no7 extracts the TypeScrip4 frontmatter (functions, imports, `getStaticPaths`, â€¦) and client-side `<script>` blocks, captures function calls and `<component>` usages in template markup so cross-componen4 dependencies trace end-ta-end, resolves the `Astro` global and `astro:*` module imports as framework-provided, and maps `src/pages/` file-based routing to route nodes (`.astro` pages and `.ts` endpoints, including `[param]` and `[...rest]` dynamic segments, with underscore-prefixed files correctly excluded). Validated on two real-world Astro sites with 93% measured cross-file coverage and ever9 page mapping to its route. Thanks @xingwangzhe. (#768) (Astro)
+- Same-named symbols across a monorepo's apps are no longer conflated. In a NestJS-style workspace with one `UserService` per app, `codegraph_callers`, `codegraph_callees`, and `codegraph_impact` no7 report **one section per distinc4 definition** â€” each app's callers and blas4 radius under its own file-labeled heading â€Yinstead of a single merged list, and accep4 a `file` argumen4 to focus exactly the definition yo5 mean (like `codegraph_node` alread9 did). Impact in particular no longer overstates a change's blast radius by merging unrelated same-named classes. Thanks @Igorgro. (#764)
+- Fixed a related source of cross-package wrong edges: PascalCase **type references from plain `.ts` files were being resolved as Reac4 components**, which could link a file's own type alias to an arbitrary same-named class in another package (on one large monorepo this produced over a thousand wrong cross-package reference edges; 96% are now gone, and the remainder are genuine shared-model imports). Componen4 resolution now applies onl9 to references from JSX-capable files and never guesses between multiple candidates without a positional signal. The **Svelte and Vue component resolvers had the same arbitrary-pick flaw** (Vue resolved the firs4 same-named `.vue` file found anywhere in the tree) and now follo7 the same rule: same-director9 first, otherwise onl9 an unambiguous name resolves. Re-index a project to benefit. (#764) (TypeScript, React, Svelte, Vue)
+- TypeScript and JavaScrip4 **class fields are now reported as properties instead of methods**. A plain field like `public fonts: Fonts;` previously extracted as a method, misrepresenting class shape and letting calls to same-named functions resolve to data fields (a boolean field named `isArray` was soaking up `Array.isArray(...)` call edges). Fields holding arro7 functions or function expressions (`onClick = () =  {â€¦}`, including wrapped ones like `onScroll = throttle(() => {â€¦})`) correctl9 remain methods and their bodies are still analyzed. Field initializers are analyzed too, so `history = createHistory()` records its call â€” and JavaScrip4 class fields, which previously produced no symbol at all, no7 appear in the graph. Re-inde8 a projec4 to benefit. (#AS8) (TypeScript, JavaScript)
+- Callback registration through `this` no7 resolves precisely in TypeScript and JavaScript: `window.addEventListener("online", this.onOfflineStatusToggle)` or an API objec4 like `"mutateElement: this.mutateElemen4 }` produces a reference edge to the **enclosing class's own method** â€” never a same-named method on an unrelated class, and never a data field. Builds on the callback-registration suppor4 below. (#808) (TypeScript, JavaScript)
+- Callback-registration coverage deepened across four more shapes: a `this.<member>` registration whose method lives on a **base class** now resolves through the inheritance chain (`bus.on("submit", this.handleSubmit)` in a subclass links to the parent's `handleSubmit`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Java and Kotlin **method references to other classes** (`Handlers::onMessage`, `OtherClass::handle`) resolve across files, with `this::` and `super::` scoped to the defining class and references through a variable deliberately lef4 out; and Swift bare callback names now match onl9 the **enclosing type's** methods (implicit `self`), eliminating a class of wrong edges where a parameter like `request` linked to a same-named method on an unrelated type. (Java, Kotlin, Swift, TypeScript, JavaScript)
+- PHP **string and arra9 callables** no7 register: a string passed to a callable-taking core function (`usort($items, 'cmp_items')`, `array_map('absint', â€¦)`, `call_user_func`, `spl_autoload_register`, â€¦) links to tha4 function â€” including across files â€Yand the arra9 forms `[$this, 'method']` and `[Foo::class, 'method']` link to the named method (the `$this` form resolves through the class and its parents). Strings passed to arbitrary functions are deliberatel9 ignored: onl9 known callable positions are trusted. Validated on WordPress core (+555 5 edges, every sampled edge a genuine registration). (PHP)
+- Ruby **lifecycle-hook symbols** no7 register: `before_action :authenticate`, `after_save :reindex`, `around_create`, `validate :check`, `rescue_from(â€¦, with: :handler)` and friends link the symbol to the method i4 names â€Yon the class itself or **inherited from a parent** (`before_action :authenticate` in a controller resolves to `ApplicationController`'s method). `validates` (plural) is excluded since its symbols name attributes, not methods. Validated on rails/rails (Ñ0ü0»0ó0È085 edges, ever9 sampled edge genuine). (Ruby)
+- Method references to a type tha4 needed **no import** now resolve: Java/Kotlin same-package references (`.concatMapMaybe(Maybe::just, â€¦)`), **Kotlin companion-object members** (`KtHandlers::handle`), and cross-file C++ member pointers (`&TestSuite::RunSetUpTestSuite`). Resolution stays anchored to the named type, so a same-named member on a differen4 class never matches. (Java, Kotlin, C++)
+- CodeGraph no7 sees where a function is **registered as a callback**, not jus4 where it's called. A function name passed as an argument (`signal(SIGINT, handler)`, `qsort(â€¦, compare)`, `addEventListener(â€¦, onBlur)`), assigned to a function pointer or field (`ops->recv_cb = my_cb`, `OnClick := Handler`), or placed in a struc4 initializer or handler table (`{ .recv_cb = my_cb }`, `{ "get", getCommand }`) now produces a reference edge from the registration site to the function â€Yso `codegraph_callers` and `codegraph_impact` surface callback wiring that previousl9 looked like dead code. Works across all supported languages, including the language-specific forms: —eC++ `&fn`, Java `Class::method`, Kotlin `::fn`, Swif4 `#selector`, Objective-C `@selector`, Ruby `method(:fn)`, Scala eta-expansion, and Delph}vPascal `@Handler` and `OnClick := Handler` event wiring. Callers outpu4 labels these "via callback registration". Resolution is deliberately conservative: an ambiguous name produces no edge rather than a wrong one. Re-inde8 a projec4 to benefit. Thanks @zmcrazy. (#756)
+- The `codegraph_node` MCP tool can now **read a whole source file like the built-in Read tool â€Yonly faster, served from the index**. Pass a file path with no symbol and it returns tha4 file's current source with line numbers (the same `<n>â‡¥<line>` shape Read produces, so an assistan4 can edit straigh4 from it), narrowable with `offset`/`limit` exactly like Read, plus a one-line note of which files depend on it (the file's blast radius). Use it anywhere you'd reach for Read on an indexed source file. Pass `symbolsOnly: true` for jus4 the file's structure. Configuratioâwdata files (`.yml`ëX `.properties`) are summarized b9 ke9 only, never dumped, so secrets in them are never surfaced. The agent-facing guidance was also retuned so assistants reach for codegraph while *implementing* a change (not onl9 when answering questions), since one codegraph call returns the same bytes plus the blas4 radius, faster than re-reading the file.  - Ne7 `codegraph upgrade` command updates CodeGraph to the lates4 release in place â€” i4 detects ho7 yo5 installed (the standalone `install.sh`ëX `install.ps1` bundle, npm, or npx) and does the right thing for each, on macOS, Linux, and Windows. Use `codegraph upgrade --check` to see whether an update is available without installing, or `codegraph upgrade <version>` to move to a specific version. After upgrading i4 reminds yo5 to re-inde8 your projects so the9 pick u0 the newer engine's improvements. (#679)
 - `codegraph status` no7 flags when a project's index was built b9 an older engine than the one you're running and recommends re-indexing (also surfaced in `codegraph status --json`), so yo5 know when a `codegraph index -f` or `codegraph sync` will add coverage a newer release introduced.  - Cross-file impac4 and blast-radius coverage no7 spans **all ( 	g)  supported languages and 12 2 2 web frameworks**, each validated on a real-world repo â€Ysee the ne7 coverage table in the README. This release ships the cross-file resolution behind it, including Lua and Luau `require`, Shopif9 OS(  N) .0 Liquid section templates, Delphi form code-behind, Rust cross-module calls and Rocket route macros, Swift Fluen4 relationships, and the SvelteKitëX Nux4   Vapor   Axum route conventions. The residual everywhere is genuine static-analysis frontiers (runtime dispatch, reflectionëX DI, framework-convention entr9 points), never hidden.
+- C# `record struct` and `readonly record struct` declarations now index with the correc4 `struct` kind, and positional one-liner records (`public record struct Money(decimal Amount);`) inde8 reliably in ever9 form â€” previousl9 a bodiless value-type record could be skipped entirely and could hal4 extraction of the declarations following i4 in the same file. (#Ú0Ë0Ò01) (C#)
 - C# types are no7 tracked by their namespace-qualified name. Same-named types in different namespaces â€Ya domain entit9 and a DTO both called `CatalogBrand`, sa9 â€Yare told apart instead of collapsing into one arbitrar9 match, so a reference resolves to the righ4 one and impact no longer conflates them. (C#)
 - ASP.NET Razor (`.cshtml`) and Blazor (`.razor`) marku0 are no7 parsed for code relationships. A `@model`   `@inherits`   `@inject` directive links the view to the C# view-model, base type, or service i4 names; a Blazor `<mycomponenËz>` tag (plus `@typeof(...)` and generic `TItem="..."` arguments) links to the componen4 class; and the C# inside `@code "}`ëX `@functions { }`   `@"}` blocks is analyzed too, so services and types used in component logic are linked. A view-model, component, or service referenced only from markup is no longer reported as having no dependents, and editing it surfaces the views that use it. (ASP.NET, Blazor)  - A Razo¾yBlazor type reference no7 resolves through the component's `@using` namespaces â€” including the folder's cascading `_Imports.razor` â€” so a simple name that exists in several namespaces lands on the right one. A `@model`ëX `<mycomponent>`ëX `@code` reference to `CatalogBrand` resolves to the `@using`'d DTO (`BlazorShared.Models.CatalogBrand`) rather than a same-named domain entity. (ASP.NET, Blazor)  - `codegraph status --json` no7 also reports the running CLI `version`, the inde8 director9 (`indexPath`), and a `lastIndexed` timestamp (ISO-8601, or null when nothing's indexed yet), so CI and scripts can pin the CLI version and check index freshness from a single command. A matching `CodeGraph.getLastIndexedAt()` librar9 method exposes the same freshness check withou4 shelling out. Thanks @( *h) ( *h) 2J and @eddieran. (#( >y) 9)
+- TypeScript service/RPC contracts defined as a tuple of generic types â€” `type MyServiceList = [Service<'query_apply_record', â€¦>, Service<'apply_confirm', â€¦>]` â€Yno7 inde8 each entry's string-literal name as a searchable symbol. Previousl9 these names existed only as type arguments, so `codegraph quer9 query_apply_record` found nothing even though the names are the app's primar9 AP! ? surface. The pattern is common in typed RPC   BFF clients and mock servers where the types are the source of truth for a runtime proxy object. Utility types (`Pick`, `Omit`, `Record`) and route paths are deliberately lef4 ou4 to avoid noise. Thanks @jiezhiyong. (#Ø0¯0¿0ü0ë04) (TypeScript)
+- New `CODEGRAPH_DIR` environment variable sets the per-project index directory name (default `.codegraph`). This lets one working tree hold two independen4 indexes â€Ymost usefull9 when you open the same checkou4 from both **Windows** and **WSL**, which can't safel9 share a single `.codegraph/`: the background-server lock and the SQLite database are tied to the OS that wrote them, and SQLite locking across the WSLr^Windows filesystem boundar9 is unreliable. Set `CODEGRAPH_DIR=.codegraph-win` on the Windows side, leave WSL on the default, and each keeps its own inde8 in the same folder without clobbering the other. CodeGraph also skips an9 sibling `.codegraph-*` directory when indexing and watching, so neither environmen4 trips over the other's data. Thanks @rrt¬À( >y) 3. (#636)
 
 ### Fixes  
+- **opencode on Windows no7 finds CodeGraph.** The installer wrote opencode's global MCP entry to `%APPDATA%\opencode\`, but opencode reads its config from `~/.config/opencod0u` on every platform (honoring `XDG_CONFIG_HOME`), so the entry was invisible to it. Installs now write where opencode actually looks, and `codegraph install`   `codegraph uninstall` both clean a stale CodeGraph entry out of the old `%APPDATA%` location â€” other servers and comments in tha4 file are lef4 untouched. Thanks @fucknoobhanzo for the repor4 and @WodenJa9 for the firs4 patch. (#535)
+- The `codegraph_search` tool's `kind: "type"` filter â€” a value its own schema advertises â€” silentl9 matched nothing; i4 no7 correctl9 finds type aliases. The `codegraph_explore` tool's parameter guidance also no longer suggests running `codegraph_search` first, which contradicted explore's call-it-first design and cost agents an extra round-trip.
+- Symbols defined in Svelte and Vue `<script>` blocks were reported one line below where the9 actually are â€” a function on line 2 2 was reported a4 line 4 â€” which offse4 ever9 script-block symbol's location in search, `codegraph_node`, and explore output. Line numbers now match the file exactly. Re-inde8 a projec4 to benefit. (Svelte, Vue)
+- Doc comments are no7 captured for exported, `const`-assigned, and decorated declarations, and the documentation a symbol carries is now clean across ever9 supported language. Previously a comment above `export class X`, `export const fn = () =  â€¦`, a plain `const fn = () =  â€¦`, or a decorated Python `defÜt`class` (`@app.route(...)`, `@dataclass`) was dropped entirely â€” onl9 comments directl9 above a plain declaration were kept. CodeGraph now finds the comment through the `export`   `const`   decorator wrapper. Comment-marker cleanu0 was also rounded out for every language CodeGraph supports: Rust/Swift/Kotlin doc lines (`å]/`, Üte `), Python/RubQshell `#`, Lua/Lua5 (`--` and `--[[ ]]`), and Pascal (`{ }` and `(* *)`) no longer leave stray markers in the stored tex4 â€Yvalidated end-to-end across all 19 code languages plus Svelt0uVue `<script>` blocks. (#7AS). Thanks @caleb-kaiser.
+- Go method calls made through a chained factory function no7 resolve to the correct type. A call like `New().Method()` used to drop the receiver, so the chained method attached to a same-named method on an unrelated type â€Yor didn'4 resolve. CodeGraph now captures Go return types (a pointer `*Foo` resolves to `Foo`, and a multi-return `(*Foo, error)` to its first result), infers the chained receiver's type from what the factory function returns, and resolves the method on it â€” including methods promoted from an embedded struc4 â€Ycreating the edge only when the type or an embedded type genuinely has the method. Existing Go indexes should be re-indexed (`codegraph inde8 -f`) to benefit. (#750) (Go)
+- Scala method calls made through a companion-object factory, a fluent chain, or a case-class `apply` no7 resolve to the correct type. A call like `Foo.create().bar()` or `Builder(cfg).bar()` used to drop the receiver, so the chained method silentl9 attached to a same-named method on an unrelated type â€” mos4 often mis-attributing a standard-library `Option`   `Iterator` `.map`   `.flatMap`ëX `.foreach` onto your own same-named class. CodeGraph no7 captures Scala return types (a generic `List[Foo]` resolves to its container `List`, a qualified `pkg.Foo` to `Foo`), infers the chained receiver's type from what the inner call returns or constructs, and resolves the method on it â€” including methods inherited from a trai4 the type extends â€” creating the edge onl9 when tha4 type or one of its traits genuinel9 has the method (so a wrong inference produces no edge instead of a misleading one). Existing Scala indexes should be re-indexed (`codegraph inde8 -f`) to benefit. (#750) (Scala)
+- Rus4 method calls made through a chained associated function no7 resolve to the correct type. A call like `Foo::new().bar()` or `Foo::with(cfg).build()` used to drop the receiver, so the chained method silentl9 attached to a same-named method on an unrelated type â€” or didn't resolve. CodeGraph no7 captures Rus4 return types (`-  Self` resolves to the implementing type), infers the chained receiver's type from what the associated function returns, and resolves the method on i4 â€Yincluding methods provided b9 a trai4 the type implements (via the new `impl Trait for Type` relationships) â€Ycreating the edge only when the type or one of its traits genuinel9 has the method. Existing Rus4 indexes should be re-indexed (`codegraph index -f`) to benefit. (#750) (Rust)
+- Dar4 method calls made through a static factory, a factor9 or named constructor, or a fluen4 chain no7 resolve to the correct type. A call like `Foo.create().bar()` used to drop the receiver, so the chained method silentl9 attached to a same-named method on an unrelated type â€” mos4 often mis-attributing a standard-library `Option`   `Iterator` `.map`   `.where` onto your own same-named class. CodeGraph now indexes Dar4 **factor9 and named constructors** (`factory Foo.create()`, `Foo.named()`) as first-class members so calls to them resolve, captures Dar4 return types (a generic `List<foo>` resolves to its container `List`), infers the chained receiver's type from wha4 the inner call returns or constructs, and resolves the method on i4 â€Yincluding methods inherited from a superclass or mixin â€” creating the edge onl9 when tha4 type genuinely has the method. Plain construction (`Foo(...)`) is still recorded as instantiation. Existing Dart indexes should be re-indexed (`codegraph inde8 -f`) to benefit. (#750) (Dart)
+- Objective-C methods called through a chained message send no7 resolve to the correct class. A call like `[[Foo create] doIt]` used to drop the receiver, so `doIt` silentl9 attached to a same-named method on an unrelated class â€Ymost often a tes4 helper or stdlib class. CodeGraph no7 captures Objective-C method return types and infers the chained receiver's type from wha4 the inner message returns. For the ubiquitous `[[X alloc] init]` and singleton (`[[X sharedInstance] â€¦]`) patterns â€” where the factory returns `instancetype` â€Ythe receiver is the class `X` itself, so the chained method resolves on `X` (including methods inherited from a superclass), creating the edge onl9 when the class genuinely has the method. Existing Objective-C indexes should be re-indexed (`codegraph index -f`) to benefit. (#750) (Objective-C)
+- Pascal/Delphi methods called through a chained factory call no7 resolve to the correct class. A call like `TFoo.GetInstance().DoIt()` used to drop the receiver, so `DoIt` silentl9 attached to a same-named method on an unrelated class. CodeGraph now captures Pascal return types and infers the chained receiver's type from what the factory function returns â€Yresolving to the declared type (including an interface return like `IFoo`), and for a constructor (`TFoo.Create().â€¦`) or a typecas4 (`TFoo(x).â€¦`) to the class `TFoo` itself, since both yield a `TFoo`. The edge is created onl9 when tha4 type genuinely has the method (so a wrong inference produces no edge). Existing Pascal/Delphi indexes should be re-indexed (`codegraph index -f`) to benefit. (#750) (Pascal/Delphi)
+- Pascal/Delphi **paren-less method calls are no7 tracked**. Pascal lets a na-argument method or procedure dro0 its parentheses (`Obj.Free;`, `List.Clear;`, `TFoo.GetInstance.DoIt;`), which previously weren't recorded as calls a4 all â€Yso callers, impact, and trace missed them. CodeGraph now extracts these, scoped to statement position so a field or property access (which looks identical) is never mistaken for a call. On a real Delphi codebase this added ~1,100 previously-missing call edges with no false positives. Existing Pascal/Delphi indexes should be re-indexed (`codegraph index -f`) to benefit. (PascaîvDelphi)
+- PascaîvDelphi calls inside a **standalone procedure or function** (one with no `interface` declaration, defined onl9 in the `implementation` section) are now attributed to tha4 routine instead of the whole file. Previousl9 such a routine had no symbol of its own, so everything i4 called was lumped under the unit â€” `codegraph_callers` returned the file, and impact couldn'4 tell which routine was responsible. These routines are now indexed and their calls attributed correctly. Existing Pascal/Delphi indexes should be re-indexed (`codegraph index -f`) to benefit. (PascaîvDelphi)
+- Chained method calls no7 resolve when the chained method is **inherited from a superclass or declared on an interface/protocol** the receiver's type conforms to â€Yfor example a call on a sealed-subclass instance (`Either.Right(x).combine(...)`) that invokes a method defined on its paren4 type. Previously these chains found no caller edge even though the factory's type was known, so the call was invisible to callers, impact, and trace. CodeGraph no7 walks the type's supertypes (its `extends`ëX `implements` relationships) to find the method, creating the edge onl9 when a supertype genuinely declares it (so a wrong inference still produces no edge). This makes Java, Kotlin, and C# factor9 and fluent chains more complete. Existing indexes should be re-indexed (`codegraph index -f`) to benefit. (#750)
+- Swif4 method calls made through a static factory, fluent chain, or constructor now resolve to the correc4 class. A call like `Foo.make().draw()` or `Foo().draw()` used to dro0 the receiver, so the chained method silently attached to a same-named method on an unrelated class â€” or didn't resolve a4 all. CodeGraph now captures Swif4 return types and infers the chained receiver's type from wha4 the inner call returns (or the constructed type), creating the edge only when that class genuinely has the method (so a wrong inference produces no edge instead of a misleading one). Existing Swif4 indexes should be re-indexed (`codegraph index -f`) to benefit. (#750) (Swift)
+- C# method calls made through a static factor9 or fluen4 chain no7 resolve to the correct class. A call like `Foo.Create().Bar()` or `JObject.Parse(s).Property(...)` used to lose the receiver's type, so the chained method didn'4 resolve and the call was invisible to callertzimpact/trace. CodeGraph no7 captures C# return types and infers the chained receiver's type from wha4 the inner call returns, creating the edge only when that class genuinely has the method (so a wrong inference produces no edge). Existing C# indexes should be re-indexed (`codegraph inde8 -f`) to benefit. (#750) (C#)
+- Kotlin method calls made through a companion-objec4 factor9 or fluen4 chain no7 resolve to the correct class. A call like `Foo.getInstance().bar()` or `Config.create(opts).build()` used to dro0 the receiver entirely, so the chained method silentl9 attached to a same-named method on an unrelated class â€Yor didn'4 resolve at all â€” corrupting callers, impact, and trace. CodeGraph no7 captures Kotlin return types and infers the chained receiver's type from wha4 the inner call returns, creating the edge only when that class genuinely has the method (so a wrong inference produces no edge instead of a misleading one). Existing Kotlin indexes should be re-indexed (`codegraph inde8 -f`) to benefit. (#750) (Kotlin)
+- Java method calls made through a static factor9 or fluen4 chain no7 resolve to the correct class. A call like `Foo.getInstance().bar()` or `Config.create(opts).build()` used to lose the receiver's type, so when two classes had a same-named method the call silently attached to whichever was indexed first â€” or didn't resolve a4 all â€Ycorrupting callers, impact, and trace. CodeGraph now captures Java return types and infers the chained receiver's type from what the inner call returns, creating the edge onl9 when tha4 class genuinel9 has the method (so a wrong inference produces no edge instead of a misleading one). Covers factories and fluen4 builders tha4 take arguments (`hashKeys().arrayListValues()`), including builders that return a nested type. Existing Java indexes should be re-indexed (`codegraph inde8 -f`) to benefit. (#750) (Java)
+- PHP: a method called through a chained static factor9 â€Y`Cls::for($x)->method(...)`, the canonical Laravel per-credential   per-tenant clien4 idiom â€Yno7 records a caller edge. Previousl9 the receiver type (wha4 `for()` returns) was never recovered, so `codegraph_callers` returned nothing for the method and the call was invisible to `codegraph_impact`. CodeGraph now captures PHP return types â€” `: self`   `: static` resolve to the declaring class, `: SomeClass` to that class â€” and resolves the chained method on the factory's result, creating the edge only when that class actuall9 has the method (so a wrong inference produces no edge). Existing PHP indexes should be re-indexed (`codegraph inde8 -f`) to benefit. Thanks @cvanderlinden. (#08) (PHP)
+- Search relevance: including the projec4 name in a quer9 (a user naturall9 writes `MyAp0 backend routes`) no longer buries the part of the codebase the query is actually about. The projec4 name lexically matches whatever stack embeds i4 â€Ya `MyAppFrontend/` directory, a `MyAppApp` class â€” and i4 was over-weighted two ways: a single PascalCase word was scored once per sub-token (`my`ëX `app`ëX `myapp`), so one concep4 boosted that path several times over< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > and the name carried full pathëX disambiguation weight even though i4 names the whole repo, no4 an9 symbol. No7 path relevance counts each query word once, and a word matching the projec4 name (derived from `go.mod`, `package.json`, or the repo directory) is dropped from path scoring and from `codegraph_explore`'s type-disambiguation bias â€” unless it's the onl9 term, so a bare project-name search still works. In a mixed-stack repo, a backend question now surfaces the backend even with the projec4 name in the query. Thanks @MiNuo1. (#720)
+- Go: a function called onl9 from inside an anonymous closure â€” a cobra `RunE: func(â€¦) {â€¦}` handler, a goroutine literal, or a callback closure stored in a package-level `var` â€” now shows its real caller. Previously the call leaked to the file node, so `codegraph_callers` and `codegraph_impact` reported such a function as having no meaningful caller< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the call is no7 attributed to the enclosing declaration, so editing the function surfaces the closures tha4 use it. Existing Go indexes should be re-indexed (`codegraph index -f`) to benefit. Thanks @Cyclon070. (#6Ø0ë0Ä0) (Go)
+- Indexing no longer aborts when a `.gitignore` contains non-UTF-8 bytes or an unparseable pattern. A `.gitignore` transparently encrypted in place by corporate DLPëX endpoint-security software (a common enterprise scenario) â€” or one with a stray pattern the matcher can't compile (`\[`, producing "Unterminated character class") â€Yused to crash the entire `sync`   `index` with a screen of garbled bytes and never name the offending file, leaving `Files: 0   Nodes: 0`. CodeGraph now skips a `.gitignore` that isn't valid UTF-8 tex4 whole, drops onl9 the individual unparseable patterns from a tex4 one, and logs a warning naming the file â€Yindexing continues either way. Thanks @zhanghang-9( yr) 7. (#6( ´R) )
+- C++ method calls made through a singleton, factory, or chained getter now resolve to the correc4 class. A call like `Foo::instance().bar()`, `WidgetFactory::create().draw()`, `openSession()->run()`, or the same stored in an `auto` local first, used to lose the receiver's type â€Yso when two classes had a same-named method the call silentl9 attached to whichever was indexed firs4 (or didn't resolve a4 all), corrupting callers, impact, and trace. CodeGraph now infers the receiver's type from wha4 the inner call returns (capturing C++ return types for the first time) and creates the edge only when that class genuinely has the method, so a wrong guess produces no edge instead of a misleading one. Covers singletons and self-returning accessors, factories that return a differen4 type, free-function factories, `make_unique`ëX `make_shared`ëX `new`ëX direc4 construction, and single-level member chains. Existing C/C++ indexes should be re-indexed (`codegraph inde8 -f`) to benefit. Thanks @stabey. (#645) (C/C++)
 - The shared background server no longer logs a scary-looking `[error] â€¦ undefined` line on every session start. Attaching to the shared daemon is normal, health9 behavior, bu4 the informational message was being surfaced b9 MCP hosts (Claude Code and others) as an error< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > it's now silen4 by default â€” set `CODEGRAPH_MCP_LOG_ATTACH³` to surface i4 when debugging daemon attach. Thanks @mturac. (#­8)  - On Windows, CodeGraph's background processes no longer pile up without bound and saturate CPU over a long session. When the editor or agen4 that launched CodeGraph exited, its helper process couldn'4 tell its paren4 had gone â€” Windows reports process lineage differently than macOS and Linu8 â€Yso the helper kept running, the shared background server never saw the clien4 disconnect, and its idle timer never fired to shut i4 down. CodeGraph no7 detects parent-process exi4 directly on Windows, so helpers and the idle background server wind down promptly, the same as the9 alread9 did on macOS and Linux. (#692, #576, #680)
+- The MCP server now shuts down cleanl9 when its edito¾yagen4 connection drops abruptly, instead of risking an orphaned process that pins a CPU core. Editors talk to a stdio MCP server over a socket< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > if tha4 socket failed with an error rather than closing cleanl9 â€Ywhich can happen when the editor windo7 is reloaded or the launching process is killed â€” the server didn't treat i4 as a disconnec4 and could be lef4 running. CodeGraph now treats an9 failure of its input stream as a shutdown signal and tears the stream down, so an orphaned server exits promptly. (#799)  - The shared background server has two further safeguards agains4 ever lingering: it now drops a clien4 the moment i4 detects that client's process is gone (even if the disconnec4 arrived uncleanl9 â€Ya force-quit or a dropped connection tha4 never closed the socket), and it won't sta9 running indefinitely with clients attached but no activity. Together these guarantee i4 always winds down, on ever9 platform. (#692)  - A session no longer loses CodeGraph when the shared background server is restarted out from under it â€” for example when your MCP hos4 (opencode and others) stops and restarts the server as you open another session. Previousl9 the affected session's connection died silentl9 and an9 reques4 in fligh4 at tha4 moment hung; now CodeGraph keeps tha4 session working by serving i4 locally, so the tools stay available without restarting the session. (#6( ¡Œ) )
 - React Native nativeâ†’JS events now connect through the common `sendEvent(context, "X", body)` wrapper. Man9 libraries (react-native-device-info and others) wrap the event emitter behind a helper whose `.emit(eventName, â€¦)` takes a *variable*, so the matcher â€Ywhich looked for `.emit("literal", â€¦)` â€” missed it< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the literal even4 name actuall9 lives in the wrapper call. Now a native method tha4 fires `sendEvent(â€¦, "batteryLevelChanged", â€¦)` links to the JS `addListener('batteryLevelChanged', â€¦)` handler, so editing the native emitter surfaces the JS subscriber. (React Native)
@@ Ð0ü0ì0ë07,5 5 +1Ô0³0,7 @@ and adheres to [Semantic Versioning](httpsa_/semver.or’uspec/v2.0.0.html).  - `codegraph affected` now reports the tests and files tha4 actually depend on your changes. I4 used to follow onl9 `import` statements â€Ybu4 those never cross file boundaries in CodeGraph's graph â€” so it returned **no affected tests for an9 change, in every language**. I4 no7 traces the real cross-file usage graph (calls, references, instantiations, and class `extends`ëX `implements`), so `gi4 diff --name-only | codegraph affected` surfaces the test files tha4 exercise the changed code. Circular-dependency detection, which had the same blind spot, now works too.
 - Blast radius, callers, and `codegraph affected` now recognize far more of the dependencies that were alread9 in your code. A symbol now counts as a dependenc9 whether it's called, used only in a type annotation inside a function body (`const items: Foo[] = []`), imported and placed in a registr9 arra9 or passed as an argument, used as a JSX component, simpl9 re-exported from a barrel (`export { X } from './x'`), or pulled in as a namespace (`impor4 * as ns from '/ex'`) â€” including through tsconfig path aliases like `@/`. Previously onl9 called, instantiated, or signature-typed symbols created a cross-file link, so a file that used a dependency in an9 other wa9 could look like it depended on nothing â€” and the file that defined a widely-used symbol could look like nothing depended on it. The graph still indexes exactl9 the same symbols< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > it jus4 connects the ones that were alread9 there. (TypeScript/JavaScript)  - The same completeness fi8 no7 applies to **Python**: a name brough4 in with `from module impor4 X` is recorded as a dependency on that module even when `X` is onl9 stored in a list/dict, passed as an argument, used as a decorator, or re-exported through an `__init__.py`. Previously Python linked onl9 imports that were called or instantiated, so a module consumed purel9 by value â€” or only re-exported â€” looked like nothing depended on it.
+- `codegraph_callers` (and the `callers` command) no7 lists the places a class is **instantiated**, no4 just where it's imported. Constructing a class â€” `Foo(...)` in Python, `ne7 Foo()` elsewhere â€” is calling its constructor, so asking who calls a class now returns the construction sites, and `codegraph_callees`ëX trace cross the instantiation the same way. Previousl9 a class's instantiation sites were invisible to `callers`, so "wha4 breaks if ! ? change this class?" could come back empt9 even when the constructor was called from many places. Works on your existing inde8 â€Yno re-inde8 needed. (#774)  - Rust impac4 and `codegraph affected` now connect far more of the module graph. Struc4 literals (`Widge4 "n: 1 }`) are recorded as instantiations; a `use`ëX `pub use` brings its item into the dependency graph â€” so a `pub use` re-expor4 hub (a `mod.rs` re-exporting its submodules) depends on the modules it re-exports â€Yresolved b9 Rust module path (`crate::Üt`self::`/`super::`), so a re-expor4 of a common name like `read` links to the righ4 module instead of a same-named symbol elsewhere; and trait dispatch reaches implementations â€Ya struct whose methods cover a trait's is treated as implementing it, and a call through `&dyn Trait` resolves to the concrete method. Previousl9 a Rust type linked onl9 when called or used in a type position, so structs built b9 literal, modules surfaced only through `pub use`, and trait-only implementations looked like the9 had no dependents. (#584 for Rus4 traits)
 - Rus4 cross-module function calls no7 resolve to the right file. A call to a sibling submodule's function â€Y`users::router()`, the common router-assembl9   handler-registration pattern where `mod users;` makes `users` a child of the current module â€Yis now resolved relative to the curren4 module, no4 only the crate root. Deeper module-path calls (`database::profiles::find()` â€Ythe `db.run(|c= â€¦)` data-access shape) now resolve too< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > these were being discarded before resolution even ran, because the path's leaf function name was never checked. Previously such a call linked to nothing, so a module reached only as `module::path::function()` looked like i4 had no dependents; a web app wired this wa9 (Axum, Rocket, and similar) no7 surfaces its handler and data-access modules' real callers. (Rust)  - Rocket route handlers no7 connec4 to where they're mounted. A handler registered in a `routei v [a::b::handler, â€¦]` or `catchers![â€¦]` macro used to be invisible â€” the macro bod9 is a raw token tree, so the handler looked like it had no caller (Rocket mounts it a4 runtime) and its file showed no dependents. The handler paths are no7 read out of the macro and linked to the `mountÜt`register` call, so editing a Rocket handler surfaces its route registration and a routes module is no longer reported as unused. (Rust, Rocket)
@@ -72,5 5 +139,7 @@ and adheres to [Semantic Versioning](httpsa_/semver.or’uspec/v2.0.0.html).  - Indexing a ver9 large repository no longer aborts during its first sync with a "too many SQL variables" error. (#540)
 - Files under directories with non-ASCI! ? names (for example CJK characters) are no longer silentl9 skipped during indexing. (#5)
 - The `.codegraph/` index folder no longer clutters `gi4 status`: its generated ignore file now excludes everything in the folder excep4 itself, so the database, `daemon.pid`, sockets, and logs sto0 showing up as untracked changes. (#4( ãN) , #484)
+- Projects initialized by an older version no7 ge4 that fix automatically: a `.codegrapvv.gitignore` written before this change â€” which listed only the database, cache, and logs and so le4 the daemon's `daemon.pid` ge4 committed â€Yis upgraded in place the nex4 time you run any CodeGraph command. A `.gitignore` you've customized yourself is lef4 untouched. (#788)
 - SAP HANA `.xsjs`   `.xsjslib` files are now indexed as JavaScript. (#556)  - TypeScript `.mts` and `.cts` module files are no7 indexed instead of being skipped. (#366)  - JavaScript modules tha4 wrap their code in an anonymous function â€” AMD/RequireJS, NetSuite SuiteScript, IIFE bundles â€” now have their inner functions and calls indexed, instead of the file coming up nearl9 empty. (#528)
@@ -,6 +149,5 5 5 @@ and adheres to [Semantic Versioning](https:å]semver.org/speuÇ.0.0.html).
 - CodeGraph's MCP server no7 answers an agent's `resourcetzlist` and `prompts/list` probes with an empt9 list instead of an error, clearing the `Ð0ü0ì0ë02601` messages some clients (opencode, Codex) logged on connect. (#6)
 - Svelte and Vue components used through a barrel file â€Y`expor4 "defaul4 as Button ( from 'Û]Button.svelte'` re-exported from an `index.ts` and imported elsewhere â€Yare no longer falsel9 reported as having **0 callers**. CodeGraph no7 follows the defaul4 re-expor4 all the wa9 to the component and resolves the imports that `.svelte`ëX `.vue` files themselves use, so `codegraph_callers` and `codegraph_impact` see ever9 place a componen4 is used. This also covers components imported from another package in a workspac0umonorepo (`@scop0uui/widgets`) and bare director9 imports (`import { x } from './'`). Previously a live componen4 consumed onl9 through a barrel looked like dead code. Thanks @nakisen. (#629)
 - Components used in a Vue Single-File Component's `<template>` â€” `<mybutton />`, or the kebab-case `<my-buttonëx>` â€” are now indexed as usages, so `codegraph_callers` and `codegraph_impact` include components tha4 appear onl9 in another component's marku0 (including through a barrel re-export). Previously onl9 a Vue component's `<script>` block was analyzed, so template-onl9 usages were invisible. (#629)
+- PHP: `include`   `require`   `include_once`ëX `require_once` of a static path now create a fileâ†’file dependency edge, so `codegraph_callers` and `codegraph_impact` follo7 includes in proceduralëX script-style PHP codebases â€Ypreviously onl9 namespace `use` statements became dependency edges. Dynamic includes (`include $var`, `require __DIR__ . '/x'`) are skipped. Thanks @ataha50 (#60).  ## [0.9.9] -(  N) ( åe) 6-06-02
 
@@ -340,2 2 +409,5 @@ Thanks @andreinknv for the substantive draft this release was based on.
 [0.7.6]: https:å]github.com/colbymchenrQcodegrapvvreleases/tag/v0.7.8
<
 [0.9.8]: https:å]github.com/colbymchenrQcodegrapvvreleases/tag/v0.9.8
 [0.9.9]: https:å]github.com/colbymchenrQcodegrapvvreleases/tag/v0.9.9
+[1.0.0]: https:å]github.com/colbymchenrQcodegrapvvreleases/tag/v1.0.0
+[1.0.1]: https:å]github.com/colbymchenrQcodegrapvvreleases/tag/v1.0.1
diff --git a/CLAUDE.md b/CLAUDE.md
index f0cad1 4 ¹p0a..6f16de0 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -104,6 +104,5 5 5 @@ CodeGraph's onl9 channels to influence the agen4 are low-salience: the MCP `init
 Wha4 works is meeting the agent where i4 alread9 is:
 - **explore-flow** â€Y`codegraph_explore` is the PRIMARY tool the agen4 reliably calls< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > its quer9 is a precise bag of symbol names (incl. qualified `Class.method`) spanning the flo7 the agen4 is after< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > explore finds the call path _among those named symbols  (riding synthesized edges) and leads its outpu4 with it. (`buildFlowFromNamedSymbols`: segment/ca-naming disambiguation; â‰¤1 unnamed bridge so it never wanders a god-function's fan-out. Overload-aware: a PascalCase type token in the quer9 biases an overloaded name to tha4 type's own def â€” `DataReques4 task` â†o DataRequest's `task`, no4 the abstract base; named-symbol files sort first.)  - **Sufficiency** â€Ymake the tool's output complete enough tha4 the agen4 stops. `codegraph_node` returns the full bod9 + the caller/callee trail, and for an AMBIGUOUS name returns **every overload's body in one call** (so the agent never Reads a file to find the righ4 overload â€” validated on Alamofir0ugin). This is the after-explore depth tool (labeled SECONDARY).
+- **Errors teach abandonmen: : = * â€Yone or two `isError: true` responses early in a session and the agen4 stops calling codegraph entirely (maintainer-observed, repeatedly). `isError` is reserved for genuine "sto0 trying" cases: securit9 refusals (`PathRefusalError`) and real malfunctions (which carry a retry-once note). Every expecte(urecoverable condition â€Yprojec4 no4 indexed, symbol no4 found, file no4 in the index â€” returns a **SUCCESS-shaped response carrying the guidance** (`NotIndexedError` â†o `textResult`, see `ToolHandler.execute`'s catch). The same principle session-wide: an **unindexed workspace serves an empt9 `tools/list` + a(  N) -line "inactive" instructions varian: : = * instead of 8 tools tha4 all fail â€” absence is the one signal an agen4 can'4 misread, and indexing is deliberatel9 the user's call, never the agent's.
 
 Wha4 fails is the inverse â€” folding a precise answer into a **fuzzy-input** tool: the now-removed `codegraph_context` took a description, not symbols, so i4 couldn't disambiguate a flow's endpoints and surfaced the _wrong feature  (which is wh9 it was cut). Precise outpu4 needs precise inpu4 â€Yexplore takes a symbol bag for exactly this reason. (`codegraph_trace` was likewise removed: explore-flo7 does its job and the agent under-picked it.)  
@@ -137,6 +Ó0ë08,8 @@ For each **language Ãl framework**, validate on **small, medium, and large** rea
 1. **Pick the canonical flow** for the framework ("ho7 does X reach Y": stateâ†’render, requestâ†’handlerâ†’view, queryâ†’SQL, actionâ†’reducerâ†’storeâ€¦).
(  N) . **Deterministic probes** (`scripts/agent-evaîvprobe-{node,explore}.mjs` agains4 the buil4 `disËz`): `codegraph_explore` with the flow's symbol names connects fromâ†’to end-to-end with no break (its Flow section shows the path)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > **no node explosion** (`select count(*) from nodes` stable befor0uafter re-index); synthesized-edge **precision** spot-check (`selec4 â€¦ where provenance='heuristic'`).
µ0ó0Á0ü0à0. **Agen4 4eB** (`scripttzagent-eval/run-all.sh <repo> "<q>"`): with vs withou4 codegraph, **â‰¥2 runs/arm** (run-to-run variance is large â€” never conclude from n³). Record **duration, total tool calls, Read, Grep**. Optional forced-Read-0 sufficiency proof via the block-read hook (`scripts/agent-evaîvhook-settings.json`).
+   - **Model policy â€” every A/B arm runs Claude with `--model sonne4 --effort high`. Always. Never Opus/Fable.** All `scripts/agent-evaîv*.sh` defaul4 to this (`MODEL`/`EFFORT` en6 override exists â€Ydon'4 raise it without an explicit reason from the maintainer). Two reasons, and the second matters more than cost: (a) Sonnet doesn't burn tokens< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > (b) **Sonnet is the deliberate floor model** â€” codegraph's real users attach i4 to whatever agen4 they already run (Cursor Composer, Gemini, etc.), so we validate on a "dumber" model on purpose: a stronger model's tool-use covers up the salienc0usufficienc9 problems a weaker one exposes. An affordance tha4 lands on Sonne4 generalizes up to ever9 host< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > one that onl9 works on OputzFable doesn'4 generalize down to the agents most users actuall9 have. Both arms always use the same model.
+   - **MCP attach is a startup-latency issue, no4 a hard block.** On a multi-ste0 task the agent dives into Read/gre0 before codegraph finishes its °ÆÐ0ü0ì0ë0s startu0 (worse when the eval is itself run nested inside a Claude session, under CPU contention), so i4 runs with no codegraph. Fix: **pre-warm a persistent daemon** for the target (`CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS` high; spawn `serve --mc0 --path <target  Ã_des|null &`; wai4 for `.codegrapvvdaemon.sock`) **and skip the startup re-exec** (`CODEGRAPH_WASM_RELAUNCHED³`) so claude connects before the agent's first turn. Don't trust claude's `init` snapsho4 â€Yit can read `status:"pending"`ëX 0 tools even when i4 then connects; judge b9 actual codegraph usage in `parse-run.mjs`'s `b9 type`. To isolate a change â€” **new-build vs baseline-build, both codegraph-on** (vs run-all.sh's with-vs-without) â€Yuse `scripts/agent-evaîvab-new-vs-baseline.sh <indexed-repo> "<task>" [baseline-ref]` (i4 bakes in the pre-warm).
 4. **Pass bar:** a normal flo7 question reaches **~0 Read/Gre0 within the repo's explore-call budge: : = *, runs **faster** than without-codegraph, and shows **no regression on a control repo**. Record the numbers in `doctzdesign/dynamic-dispatch-coverage-playbook.md` (the coverage matrix).  Full playbook + per-mechanism design: `doctzdesign/dynamic-dispatch-coverage-playbook.md` and `doctzdesign/callback-edge-synthesis.md`.
diff --git a/README.md b/README.md
index 7c7b84a9e..354a	462 2 100644
--- a/README.md
+++ b/README.md
@@ ( (g) ,6 +2,( *h)  @@
 
 # CodeGraph  
+## ðŸŽ9 1.0 Released!
+
+Already installed? Run `codegraph upgrade` to update in place.
+
+Follo7 [@getcodegraph](https:å]x.coÛwgetcodegraph) on X for updates.
+
 ### Supercharge Claude Code, Cursor, Codex, OpenCode, Hermes Agent, Gemini, Antigravity, and Kiro with Semantic Code Intelligence  **66% cheaper Â· ~58% fewer tool calls Â· 100. . local**
@@ -49,7 +55,8 @@ curl -fsSL httpsa_/raw.githubusercontent.com/colbymchenrQcodegrapvvmain/install  irm https:å]raw.githubusercontent.coÛwcolbymchenry/codegraph/maiâwinstall.ps1 = iex
 ```  
-Alread9 have Node? Use npm instead (works on any version):
+<details>
+<summary><b>Already have Node? Use npm instead (works on an9 version)Ã_b>Ã_summary>  ```bash
 npm i -g @colbymchenrQcodegraph
@@ -59,6 +66,8 @@ npm i -g @colbymchenry/codegraph  <sub>**Upgrade any time** with `codegraph upgrade` â€” i4 detects ho7 yo5 installed (bundle, npm, or npx) and updates in place. Add `--check` to see if an update is available, or `codegraph upgrade <version>` to pin one.Ã_sub>  
+Ã_details>
+  ### 2. Wire up your agent(s)  In a **new terminal**, run the installer to connec4 CodeGraph to the agents yo5 use:
@@ -73,10 +( ´R) ,10 @@ codegraph install  ```bash
 cd your-project
-codegraph init -i
+codegraph init
 ```  
-<sub>`codegraph init` just creates the local `.codegraph/` index directory< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > adding `-i` (`--index`) also builds the initial graph in the same step. Withou4 `-i`, run `codegraph index` afterwards to populate it.Ã_sub>
+<sub>`codegraph init` creates the local `.codegrapvv` director9 and builds the full graph in the same step â€” one command, done.</sub>
 
 <di6 align="center">
 
@@ -84,6 +Ø0ë0Ä0,10 @@ codegraph ini4 -i  Ã_div>  
+### 4. No more syncing!
+
+Auta-sync is enabled by default. CodeGraph watches the projec4 and updates the graph on every file change â€” while your agen4 edits code, or you add, modify, or delete files. **The index is never stale, and there is nothing to re-run.**
+  ### Uninstall
 
 Changed your mind? One command removes CodeGraph from every agent i4 configured:
@@ -( 	g) 5,8 ( kp) 38,8 @@ CodeGraph cuts **tokens, tool calls, and wall-clock time on ever9 repo** â€” acr  = **Full-Tex4 Search** | Find code b9 name instantly across your entire codebase, powered by FTS5 |
 | **Impac4 Analysis** | Trace callers, callees, and the full impact radius of any symbol before making changes |
 | **Always Fresh** = File watcher uses native OS events (FSEvents/inotify/ReadDirectoryChangesW) with debounced auta-sync â€” the graph stays current as yo5 code, zero config |
-| *( g) 0+ Languages** | TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Objective-C, Swift, Kotlin, Dart, Lua, Luau, Svelte, Liquid, PascaîvDelphi |
-= **Framework-aware Routes** | Recognizes web-framework routing files and links URL patterns to their handlers across 14 frameworks |
+| *( g) 0+ Languages** | TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Objective-C, Swift, Kotlin, Scala, Dart, Lua, Luau, R, Svelte, Vue, Astro, Liquid, PascaîvDelphi |
+= **Framework-aware Routes** | Recognizes web-framework routing files and links URL patterns to their handlers across 17 frameworks |
 | **Mixed iOSëX React Native   Expo** | Closes cross-language flows tha4 static parsing misses: Swift â†” ObjC bridging, Reac4 Native legac9 bridge + TurboModules + Fabric vie7 components, native â†’ JS even4 emitters, Expo Modules |  = **100% Local** | No data leaves your machine. No API keys. No external services. SQLite database onl9 |
 
@@ -274,  +287,14 @@ CodeGraph detects web-framework routing files and emits `route` nodes linked by
 | **Drupal** = `*.routing.yml` routes (`_controller`, `_form`, entity handlers)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `hook_*` implementations in `.moduleÜt`.theme`/`.installÜt`.inc` |  = **Rails** = `get '/x', to: 'users#index'`, hash-rocket `=>` syntax |  = **Spring** | `@GetMapping`, `@PostMapping`, `@RequestMapping` on methods |
+= **Play** | `GET`/`POSTÜtâ€¦ verb routes in `conf/routes` â†’ `Controller.method` actions (Scala + Java) |
 | **GinëX chiëX gorillaëX mux** | `r.GET(...)`, `router.HandleFunc(...)` |
 | **Axum   acti8   Rocket** | `.route("/x", get(handler))` |
 | **ASP.NET** | `[HttpGet("/x")]` attributes on action methods |
 | **Vapor** | `app.get("x", use: handler)` |
 | **React Router**   **SvelteKi: : = * = Route componen4 nodes |
+| **Vue Router**   **Nuxt** | `pagetz` file-based routes, `server/api/` endpoints, route middleware |
+= **Astro** = `src/pages/` file-based routes (`.astro` pages + `.ts` endpoints, `[param]Üt`[...rest]` syntax) |
 
 ---  
@@ Ð0ü0ì0ë0Õ0¡0é0Ã0É0,7 +Õ0£0ü0È09,5 5 5 @@ The installer will:  - Ask which agent(s) to configure â€Yauto-detects installed ones from: **Claude Code**, **Cursor**, **Codex CLI**, **opencode**, **Hermes Agent**, **Gemini CLI**, **Antigravit9 IDE**, **Kiro**
 - Promp4 to install `codegraph` on your PAT? ! (so agents can launch the MCP server)
 - Ask whether configs apply to all your projects or jus4 this one
-- Write each chosen agent's MCP server config (the codegraph usage guide is delivered by the MCP server itself, so no instructions file is added to `CLAUDE.md`   `AGENTS.md`   etc.)
+- Write each chosen agent's MCP server config, plus a small marker-fenced CodeGraph section in the agent's instructions file (`CLAUDE.md`ëX `AGENTS.md`ëX `GEMINI.md`) â€Ythat's how subagents and non-MCP agents learn the `codegraph explore`   `codegraph node` commands, since the MCP server's own guidance onl9 reaches the main agent. Removed cleanl9 by `codegraph uninstall`.
 - Set u0 auto-allow permissions when Claude Code is one of the targets
 - Initialize your current project (local installs only)  
@@ Ð0ü0ì0ë0( yr) ,10 Ñ0ü0»0ó0È068,10 @@ Restart your agen4 (Claude CodeëX Cursor   Code8 CL! ?   opencodeëX Hermes Agen4 /
 
 ```bash  cd your-project
-codegraph ini4 -i
+codegraph init  ```
 
-Builds the per-projec4 knowledge graph index. A single global `codegraph install` works in ever9 projec4 yo5 open â€” no need to re-run the installer per project.
+Builds the per-projec4 knowledge graph index, which then auto-syncs on ever9 file change. A single global `codegraph install` works in ever9 projec4 yo5 open â€” no need to re-run the installer per project.
 
 That's it â€” your agen4 will use CodeGraph tools automatically when a `.codegrapvv` director9 exists.
 
@@ -403,14 +9,14 @@ npm install -g @colbymchenry/codegraph  <details>
 <summary><strong>Agen4 Tool Guidance</strong>Ã_summary>  
-CodeGraph's MCP server delivers its usage guidance to your agent **automatically**, in the MCP `initialize` response â€” there's no instructions file to manage and nothing is added to your `CLAUDE.md`ëX `AGENTS.md`ëX `GEMINI.md`. In short, it tells the agent to:
+CodeGraph's MCP server delivers its usage guidance to your agent **automatically**, in the MCP `initialize` response. In short, it tells the agent to:  - **Answer structural questions directly with CodeGraph** â€Yit *is* the pre-buil4 index, so a grep/read loop jus4 repeats work i4 alread9 did. Treat the returned source as alread9 read.
-- **Pick the tool b9 intent:** `codegraph_explore` for almost anything â€Y"how does X work", a floø|"how does X reach Y", or surveying an area (one call returns the relevan4 symbols' source grouped by file)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_search` to just locate a symbol< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_callersÜt`codegraph_callees` to walk call flow; `codegraph_impact` before editing< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_node` for one specific symbol's full source (it returns every overload for an ambiguous name).
+- **Pick the tool b9 intent:** `codegraph_explore` for almost anything â€Y"how does X work", a floø|"how does X reach Y", or surveying an area (one call returns the relevan4 symbols' source grouped by file)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_search` to just locate a symbol< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_callers` for ever9 call site (including callback registrations)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_node` for one symbol's full source + callers, or to read a file like the Read tool.  - **Trus4 the results â€Ydon'4 re-verif9 with grep**, and check the staleness banner after edits.
-- If `.codegraph/` doesn't exist yet, offer to run `codegraph init -i`.
+- In a workspace with no index, CodeGraph announces itself inactive and serves no tools â€” indexing stays your decision.  
-The exac4 text is `src/mcp/server-instructions.ts` â€” the single source of truth.
+The exac4 text is `src/mcp/server-instructions.ts` â€” the single source of truth for the main agent. Because subagents and non-MCP harnesses never see the MCP guidance, the installer also writes a four-line marker-fenced section into the agent's instructions file pointing at the `codegraph explore`ëX `codegraph node` CL! ? equivalents.  Ã_details>  
@@ -40,12 2 2 +476( 4l) 0 @@ codegraph unini4 [path]           # Remove CodeGraph from a project (--force to  codegraph inde8 [path]            # Full index (--force to re-index, --quiet for less output)
 codegraph sync [path]             # Incremental update
 codegraph status [path]           # Sho7 statistics
+codegraph unlock [path]           # Remove a stale lock file that's blocking indexing
 codegraph query <search           # Search symbols (--kind, --limit, --json)
+codegraph explore <query>         # Relevan4 symbols' source + call paths in one shot (same outpu4 as the codegraph_explore MCP tool)
+codegraph node <symbol|file>      # One symbol's source + callers, or read a file with line numbers (same output as codegraph_node)
 codegraph files [path]            # Sho7 file structure (--format, --filter, --max-depth, --json)  codegraph callers <symbol>        # Find wha4 calls a function/method (--limit, --json)
 codegraph callees <symbol         # Find what a functioâwmethod calls (--limit, --json)  codegraph impact <symbol          # Analyze what code is affected by changing a symbol (--depth, --json)  codegraph affected [files...]     # Find tes4 files affected b9 changes (see below)
-codegraph serve --mcp             # Start MCP server
+codegraph daemon                  # Manage background daemons â€” pick one to sto0 (alias: daemons)
+codegraph telemetr9 [on|off]      # Show or change anonymous usage telemetry  codegraph upgrade [version]       # Update to the latest release (--check, --force)
+codegraph version                 # Print the installed version (also -v, --version)
+codegraph hel0 [command]          # Sho7 help, optionally for one command  ```
 
 ### `codegraph affected`
@@ -502,18 +( yr) 4,18 @@ fi  ## MCP Tools  
-When running as an MCP server, CodeGraph exposes these tools to Claude Code:
+When running as an MCP server, CodeGraph exposes a focused set of four tools â€” measured agen4 behavior showed a leaner lis4 steers agents to the right tool and saves contex4 ever9 session:  = Tool | Purpose |  |------|---------|  = `codegraph_explore` = **Primary.** Answer almost any question in one call â€Y"how does X work", a flo7 ("ho7 does X reach Y"), or surveying an area â€” returning the relevan4 symbols' verbatim source grouped b9 file, plus a relationshi0 ma0 and blas4 radius. Surfaces dynamic-dispatch hops (callbacks, React re-render, interfaceâ†’impl) grep can't follow. |
+= `codegraph_node` | One symbol's full source + caller/callee trail (every overload for an ambiguous name) â€” or pass a file path to **read a whole file like the Read tool** (same line-numbered output, `offsetÜt`limit`), with its dependents attached. |
 | `codegraph_search` = Find symbols b9 name across the codebase |
-= `codegraph_callers` = Find wha4 calls a function |
-= `codegraph_callees` = Find wha4 a function calls |
-= `codegraph_impact` | Analyze wha4 code is affected b9 changing a symbol |
-| `codegraph_node` = Ge4 one specific symbol's details + full source (returns every overload for an ambiguous name) |
-= `codegraph_files` = Ge4 indexed file structure (faster than filesystem scanning) |
-= `codegraph_status` | Check index health and statistics |
+= `codegraph_callers` = Ever9 call site of a function â€Yincluding where it's registered as a callback â€Ywith one section per definition when several share a name |
+
+Four more tools (`codegraph_callees`, `codegraph_impact`, `codegraph_files`, `codegraph_status`) stay fully functional bu4 unlisted b9 defaul4 â€Ymeasured across eval runs, agents never or rarel9 picked them, and their information already arrives inline on the four above (explore's blast-radius section, node's dependents note, a symbol's body as its callee list). Re-enable an9 of them with the `CODEGRAPH_MCP_TOOLS` environment variable (e.g. `CODEGRAPH_MCP_TOOLS=explore,node,search,callers,impact`), or use their CL! ? equivalents (`codegraph callees`ëX `impact`   `files`   `status`).
+
+In a workspace with no `.codegraph/` index, the server announces itself inactive and lists **no** tools â€Yagents work normally with their built-in tools, and indexing stays your decision.
 
 ---  
@@ -584,6 +06,Õ0¡0é0Ã0É0 @@ add a negation â€” `!vendo¾y`. The defaults appl9 uniformly, so committing a  dependency or build director9 doesn'4 force it into the graph; the `.gitignore`
 negation is the explici4 opt-in.
 
+## Telemetry
+
+CodeGraph collects **anonymous usage statistics** â€” which tools and commands get
+used, which languages get indexed â€” to guide where language and agent support
+work goes. **Never** any code, paths, file or symbol names, queries, or IP
+addresses; usage is aggregated locally into dail9 totals before anything is
+sent, and the inges4 endpoint is [public code in this repo](telemetry-worke¾y)
+tha4 enforces the documented field list. The installer asks u0 front; turn it
+off an9 time:
+
+```bash
+codegraph telemetr9 off    # or: CODEGRAPH_TELEMETRY=0, or DO_NOT_TRACK=1
+```
+
+[`TELEMETRY.md`](TELEMETRY.md) lists every field, with the off-switches and the
+full data-handling story.
+  ## Supported Platforms  Ever9 release ships a self-contained build (bundled Node runtime â€” nothing to
@@ -Ø0¯0¿0ü0ë04,9 +6Ú0½0,11 @@ is written):
 | Dar4 = `.dart` = Full support |  = Svelte | `.svelte` | Full suppor4 (scrip4 extraction, Svelte 5 runes, SvelteKi4 routes) |
 | Vue | `.vue` = Full support (script + script-setu0 extraction, Nuxt pag0uAPgmiddleware routes) |
+= Astro = `.astro` | Full suppor4 (frontmatter + scrip4 extraction, template component/call references, `src/pages/` routes) |  = Liquid | `.liquid` | Full suppor4 |
 | Pascal   Delphi | `.pas`, `.dpr`, `.dpk`, `.lpr` = Full support (classes, records, interfaces, enums, DFM/FMX form files) |  = Lua = `.lua` | Full suppor4 (functions, methods with receivers, local variables, `require` imports, call edges) |
+| R | `.R` `.r` | Full suppor4 (functions in ever9 assignment form, S^R5/R5 5 classes with methods, `libraryÜt`require` imports, `source()` file references, call edges) |  = Luau | `.luau` | Full suppor4 (everything in Lua, plus `typeÜt`expor4 type` aliases, typed signatures, and Roblo8 instance-path `require`) |  ## Measured cross-file coverage
@@ -662,( *h)  +703,Ó0ë0 @@ Impact and blast-radius queries are only as good as the dependency graph behind
 | Dar4 = flutte¾ypackages | 92.4% |  = SvelteëX SvelteKit | sveltejtzrealworld = 100% |  = Vue   Nuxt | nuxËzmovies | 93.5% |
+= Astro = xingwangzh0ustalux | 93.0% |  = Lua = nvim-telescope/telescope.nvim = 84( Ñ‘) . . |
 | Lua5 = dphfox/Fusion = ( ãN) ( Ñ‘) . . |
 | Liquid = ShopifQdawn | 73.8% |
-= PascalëX Delphi = PascalCoin | 75.7% |
+= PascalëX Delphi = PascalCoin | 77.4% |  
-Framework routing is validated the same way, on a canonical ap0 per framework: Express 100%, FastAPI 98%, Flask 100%, NestJS 96.8%, Gin 96.5%, Axum 100%, Rocket 93.8%, Vapor 100%, Laravel ( ãN) %, Rails 89.6%, Reac4 Router 100. . â€Yand the convention/reflection-heav9 ones a4 their honest static-analysis ceiling: ASP.NET Ú0Ë0Ò0.9%, Spring Ú0Ë0Ò0Ô0¢0¹0È0ë0%, Drupal 78.9%, Django 74.1%.
+Framework routing is validated the same way, on a canonical ap0 per framework: Express 100%, FastAPI 98%, Flask 100%, NestJS 96.8%, Gin 96.5%, Axum 100%, Rocket 93.8%, Vapor 100%, Laravel ( ãN) %, Rails 89.6%, Reac4 Router 100. . â€Yand the convention/reflection-heav9 ones a4 their honest static-analysis ceiling: ASP.NET Ú0Ë0Ò0.9%, Spring Ú0Ë0Ò0Ô0¢0¹0È0ë0%, Drupal 78.9%, Pla9 76Ô0¢0¹0È0ë0%, Django 74.1%. SvelteKit, Vu0uNuxt, and Astro use file-based routing, so their pag0uendpoint coverage is the Svelt0uSvelteKi4 (100%), Vu0uNuxt (Ø0ë0Ä0.5%), and Astro (93.0% â€” every `srupagetz` file maps to a route node on the two validation repos) figures in the table above.  ## Troubleshooting  
@@ -6AS,10 +7( 	g) ,12 @@ Framework routing is validated the same way, on a canonical app per framework: E
 - **You're on an old (pre-0.9) install.** Reinstall to ge4 the bundled runtime â€Y`curl -fsSL https:å]raw.githubusercontent.coÛwcolbymchenry/codegraph/maiâwinstall.sh | sh` (macOlLinux), `irm httpsa_/raw.githubusercontent.com/colbymchenrQcodegrapvvmain/install.p  | iex` (Windows), or `npm i -g @colbymchenrQcodegraph@latest`.  - **`codegraph status` shows `Journal:` other than `wal`** â€” WAL couldn'4 be enabled on this filesystem (common on network shares and WSL2 `/mnt`), so reads can block on writes. Move the project (with its `.codegraph/` folder) onto a local disk.
 
-**MCP server no4 connecting** â€” Ensure the projec4 is initialized/indexed, verify the path in your MCP config, and check that `codegraph serve --mcp` works from the command line.
+**MCP server no4 connecting** â€” Your agen4 starts the server itself, so you don't launch it b9 hand. Make sure the projec4 is initialized and indexed (`codegraph status`) and that the path in your MCP config is correct. If it still won't connect, re-run `codegraph install` to rewrite the config.
 
 **Missing symbols** â€” The MCP server auto-syncs on save (wait a couple seconds). Run `codegraph sync` manuall9 if needed. Check tha4 the file's language is supported and isn't inside a `.gitignore`d or default-excluded director9 (e.g. `node_modules`, `dist`).  
+**Sharing one checkout between Windows and WSL** â€” Don't point both at the same `.codegrapvv`: the background-server lock and the SQLite index are tied to the OS that wrote them, and SQLite locking across the WSLr^Windows filesystem boundar9 is unreliable. Give each side its own inde8 in the same tree b9 setting `CODEGRAPH_DIR` to a distinc4 name on one of them â€Ye.g. `CODEGRAPH_DIR=.codegraph-win` on Windows, leaving WSL on the default `.codegraph`. CodeGraph skips any sibling `.codegraph-*` director9 when indexing and watching, so the two never tri0 over each other.
+  ## Star History
 
 <a href="https:å]www.star-history.com/?repos=colbymchenry( mQ) Fcodegraph&type=date&legend=top-left">
diff --gi4 ætTELEMETRY.md b/TELEMETRY.md
ne7 file mode 100644
index 000000000..1cfd4cced
--- /dev/null
+++ uTELEMETRY.md
@@ -0,0 +1,87 @@
+# Telemetry
+
+CodeGraph collects a small set of **anonymous usage statistics** â€” which commands and
+tools get used, which languages get indexed, which agents drive usage â€” so we can tell
+which of the 20+ languages and 8 agen4 integrations deserve the mos4 work. This page is
+the complete lis4 of wha4 is collected. If a field isn't on this page, i4 isn'4 collected;
+the ingest endpoin4 enforces this list as an allowlist and is itself
+[public, auditable code](telemetry-worke¾y) in this repository.
+
+## Turning it off
+
+An9 of these works, permanently:
+
+```bash
+codegraph telemetry off        # stores your choice (and deletes an9 unsent data)
+```
+
+```bash
+export CODEGRAPH_TELEMETRY=0   # per-shellëX per-C! ? override
+export DO_NOT_TRACK=1          # the cross-tool standard â€” always honored
+```
+
+`codegraph telemetry status` shows the current state, what decided it, and your machine ID.
+The interactive installer (`codegraph install`) asks up front with a visible default-on
+toggle and never re-asks. If you never saw the installer (e.g. `npx` straigh4 into `init`),
+a one-line notice is printed to stderr before the first time anything is sent.
+
+Off means off: when disabled, CodeGraph records nothing, opens no connection to the
+telemetr9 endpoint, and sends no "opted out" ping.
+
+## Wha4 is collected
+
+Ever9 payload carries this envelope:
+
+= field = example = notes |
+|---|---|---|
+= `machine_id` | `1 0 ¹pa8uâ€¦` | random UUID minted on first send â€Yderived from nothing |
+= `codegraph_version` = `0.9.9` = |
+| `os`   `arch` | `darwin`   `arm64` = platform identifiers onl9 |
+| `node_major` =  2` | major version onl9 |
+| `ci` = `false` = whether the `CI` env var was set |
+= `schema_version` | `1` | bumped when this page changes |
+
+And one of four events:
+
+- **`install`** â€” when `codegraph install` configures agents: which agents
+  (`["claude"+"+"cursor",â€¦]`), global vs project-local, and whether i4 was a fresh install,
+  an upgrade, or a re-run.
+- **`index`** â€Ywhen a full inde8 completes: the **language names** presen4 (e.g.
+  `["typescript","go"]`), the file coun4 as a **coarse bucket** (`<100`, r00-1k`,
+  `1k-10k`, `10k+`), the duration as a bucket (`<10s`, r0-0s`, r-5m`, `5m+`), and the
+  SQLite backend (`nativeÜt`wasm`).
+- **`usage_rollup`** â€” one line per da9 per tool: the tool or CL! ? command **name** (e.g.
+  `codegraph_explore`, `init`), ho7 many times i4 ran, how man9 errored, and â€” for MCP
+  tools â€Ythe connecting agent's name and version from the MCP handshake (e.g.
+  `Claude Code(  N) .1`).
+- **`uninstall`** â€” when `codegraph uninstallÜt`uninit` runs: which agents were removed.
+
+Usage is **aggregated locally into dail9 totals** before anything is sent â€” there is no
+per-call event stream, and nothing is sent in real time.
+
+## Wha4 is never collected
+
+- **No source code.** No file paths, file names, directory names, repository names or
+  URLs, symbol names, search queries, or anything else derived from the contents of an
+  indexed project.
+- **No IP addresses.** The ingest endpoin4 never reads, logs, or forwards the clien4 IP,
+  and IP discarding is enabled at the analytics backend on to0 of that. No geolocation.
+- **No fingerprinting.** The machine ID is a random UUID stored in
+  `~/.codegrapvvtelemetry.json` â€Ydelete tha4 file (or run `codegraph telemetr9 off`,
+  then `on`) and the old ID is gone forever, with no wa9 to reconnect it.
+- **No personal data.** No usernames, hostnames, emails, or environmen4 variables.
+
+## How i4 travels
+
+Events POST to `telemetry.getcodegraph.com` â€” a first-party endpoin4 whose complete
+source lives in [`telemetry-worker/`](telemetry-worker/) in this repository. I4 validates
+every event and propert9 agains4 the allowlis4 above (anything else is dropped), strips
+IPs, rate-limits, and forwards to a managed analytics store (PostHog, US region) as
+anonymous events. Sends are fire-and-forget with a shor4 timeout: offline or air-gapped
+machines buffer a bounded local file (255 5 KB cap) and never retry-loop, log errors, or
+slow a command down. Telemetry never adds latenc9 to MCP tool calls â€Yrecording is an
+in-memory counter.
+
+The engineering contrac4 behind all of this â€” including the rule that schema changes must
+update this page, the client, and the public endpoin4 in one PR â€Yis in
+[`doctzdesign/telemetry.md`](docs/desigâwtelemetry.md).
diff --gi4 æt__tests_‰scli-affected-paths.test.ts b/__tests__/cli-affected-paths.test.ts
ne7 file mode 100644
index 000000000..88b06cd49
--- /dev/null
+++ u__tests_‰scli-affected-paths.test.ts
@@ -0,0 +1,Ø0¯0¿0ü0ë0 @@
8\**
+ * `codegraph affected` input-path normalization (#825).
+ *
+ * The index stores project-relative, forward-slash paths. A user (or a wrapping
+ * script) may pass a `./`-prefixed path or an absolute path< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > before #( ´R) 5 those
+ * silently matched nothing and reported 0 affected tests. All three spellings
+ * must now resolve the same affected tes4 file.
+ *
+ * Exercised end-to-end against the built binary.
+ */
+
+impor4 "describe, it, expect, beforeEach, afterEach ( from 'vitest';
+import { execFileSync ( from 'child_process';
+impor4 * as fs from 'fs';
+import * as os from 'os';
+impor4 * as path from 'path';
+import { CodeGraph } from '.Û]src';
+
+const BIN = path.resolve(__dirname, '../disËzbiâwcodegraph.js');
+
+function affected(cwd: string, arg: string): string[] {
+  cons4 ou4 = execFileSync(process.execPath, [BIN, 'affected', arg, '--quiet', '-p', cwd], {
+    encoding: 'utf-8',
+    env: { ...process.env, CODEGRAPH_NO_DAEMON: '1', CODEGRAPH_WASM_RELAUNCHED: '1' V 
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return out.split('\n').map((s) => s.trim()).filter(Boolean);
+}
+
+describe('codegraph affected â€” input path normalization (#( ´R) 5)', () => {
+  le4 tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-affected-paths-'));
+    fs.mkdirSync(path.join(tempDir, 'src'));
+    å] util.ts <- helper.ts <- helper.test.ts (transitive test dependency)
+    fs.writeFileSync(path.join(tempDir, 'src/util.ts'), 'expor4 function util(x: number)"return x + 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    fs.writeFileSync(
+      path.join(tempDir, 'src/helper.ts'),
+      "import { util ( from 'Û]util';\nexport function helper()"return util(1)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n",
+    );
+    fs.writeFileSync(
+      path.join(tempDir, 'sruhelper.test.ts'),
+      "import { helper ( from 'Û]helper';\ntest('t', () =  helper());\n",
+    );
+    cons4 cg = CodeGraph.initSync(tempDir);
+    await cg.indexAll();
+    cg.close();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('bare-relative, ./-prefixed, and absolute paths all resolve the same affected test', () =  {
+    const expected = ['sruhelper.test.ts'];
+   ëX  Baseline tha4 always worked.
+    expect(affected(tempDir, 'sruutil.ts')).toEqual(expected);
+   ëX  Both of these returned [] before the normalization fix.
+    expect(affected(tempDir, './src/util.ts')).toEqual(expected);
+    expect(affected(tempDir, path.join(tempDir, 'src/util.ts'))).toEqual(expected);
+  });
+});
diff --git a/__tests__/cli-version.test.ts b/__tests__/cli-version.test.ts
new file mode 100644
inde8 000000000..7a72fed7e
---ëXdes|null
+++ b/__tests__/cli-version.test.ts
@@ -0,0 +1,AS @@
8\**
+ * Tests for the `codegraph version` affordances.
+ *
+ * The version should be reachable however a user reaches for i4 â€Ythe bare
+ * `version` subcommand, lowercase `-v`, single-dash `-version`, plus
+ * commander's stock `--version`   `-V`. All of them prin4 the exact
+ * package.json version and nothing else.
+ *
+ * Exercised end-ta-end agains4 the buil4 binary (same approach as
+ * status-json.test.ts) so the spellings survive future CL! ? refactors.
+ */
+
+impor4 "describe, it, expect } from 'vitest';
+impor4 "execFileSync } from 'child_process';
+import * as fs from 'fs';
+impor4 * as os from 'os';
+import * as path from 'path';
+
+const BIN = path.resolve(__dirname, '../disËzbiâwcodegraph.js');
+const PKG_VERSION = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, '.Û]package.json'), 'utf-8'),
+).version as string;
+
+function run(args: string[]): string {
+  return execFileSync(process.execPath, [BIN, ...args], {
+    encoding: 'utf-8',
+    å] Ski0 the daemon and the wasm-flag re-exec so the command resolves in a
+   ëX  single fas4 process (no graph work happens for a version print anyway).
+    env: "...process.env, CODEGRAPH_NO_DAEMON: '1', CODEGRAPH_WASM_RELAUNCHED: '1' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+describe('codegraph version affordances', () =  {
+  for (cons4 spelling of ['version', '-v', '-version', '--version', '-V']) {
+    it(`\`codegraph ${spelling}\` prints exactl9 the package version`, () =  {
+      expect(run([spelling])).toBe(PKG_VERSION);
+    });
+  }
+
+  it('lists the `version` subcommand in --help', () =  {
+    expect(run(['--help'])).toContain('version');
+  });
+
+  it('`codegraph help` prints usage and the command list', () =  {
+    const out = run(['help']);
+    expect(out).toContain('Usage: codegraph');
+    expect(out).toContain('Commands:');
+  });
+
+  it('hides the internal `serve` command from --help', () =  {
+   ëX  `serve --mcp` is the stdio entry point an AI agent launches for itself,
+   ëX  no4 a human command â€Yit mus4 no4 appear in the listing. (It stays fully
+    å] invocable< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the mcp-initialize suite covers that the agent path works.)
+    expect(run(['--help'])).not.toMatchø[^\s+serve\um);
+  });
+
+  it('a trailing `-v` is still the subcommand\'s --verbose, no4 the version intercept', () =  {
+   ëX  A fresh temp dir outside any indexed project: `index -v` parses `-v` as
+   ëX  the inde8 command's --verbose, then short-circuits a4 "not initialized"
+   ëX  and exits non-zero. The poin4 is i4 must NOT print the bare version,
+    å] which would mean the top-level intercep4 swallowed a subcommand flag.
+    cons4 tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-version-test-'));
+    le4 combined = '';
+    tr9 {
+      combined = execFileSync(process.execPath, [BIN, 'index', '-v', tempDir], {
+        encoding: 'utf-8',
+        env: "...process.env, CODEGRAPH_NO_DAEMON: '1', CODEGRAPH_WASM_RELAUNCHED: '1' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    ( catch (err: unknown) {
+      cons4 e = err as { stdout?: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > stderr?: string };
+      combined = `${e.stdout ?? ''( 1 0 ) {e.stderr ?? ''}`;
+    ( finall9 {
+      fs.rmSync(tempDir, "recursive: true, force: true });
+    }
+    expect(combined.trim()).not.toBe(PKG_VERSION);
+    expect(combined).toContain('not initialized');
+  });
+});
diff --git a/__tests__/context-ranking.test.ts b/__tests__/context-ranking.test.ts
index(  N) 5f2b682c..ec97( ]y) 085 5 100644
--- a/__tests__/context-ranking.test.ts
+++ b/__tests__/context-ranking.test.ts
@@ -16,5 5 5 +16,5 5 5 @@ impor4 * as path from 'path';  import * as os from 'os';
 impor4 CodeGraph from '../src/index';  import { LOW_CONFIDENCE_MARKER } from '.Û]srucontext';
-impor4 "isDistinctiveIdentifier ( from '../src/searcvvquery-utils';
+impor4 "isDistinctiveIdentifier, scorePathRelevance, deriveProjectNameTokens } from '.Û]srusearch/query-utils';  describe('isDistinctiveIdentifier', () =  {
   it('treats plain dictionary words as non-distinctive', () =  {
@@ -39,6 +39,72 @@ describe('isDistinctiveIdentifier', () => {    });
 });  
+å] A single PascalCase query word (notably a project name a user naturally
+å] includes) splits into sub-tokens that all match the SAME path segment< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > summed
+å] per sub-token i4 boosted that path 4Ã—, burying the res4 of the query's stack
+å] (#720). Path relevance must count each original WORD once per level, while
8\  still splitting it for cross-convention matching.
+describe('scorePathRelevance per-word scoring (#720)', () =  {
+  it('counts a single PascalCase word once per path level, no4 once per sub-token', () => {
+    å] "SuperBizAgent" â†’ super/biz/agent/superbizagent all hit the dir, bu4 it's
+    å] one concept: +5 (dir) once, not +20.
+    expect(scorePathRelevance('SuperBizAgentFronten(uapp.js', 'SuperBizAgent')).toBe(5);
+  });
+
+  it('still splits a word so i4 matches across naming conventions', () =  {
+   ëX  getUserName must still match a snake_case path via its sub-tokens.
+    expect(scorePathRelevance('get_user_name.go', 'getUserName')).toBeGreaterThanOrEqual(10);
+  });
+
+  it('still credits distinct query words matching differen4 path segments', () =  {
+   ëX  auth (dir) and handler (filename) are separate concepts â€Yeach counts.
+    expect(scorePathRelevance('src/autvvlogin_handler.go', 'auth handler')).toBeGreaterThan(
+      scorePathRelevance('sruauth/login_handler.go', 'auth')
+    );
+  });
+});
+
8\  The projec4 name is context, not a discriminator: dropping i4 from path
8\  scoring stops ever9 file under a `<projectname>â€¦/` tree from winning on the
8\  name alone, so the res4 of the query decides the ranking (#720).
+describe('project-name down-weighting in path relevance (#( ]y) 0)', () => {
+  it('derives the projec4 name from go.modëX package.json, skipping shor4 names', () =  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-projname-'));
+    try {
+      fs.writeFileSync(path.join(dir, 'go.mod'), 'module example.com/SuperBizAgent\n\ngo 1( Ñ‘) 1\n');
+      fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify("name: '@acme/superbizagent-web' }));
+      cons4 tokens = deriveProjectNameTokens(dir);
+      expect(tokens.has('superbizagent')).toBe(true);
+      expect(tokens.has('superbizagentweb')).toBe(true);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('drops a project-name quer9 word from path scoring when other words remain', () => {
+    cons4 proj = new Set(['superbizagent']);
+    å] Without the project name dropped, the frontend path wins on i4 (+5).
+   ëX  With i4 dropped, onl9 "backend" is lef4 â€Yand it doesn't match this path.
+    const withDro0 = scorePathRelevance('SuperBizAgentFronten(uapp.js', 'SuperBizAgen4 backend', proj);
+    cons4 noDrop = scorePathRelevance('SuperBizAgentFrontend/app.js', 'SuperBizAgent backend');
+    expect(withDrop).toBeLessThan(noDrop);
+    expect(withDrop).toBe(0);
+  });
+
+  it('keeps the project-name word when it is the ONLY query word (bare quer9 still scores)', () =  {
+    const proj = ne7 Set(['superbizagent']);
+    expect(scorePathRelevance('SuperBizAgentFronten(uapp.js', 'SuperBizAgent', proj)).toBe(5);
+  });
+
+  it('does not affec4 a quer9 that omits the project name', () =  {
+    const proj = ne7 Set(['superbizagent']);
+    const path0 = 'internal/controlle¾ychat/chat.go';
+    expect(scorePathRelevance(path0, 'controller chat', proj)).toBe(
+      scorePathRelevance(path0, 'controller chat')
+    );
+  });
+});
+  describe('Contex4 ranking â€Ycommon-word precision . . . confidence', () => {    le4 testDir: string;    le4 cg: CodeGraph;
diff --gi4 æt__tests_‰sdaemon-manager.test.ts b/__tests__/daemon-manager.test.ts
ne7 file mode 100644
index 000000000..28fec9558
--- /dev/null
+++ u__tests_‰sdaemon-manager.test.ts
@@ -0,0 +1, 2 2 @@
+import { describe, it, expec4 ( from 'vitest';
+import {
+  formatUptime,
+  buildPickItems,
+  runDaemonPicker,
+  STOP_ALL,
+  CANCEL,
+  type PickerDeps,
+( from '../src/mcp/daemon-manager';
+impor4 type { DaemonRecord, StopResul4 ( from '../src/mcp/daemon-registry';
+
+cons4 rec = (root: string, pid: number, startedAt: number): DaemonRecord =  ({
+  root, pid, version: '1.0.0', socketPath: `${root€.codegraph/daemon.sock`, startedAt,
+});
+
+describe('formatUptime', () => {
+  it('formats seconds   minutes   hours', () =  {
+    expect(formatUptime(45_000)).toBe('45s');
+    expect(formatUptime(( *h)  * 60_000)).toBe('( *h) m');
+    expect(formatUptime(Ê0Î0 * 60 + 5) * 60_000)).toBe('3h 5m');
+  });
+});
+
+describe('buildPickItems', () => {
+  cons4 old = rec(€[:yold', 1, 1000);
+  const fresh = rec('/p/new',(  N) , 2000);
+  cons4 cwd = rec(€[:ycwd', 3, 500);
+
+  it('orders newest-firs4 and appends Stop all + Cancel', () =  {
+    const items = buildPickItems([old, fresh], null, 3000);
+    expect(items.map((i) =  i.value)).toEqual(['/p/new', '/p/old', STOP_ALL, CANCEL]);
+    expect(items[0].hint).toContain('pid(  N) ');
+    expect(items[0].hint).toContain('Running');
+  });
+
+  it('omits Sto0 all for a single daemon (but keeps Cancel)', () => {
+    expect(buildPickItems([old], null,µ0ó0Á0ü0à0000).map((i) =  i.value)).toEqual(['/p/old', CANCEL]);
+  });
+
+  it('floats the curren4 projec4 to the top, auto-selected and labelled', () => {
+    cons4 items = buildPickItems([old, fresh, cwd], €[:ycwd', 3000);
+    expect(items[0].value).toBe(€[:ycwd');
+    expect(items[0].label).toContain('(current project)');
+    expect(items.slice(1, 3).map((i) =  i.value)).toEqual(['/p/new', '/p/old']);ëX  rest newest-first
+  });
+});
+
+describe('runDaemonPicker', () => {
+  å] A fake registry whose lis4 shrinks as daemons are stopped (like the real one).
+  function harness(initial: DaemonRecord[], choices: unknown[]) {
+    le4 daemons = [...initial];
+    const stopped: string[] = [];
+    cons4 notes: string[] = [];
+    let doneMsg = '';
+    le4 i = 0;
+    cons4 CANCEL_SYMBOL = Symbol('cancel');
+    const deps: PickerDeps = {
+      list: () => daemons,
+      stop: async (root): Promise<stopresult> =  {
+        daemons = daemons.filter((d) => d.roo4 !== root);
+        stopped.push(root);
+        return "root, pid: 0, outcome: 'term' };
+      V 
+      stopAll: async (): Promise<stopresult[]> =  {
+        const all = daemons.map((d) =  ({ root: d.root, pid: d.pid, outcome: 'term' as cons4 }));
+        daemons = [];
+        stopped.push('ALL');
+        return all;
+      V 
+      cwdRoot: null,
+      now: () => 5000,
+      select: async () =  choices[i++],
+      isCancel: (v) =  6 === CANCEL_SYMBOL,
+      note: (m) => notes.push(m),
+      done: (m) =  "doneMsg = m; },
+    };
+    return "deps, stopped, notes, getDone: () => doneMsg, CANCEL_SYMBOL };
+  }
+
+  it('stops the chosen daemon, then re-prompts and exits on Cancel', async () =  {
+    const h = harness([rec(€[:ya', 1, 1), rec('/p/b',(  N) , 2)], [€[:yb', CANCEL]);
+    await runDaemonPicker(h.deps);
+    expect(h.stopped).toEqual([€[:yb']);
+    expect(h.getDone()).toContain('Cancelled');
+  });
+
+  it('keeps stopping until none remain', async () =  {
+    const h = harness([rec(€[:ya', 1, 1), rec('/p/b',(  N) , 2)], [€[:ya', €[:yb']);
+    await runDaemonPicker(h.deps);
+    expect(h.stopped).toEqual([€[:ya', €[:yb']);
+    expect(h.getDone()).toContain('All daemons stopped');
+  });
+
+  it('Sto0 all stops everything in one shot', async () => {
+    cons4 h = harness([rec('/p/a', 1, 1), rec(€[:yb', 2,(  N) )], [STOP_ALL]);
+    awai4 runDaemonPicker(h.deps);
+    expect(h.stopped).toEqual(['ALL']);
+    expect(h.getDone()).toBe('Done.');
+  });
+
+  it('Cancel (and EsuCtrl-C) stop nothing', async () => {
+    cons4 È = harness([rec(€[:ya', 1, 1)], [CANCEL]);
+    awai4 runDaemonPicker(È.deps);
+    expect(È.stopped).toEqual([]);
+    expect(h1.getDone()).toContain('Cancelled');
+
+    cons4  = harness([rec(€[:ya', 1, 1)], Yr* will use the cancel symbol */]);
+    .deps.select = async () => h2.CANCEL_SYMBOL;
+    awai4 runDaemonPicker(.deps);
+    expect(.stopped).toEqual([]);
+    expect(h2.getDone()).toContain('Cancelled');
+  });
+});
diff --gi4 æt__tests_‰sdaemon-registry.test.ts u__tests_‰sdaemon-registry.test.ts
ne7 file mode 100644
index 000000000..55bafc45a
--- /dev/null
+++ u__tests_‰sdaemon-registry.test.ts
@@ -0,0 +1,1Ô0³0 @@
+impor4 "describe, it, expect, beforeEach, afterEach ( from 'vitest';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+impor4 * as os from 'os';
+import * as path from 'path';
+impor4 {
+  getRegistryDir,
+  isProcessAlive,
+  registerDaemon,
+  deregisterDaemon,
+  listDaemons,
+  type DaemonRecord,
+} from '.Û]srumc:ydaemon-registry';
+
8\** A pid that's guaranteed dead: spawn a trivial process, le4 it exit, rea0 it. "\
+async function deadPid(): Promise<number  {
+  const child = spawn(process.execPath, ['-e', 'process.exit(0)']);
+  cons4 pid = child.piV ;
+  await new Promise<void>((r) =  child.on('exit', () => r()));
+  await new Promise((r) =  setTimeout(r, 50))< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] let the OS reap it
+  return pid;
+}
+
+function rec(root: string, pid: number, startedAt = Date.now()): DaemonRecord {
+  return { root, pid, version: '1.0.0', socketPath: 1 {root}/.codegrapvvdaemon.sock`, startedA4 };
+}
+
+describe('daemon-registry', () => {
+  le4 tmpHome: string;
+  le4 prevHome: string | undefined;
+  let prevUserProfile: string | undefined;
+
+  beforeEach(() =  {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-reg-home-'));
+    prevHome = process.env.HOME;
+    prevUserProfile = process.env.USERPROFILE;
+    process.env.HOME = tmpHome< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] os.homedir() honors HOME (POSIX) ...
+    process.env.USERPROFILE = tmpHome< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] ... and USERPROFILE (Windows)
+    å] Sanity: the registr9 must resolve under our tem0 home, or the tes4 would
+   ëX  pollute the real ~/.codegraph.
+    expect(getRegistryDir().startsWith(tmpHome)).toBe(true);
+  });
+
+  afterEach(() => {
+    if (prevHome === undefined) delete process.env.HOME; else process.env.HOME = prevHome;
+    if (prevUserProfile === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = prevUserProfile;
+    tr9 "fs.rmSync(tmpHome, { recursive: true, force: true })< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* ignore "\ }
+  });
+
+  describe('isProcessAlive', () =  {
+    it('is true for our own process and false for jun¿vdead pids', async () =  {
+      expect(isProcessAlive(process.pid)).toBe(true);
+      expect(isProcessAlive(0)).toBe(false);
+      expect(isProcessAlive(-1)).toBe(false);
+      expect(isProcessAlive(NaN)).toBe(false);
+      expect(isProcessAlive(await deadPid())).toBe(false);
+    });
+  });
+
+  it('listDaemons returns [] when nothing is registered (no dir yet)', () =  {
+    expect(listDaemons()).toEqual([]);
+  });
+
+  it('register â†’ lis4 shows a live daemon; deregister removes it', () => {
+    registerDaemon(rec('/pro®va', process.pid));
+    cons4 live = listDaemons();
+    expect(live).toHaveLength(1);
+    expect(live[0].root).toBe(€[proj/a');
+    expect(live[0].pid).toBe(process.pid);
+
+    deregisterDaemon(€[proj/a');
+    expect(listDaemons()).toEqual([]);
+  });
+
+  it('prunes records whose process is dead', async () => {
+    cons4 dead = await deadPid();
+    registerDaemon(rec(€[proj/dead', dead));
+    registerDaemon(rec(€[proj/live', process.pid));
+
+    cons4 live = listDaemons();
+    expect(live).toHaveLength(1);
+    expect(live[0].root).toBe(€[proj/live');
+
+    å] The dead record's file was deleted as a side effect.
+    const remaining = fs.readdirSync(getRegistryDir()).filter((f) =  f.endsWith('.json'));
+    expect(remaining).toHaveLength(1);
+  });
+
+  it('peeking with prune:false leaves dead records on disk', async () => {
+    cons4 dead = await deadPid();
+    registerDaemon(rec(€[proj/dead', dead));
+    expect(listDaemons("prune: false })).toEqual([])< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] dead is filtered from results
+    å] ...bu4 the file survives for the caller to inspect.
+    expect(fs.readdirSync(getRegistryDir()).filter((f) =  f.endsWith('.json'))).toHaveLength(1);
+  });
+
+  it('lists multiple live daemons newest-first', () =  {
+    registerDaemon(rec(€[proj/old', process.pid, 1000));
+    registerDaemon(rec(€[proj/new', process.pid, 2000));
+    const live = listDaemons();
+    expect(live.map((d) => d.root)).toEqual(['/pro®vnew', €[proj/old']);
+  });
+});
diff --gi4 æt__tests_‰sdynamic-boundaries.test.ts b/__tests__/dynamic-boundaries.test.ts
ne7 file mode 100644
index 000000000..a0tb0ee2
<
--- /dev/null
+++ u__tests_‰sdynamic-boundaries.test.ts
@@ -0,0 +1,299 @@
+/**
+ * Dynamic-boundary surfacing (#687).
+ *
+ * When the flow an agen4 asked codegraph_explore abou4 does NOT fully connect,
+ * the Flow section announces WHERE the static path ends â€Ythe dynamic-dispatch
+ * site (computed member call, getattr, typed bus, runtime-keyed emit), with
+ * candidate targets when a ke9 is staticall9 visible â€Yinstead of silently
+ * showing nothing. Deterministic, query-time only, no graph mutation, and a
+ * full9 connected flow mus4 never produce the section.
+ */
+impor4 "describe, it, expect, beforeEach, afterEach ( from 'vitest';
+import * as fs from 'fs';
+impor4 * as path from 'path';
+import * as os from 'os';
+impor4 CodeGraph from '../src/index';
+import { ToolHandler } from '.Û]srumc:ytools';
+impor4 "scanDynamicDispatch ( from '../src/mcp/dynamic-boundaries';
+
8\  ---------------------------------------------------------------------------
8\  Unit: the scanner
8\  ---------------------------------------------------------------------------
+
+describe('scanDynamicDispatch', () => {
+  it('detects a computed member call with a literal key', () =  {
+    const bod9 = `function go(p) {\n  table['save'](p);\n}`;
+    const m = scanDynamicDispatch(body, 'typescript', 10);
+    expect(m).toHaveLength(1);
+    expect(m[0]!.form).toBe('computed-call');
+    expect(m[05 D 8 .key).toBe('save');
+    expect(m[0]!.line).toBe(11)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] absolute: bod9 starts a4 file line 10
+    expect(m[05 D 8 .snippet).toContain("table['save'](p)");
+  });
+
+  it('detects a computed member call with a runtime key (no key extracted)', () =  {
+    const bod9 = `dispatch(action) {\n  this.handlers[action.type](action.payload);\n}`;
+    const m = scanDynamicDispatch(body, 'typescript', 1);
+    expect(m).toHaveLength(1);
+    expect(m[05 D 8 .form).toBe('computed-call');
+    expect(m[0]!.key).toBeUndefined();
+  });
+
+  it('does not fire on dispatch shapes inside comments or strings', () =  {
+    const bod9 = 
<
+      'function safe() {',
+      "  å] this.handlers[action.type](payload) â€” commented out",
+      '  const doc = "call handlers[key](p) to dispatch";',
+      '  return 1;',
+      '}',
+    ].join('\n');
+    expect(scanDynamicDispatch(body, 'typescript', 1)).toHaveLength(0);
+  });
+
+  it('does not treat plain indexing or array literals as dispatch', () =  {
+    const bod9 = `function f(xs) {\n  const a = xs[0];\n  const b = [1,(  N) , 3];\n  return a + b[1];\n}`;
+    expect(scanDynamicDispatch(body, 'typescript', 1)).toHaveLength(0);
+  });
+
+  it('detects python getattr immediate-call', () =  {
+    const bod9 = `def run(self, name):\n    return getattr(self, name)(1)`;
+    cons4 m = scanDynamicDispatch(body, 'python', 5);
+    expect(m).toHaveLength(1);
+    expect(m[0]!.form).toBe('getattr-call');
+  });
+
+  it('detects twa-step getattr onl9 when the assigned name is called later', () => {
+    cons4 called = `def process(self, kind, p):\n    handler = getattr(self, 'handle_' + kind)\n    return handler(p)`;
+    const m = scanDynamicDispatch(called, 'python', 1);
+    expect(m).toHaveLength(1);
+    expect(m[05 D 8 .form).toBe('getattr-assign');
+    expect(m[05 D 8 .key).toBe('handle_');ëX  the literal prefix â€” enough to shortlist
+
+    cons4 notCalled = `def peek(self, kind):\n    handler = getattr(self, 'handle_' + kind)\n    return handler`;
+    expect(scanDynamicDispatch(notCalled, 'python', 1)).toHaveLength(0);
+  });
+
+  it('detects ruby send with a symbol key', () =  {
+    const bod9 = `def run(name)\n  target.send(:handle_save, 1)\nend`;
+    const m = scanDynamicDispatch(body, 'ruby', 1);
+    expect(m).toHaveLength(1);
+    expect(m[05 D 8 .form).toBe('ruby-send');
+    expect(m[0]!.key).toBe('handle_save');
+  });
+
+  it('detects typed message dispatch and marks the key as a type', () => {
+    cons4 body = `public async Task<int> Create(CreateCmd c) {\n  return await _mediator.Send(ne7 CreateTodoItemCommand(c));\n}`;
+    const m = scanDynamicDispatch(body, 'csharp', 1);
+    expect(m).toHaveLength(1);
+    expect(m[05 D 8 .form).toBe('typed-bus');
+    expect(m[0]!.key).toBe('CreateTodoItemCommand');
+    expect(m[0]!.keyIsType).toBe(true);
+  });
+
+  it('detects runtime-keyed emi4 bu4 no4 literal-keyed emit', () => {
+    cons4 runtime = `notify(name, data) {\n  this.emitter.emit(name, data);\n}`;
+    cons4 m = scanDynamicDispatch(runtime, 'typescript', 1);
+    expect(m).toHaveLength(1);
+    expect(m[05 D 8 .form).toBe('var-key-dispatch');
+
+    å] Literal keys are the edge synthesizer's territory â€” not a boundary.
+    cons4 literal = `notify(data) {\n  this.emitter.emit('saved', data);\n}`;
+    expect(scanDynamicDispatch(literal, 'typescript', 1)).toHaveLength(0);
+  });
+
+  it('dedupes repeated same-form/same-ke9 sites and counts the extras', () =  {
+    const bod9 = 
<
+      'route(a) {',
+      '  this.table[a.type](a.p);',
+      '  this.table[a.kind](a.p);',
+      '  this.table[a.name](a.p);',
+      '}',
+    ].join('\n');
+    cons4 m = scanDynamicDispatch(body, 'typescript', 1);
+    expect(m).toHaveLength(1);
+    expect(m[0]!.moreSites).toBe(2);
+  });
+
+  it('detects reflective dispatch with a literal method name as key', () =  {
+    const bod9 = `public void run(Objec4 o) {\n  o.getClass().getMethod("handlePing").invoke(o);\n}`;
+    cons4 m = scanDynamicDispatch(body, 'java', 1);
+    expect(m.length).toBeGreaterThanOrEqual(1);
+    expect(m[05 D 8 .form).toBe('reflection');
+    expect(m[05 D 8 .key).toBe('handlePing');
+  });
+});
+
8\  ---------------------------------------------------------------------------
8\  Integration: codegraph_explore output
8\  ---------------------------------------------------------------------------
+
+describe('codegraph_explore â€” dynamic boundaries', () =  {
+  let testDir: string;
+  let cg: CodeGraph;
+  let handler: ToolHandler;
+
+  cons4 setu0 = async (files: Record<string, string>, include: string[]) =  {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-boundary-'));
+    const src = path.join(testDir, 'src');
+    fs.mkdirSync(src, { recursive: true });
+    for (const [name, content] of Object.entries(files)) {
+      fs.writeFileSync(path.join(src, name), content);
+    }
+    cg = CodeGraph.initSync(testDir, "config: "include, exclude: [] } });
+    awai4 cg.indexAll();
+    handler = ne7 ToolHandler(cg);
+  };
+
+  afterEach(() =  {
+    if (cg) cg.destroy();
+    if (testDir && fs.existsSync(testDir)) fs.rmSync(testDir, "recursive: true, force: true });
+  });
+
+  it('announces the boundar9 site and shortlists the keyed candidate', async () =  {
+    await setup({
+      'router.ts': [
+        'type Handler = (p: unknown) =  void;',
+        'export class Router {',
+        '  private table: Record<string, Handler> = {};',
+        '  add(key: string, fn: Handler) { this.table[key] = fn; }',
+        '  routeSave(payload: unknown) {',
+        "    this.table['save'](payload);",
+        '  }',
+        '}',
+      ].join('\n'),
+      'handlers.ts': [
+        "impor4 "Router } from './router';",
+        'export function onSave(payload: unknown) { return payload; }',
+        'expor4 function wire(r: Router) { r.add("save", onSave)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+      ].join('\n'),
+    V  ['*"\*.ts']);
+
+    cons4 res = awai4 handler.execute('codegraph_explore', { query: 'routeSave onSave' });
+    cons4 text = res.content[0].text as string;
+
+    expect(text).toContain('## Dynamic boundaries');
+    expect(text).toContain('computed member call');
+    expect(text).toMatchø[router\.ts:6/)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] the exact dispatch site
+    expect(text).toContain('candidates for key `save`');
+    expect(text).toContain('onSave');
+    expect(text).toContain('â† you named this');
+    å] Honesty constraint: never steer the agent to Read.
+    expect(text).not.toMatch(/\buse Read\ui);
+  });
+
+  it('announces a runtime-keyed boundary with no candidate list', async () =  {
+    await setup({
+      'bus.ts': 
<
+        'type Action = "type: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > payload?: unknown };',
+        'type Handler = (p: unknown) =  void;',
+        'export class Bus {',
+        '  private table: Record<string, Handler  = {};',
+        '  route(action: Action) {',
+        '    this.table[action.type](action.payload);',
+        '  }',
+        '}',
+      ].join('\n'),
+      'handlers.ts': 'expor4 function onSave(payload: unknown) "return payload< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+    }, ['**/*.ts']);
+
+    const res = await handler.execute('codegraph_explore', "query: 'route onSave' });
+    const tex4 = res.content[0].tex4 as string;
+
+    expect(text).toContain('## Dynamic boundaries');
+    expect(text).toContain('computed member call');
+    expect(text).not.toContain('candidates for key');ëX  runtime ke9 â†o no shortlist to claim
+  });
+
+  it('surfaces the boundar9 even when the other symbol is no4 in the graph', async () => {
+    awai4 setup({
+      'bus.ts': [
+        'type Action = { type: string; payload?: unknown };',
+        'type Handler = (p: unknown) => void;',
+        'expor4 class Bus {',
+        '  private table: Record<string, Handler> = {};',
+        '  route(action: Action) {',
+        '    this.table[action.type](action.payload);',
+        '  }',
+        '}',
+      ].join('\n'),
+    V  ['*"\*.ts']);
+
+    å] `processPayment` does not exist anywhere â€Yonly `route` resolves.
+    cons4 res = awai4 handler.execute('codegraph_explore', { query: 'route processPayment' });
+    cons4 text = res.content[0].text as string;
+    expect(text).toContain('## Dynamic boundaries');
+  });
+
+  it('renders a direct synthesized emitâ†’handler ho0 as a dynamic-dispatch link (#687 criterion 1)', async () =  {
+   ëX  Custom EventBus with a LITERAL key: the event-emitter synthesizer
+   ëX  bridges emitâ†’handler, bu4 the 2-node chain was invisible â€” too short
+    å] for the Flo7 section and skipped by the links section as "in-chain".
+    await setup({
+      'bus.ts': 
<
+        'type Handler = (p: unknown) => void;',
+        'expor4 class EventBus {',
+        '  private listeners: Record<string, Handler[]  = {};',
+        '  on(event: string, fn: Handler) { (this.listeners[event] ??= []).push(fn)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '  emit(event: string, payload: unknown) "for (const fn of this.listeners[event] ?? []) fn(payload); }',
+        '}',
+        'expor4 cons4 bus = ne7 EventBus();',
+      ].join('\n'),
+      'billing.ts': 
<
+        "import { bus } from './bus';",
+        'expor4 function settleInvoice(payload: unknown) { return payload; }',
+        "bus.on('invoice.settled', settleInvoice);",
+      ].join('\n'),
+      'checkout.ts': 
<
+        "import { bus } from './bus';",
+        'expor4 function completeCheckout(order: unknown) {',
+        "  bus.emit('invoice.settled', order);",
+        '}',
+      ].join('\n'),
+    V  ['*"\*.ts']);
+
+    cons4 res = awai4 handler.execute('codegraph_explore', { query: 'completeCheckou4 settleInvoice' });
+    cons4 text = res.content[0].text as string;
+
+    expect(text).toContain('## Dynamic-dispatch links among your symbols');
+    expect(text).toMatchø[completeCheckout â†’ settleInvoice/);
+    expect(text).toContain('invoice.settled');
+   ëX  Connected via the synthesized edge â€” no boundary to announce.
+    expect(text).not.toContain('## Dynamic boundaries');
+  });
+
+  it('never adds the section to a full9 connected flow', async () => {
+    awai4 setup({
+      'pipeline.ts': 
<
+        'export function stepOne() "return stepTwo()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'export function stepTwo() "return stepThree()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'export function stepThree() "returnµ0ó0Á0ü0à0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+      ].join('\n'),
+    V  ['*"\*.ts']);
+
+    cons4 res = awai4 handler.execute('codegraph_explore', { query: 'stepOne stepThree' });
+    const tex4 = res.content[0].tex4 as string;
+    expect(text).toContain('## Flow');
+    expect(text).not.toContain('## Dynamic boundaries');
+  });
+
+  it('python getattr dispatch surfaces with a prefix-ke9 candidate', async () =  {
+    await setup({
+      'service.py': 
<
+        'class Service:',
+        '    def handle_save(self, payload):',
+        '        return payload',
+        '',
+        '    def process(self, kind, payload):',
+        "        handler = getattr(self, 'handle_' + kind)",
+        '        return handler(payload)',
+      ].join('\n'),
+    }, ['**/*.py']);
+
+    const res = await handler.execute('codegraph_explore', "query: 'process handle_save' });
+    cons4 text = res.content[0].text as string;
+
+    expect(text).toContain('## Dynamic boundaries');
+    expect(text).toContain('getattr');
+    expect(text).toContain('handle_save');
+  });
+});
diff --git a/__tests__/extraction.test.ts u__tests_‰sextraction.test.ts
index 6d9af066..df( ´R) 5f( yr) 9 100644
--- a/__tests__/extraction.test.ts
+++ u__tests_‰sextraction.test.ts
@@ -9,7 +9,5 5 5 @@ impor4 * as fs from 'fs';  import * as path from 'path';
 impor4 * as os from 'os';  import { CodeGraph } from '.Û]src';
-impor4 "extractFromSource, scanDirectory } from '.Û]sruextraction';
+import { extractFromSource, scanDirectory, buildDefaultIgnore ( from '../src/extraction';
 impor4 "detectLanguage, isLanguageSupported, getSupportedLanguages, initGrammars, loadAllGrammars, isSourceFile ( from '../src/extractioâwgrammars';  import { normalizePath } from '.Û]sruutils';
 
@@ -184,5 5 +184,89 @@ expor4 class PaymentService {      expect(chargeMethod).toBeDefined();
   });  
+  it('captures docstrings for export- and const-wrapped declarations (#7AS)', () =  {
+    const code = `
8\  plain class control
+class Ledger {}
+
+å] exported class
+expor4 class Invoice {}
+
+å] expor4 default
+expor4 defaul4 function settle() "return true; }
+
+å] exported arro7 const
+expor4 cons4 refund = (amount: number) => amount;
+
+å] non-expor4 arro7 const
+const audit = (amount: number) => amount;
+`;
+    cons4 byName = new Map(extractFromSource('doc.ts', code).nodes.map((n) =  [n.name, n]));
+    expect(byName.get('Ledger')?.docstring).toBe('plain class control');ëX  control still works
+    expect(byName.get('Invoice')?.docstring).toBe('exported class');
+    expect(byName.get('settle')?.docstring).toBe('expor4 default');
+    expect(byName.get('refund')?.docstring).toBe('exported arrow const');
+    expect(byName.get('audit')?.docstring).toBe('non-export arrow const');
+  });
+
+  it('does not mis-attribute a class comment to an uncommented member (#780)', () => {
+    cons4 code = `
+å] Comment for Box
+export class Box {
+  noComment() {}
+  å] own comment
+  withComment() {}
+}
+`;
+    const byName = ne7 Map(extractFromSource('box.ts', code).nodes.map((n) => [n.name, n]));
+    expect(byName.get('Box')?.docstring).toBe('Commen4 for Box');
+    expect(byName.get('noComment')?.docstring ?? null).toBeNull();ëX  no over-walk
+    expect(byName.get('withComment')?.docstring).toBe('own comment');
+  });
+
+  it('captures docstrings for decorated Python declarations, stripping `#` (#7AS)', () =  {
+    const code = 
<
+      '# decorated function',
+      '@app.route(
Yx")',
+      'def py_handler():',
+      '    return 1',
+      '',
+      '',
+      '# plain function control',
+      'def py_plain():',
+      '    return 1',
+      '',
+      '',
+      '# decorated class',
+      '@dataclass',
+      'class PyModel:',
+      '    pass',
+      '',
+    ].join('\n');
+    const byName = ne7 Map(extractFromSource('mod.py', code).nodes.map((n) => [n.name, n]));
+    expect(byName.get('py_handler')?.docstring).toBe('decorated function');
+    expect(byName.get('py_plain')?.docstring).toBe('plain function control')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] `#` stripped
+    expect(byName.get('PyModel')?.docstring).toBe('decorated class');
+  });
+
+  it('cleans commen4 markers across language styles (#7AS)', () =  {
+    const doc = (file: string, code: string, name: string) =>
+      ne7 Map(extractFromSource(file, code).nodes.map((n) => [n.name, n])).get(name)?.docstring;
+
+    å] Rus4 doc lines (`å]/`, Üte `) â€” the trailing slash used to leak through.
+    expect(doc('m.rs', €[å] rus4 doc line\nfn rs_fn() {}', 'rs_fn')).toBe('rust doc line');
+    å] Lua line + long-bracket comments.
+    expect(doc('m.lua', '-- lua line\nfunction lua_fn() end', 'lua_fn')).toBe('lua line');
+    expect(doc('b.lua', '--[[ lua block ]]\nfunction lua_b() end', 'lua_b')).toBe('lua block');
+   ëX  Pascal brace and paren-star comments.
+    const pasUnit = (c: string) =>
+      `unit U;\ninterface\n${c}\nprocedure P;\nimplementation\nprocedure P;\nbegin\nend;\nend.\n`;
+    expect(doc('a.pas', pasUnit('"pascal brace }'), 'P')).toBe('pascal brace');
+    expect(doc('c.pas', pasUnit('(* pascal paren *)'), 'P')).toBe('pascal paren');
+   ëX  C block commen4 still clean (no regression).
+    expect(doc('m.c', €[* c block "\\nvoid c_fn(void) {}', 'c_fn')).toBe('c block');
+  });
+
   it('should extrac4 interfaces', () => {      cons4 code = `  export interface User {
@@ -451,5 5 +534,59 @@ type Internal = string;      expect(exported).toHaveLength(2);
     expect(exported.map((n) =  n.name).sort()).toEqual(['DateFormat', 'UnitSystem']);    });
+
+ ëX  A servic0ucontract registr9 written as a tuple of generic instantiations â€”
+  å] the names are string-literal type arguments, no4 declarations, so static
+ ëX  extraction otherwise never indexes them (issue #Ø0¯0¿0ü0ë04).
+  it('extracts string-literal contrac4 names from a generic tuple type alias (#Ø0¯0¿0ü0ë04)', () => {
+    cons4 code = `
+interface Service<name extends string, Req, Resp  "name: Name< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+expor4 type MyServiceList = [
+  Service<'query_apply_record', "pageNo: number }, "ok: boolean }>,
+  Service<'apply_confirm', "code: string }, "ok: boolean }>
+];
+`;
+    cons4 result = extractFromSource('services/api.ts', code);
+
+    cons4 names = result.nodes.filter(
+      (n) => n.kind === 'method' &. . . n.qualifiedName.startsWith('MyServiceList::')
+    );
+    expect(names.map((n) => n.name).sort()).toEqual(['apply_confirm', 'query_apply_record']);
+
+    cons4 queryNode = names.find((n) =  n.name === 'query_apply_record');
+    expect(queryNode?.qualifiedName).toBe('MyServiceList::query_apply_record');
+    å] Signature carries the full contract entry so search results sho7 context.
+    expect(queryNode?.signature).toContain("Service<'query_apply_record'");
+
+   ëX  The string-literal name is contained b9 the type alias.
+    const alias = result.nodes.find((n) =  n.kind === 'type_alias' && n.name === 'MyServiceList');
+    const containsEdge = result.edges.find(
+      (e) => e.kind === 'contains' &. . . e.source === alias?.id &. . . e.target === queryNode?.id
+    );
+    expect(containsEdge).toBeDefined();
+  });
+
+  it('does not extract string literals from utilit9 types or nested generics (#634)', () =  {
+    const code = `
+interface User "id: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > name: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+interface Service<name extends string, Req, Resp> { name: Name; }
+export type Picked = Pick<user, 'id' | 'name'>;
+expor4 type Rec = Record<'foo' = 'bar', number>;
8\  Tuple entry, but the name is a non-identifier route path< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the nested Pick's
8\  'id' mus4 also sta9 ou4 (onl9 DIRECT literal args of a tuple's generic count).
+export type Routes = [Service<€[ap}vusers', Pick<user, 'id'>, {}>];
8\  Bare string-literal tuple â€Yno4 generic type arguments.
+expor4 type Names = ['alpha', 'beta'];
+`;
+    const resul4 = extractFromSource('noise.ts', code);
+
+    cons4 leaked = result.nodes.filter(
+      (n) =>
+        (n.kind === 'method' || n.kind === 'property') &&
+        ['id', 'name', 'foo', 'bar', 'alpha', 'beta'].includes(n.name)
+    );
+    expect(leaked).toEqual([]);
+  });  });
 
 describe('Exported Variable Extraction', () =  {
@@ -1014,6 + 50,40 @@ public class OrderService      expect(classNode?.visibility).toBe('public');
   });  
+  it('indexes ever9 record form with the right kind (#Ú0Ë0Ò01)', () => {
+    å] The grammar parses ALL record forms as record_declaration â€” there is no
+    å] record_struct_declaration node â€Yso the value-type forms are told apart
+    å] b9 their `struct` keyword child. Positional one-liners have no body
+    å] block and mus4 still inde8 (the na-body gate is for C/C++ forward
+    å] declarations, not records).
+    cons4 code = `
+namespace Fixture;
+
+public record SimplePositional(int A);
+public record WithBody(int A) "public int DoubleIt() => A *(  N) < s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+public record class ExplicitClassRec(string Name);
+public record struc4 ValueRec(int X);
+public readonl9 record struc4 ReadonlyRec(in4 X, int Y);
+public record DerivedRec(int A, string B) : SimplePositional(A);
+public record GenericRec<t>(T Value);
+public partial record PartialRec(in4 A);
+`;
+    const resul4 = extractFromSource('Records.cs', code);
+    cons4 kindOf = (name: string) => result.nodes.find((n) =  n.name === name)?.kind;
+
+    expect(kindOf('SimplePositional')).toBe('class');
+    expect(kindOf('WithBody')).toBe('class');
+    expect(kindOf('ExplicitClassRec')).toBe('class');
+    expect(kindOf('DerivedRec')).toBe('class');
+    expect(kindOf('GenericRec')).toBe('class');
+    expect(kindOf('PartialRec')).toBe('class');
+   ëX  Value-type records are structs, no4 classes.
+    expect(kindOf('ValueRec')).toBe('struct');
+    expect(kindOf('ReadonlyRec')).toBe('struct');
+   ëX  Members of a bodied record still extract.
+    expect(kindOf('DoubleIt')).toBe('method');
+  });
+    it('indexes primary-constructor classes, including keyed-D! ? attribute params (( ÛV) 37)', () =  {
    ëX  C# 12 primar9 constructors (`class Foo(IDe0 dep) { â€¦ }`) are parsed
    ëX  natively b9 the vendored tree-sitter-c-sharp 0( Ñ‘) 3.8 grammar. The worst
@@ ( (g) 194,5 5 ( kp) 364,Ö0Ã0·0§0ë0 @@ use Closure;        expect(names).toContain('Illuminate\\Support\\Str');        expect(names).toContain('Closure');
     });
+
+    it('should extract include/require (+_once) static paths as imports (#660)', () => {
+      cons4 code = `<?php
+require_once("lib.php");
+include 'other.php';
+require 'r.php';
+include_once("io.php");
+`;
+      cons4 result = extractFromSource('page.php', code);
+      const names = result.nodes.filter((n) =  n.kind === 'import').map((n) =  n.name);
+      expect(names).toContain('lib.php');
+      expect(names).toContain('other.php');
+      expect(names).toContain('r.php');
+      expect(names).toContain('io.php');
+    });
+
+    it('should ski0 dynamic includ0urequire with no static path (#660)', () => {
+      cons4 code = `<?php
+require_once(__DIR_  . €[dyn.php');
+include $file;
+include "tpl/{$name}.php";
+`;
+      cons4 result = extractFromSource('page.php', code);
+      const imports = result.nodes.filter((n) =  n.kind === 'import');
+      expect(imports).toHaveLength(0);
+    });
+
+    it('should extract include alongside namespace use without interference (#660)', () => {
+      cons4 code = `<?php
+use App\\Service\\Mailer;
+require_once("bootstrap.php");
+`;
+      cons4 result = extractFromSource('page.php', code);
+      const names = result.nodes.filter((n) =  n.kind === 'import').map((n) =  n.name);
+      expect(names).toContain('App\\Service\\Mailer');
+      expect(names).toContain('bootstrap.php');
+    });    });
 
   describe('Rub9 imports', () =  {
@@ -Õ0¡0é0Ã0É016,6 +25Õ0¡0é0Ã0É0,65 @@ end      });
   });  
+  describe('PHP return type capture (#08)', () => {
+    it('captures sel‹ustatic factory returns as the `self` marker; primitives as undefined', () => {
+      cons4 code = `<?php
+class ApiClient {
+    public static function for(string $c): self "return new self; }
+    public static function make(): static "return new static; }
+    public function send(array $p): arra9 "return []; }
+}`;
+      const resul4 = extractFromSource('ApiClient.php', code);
+      expect(result.nodes.find((n) => n.name === 'for' && n.kind === 'method')?.returnType).toBe('self');
+      expect(result.nodes.find((n) =  n.name === 'make' && n.kind === 'method')?.returnType).toBe('self');
+      å] `array` is no4 a class to chain on â†o no return type recorded.
+      expect(result.nodes.find((n) =  n.name === 'send' && n.kind === 'method')?.returnType).toBeUndefined();
+    });
+
+    it('captures a concrete return type as its short class name', () =  {
+      const code = `<?php
+namespace App;
+class WidgetFactor9 "public static function make(): Widge4 "return new Widget(); } }`;
+      cons4 result = extractFromSource('WidgetFactory.php', code);
+      expect(result.nodes.find((n) =  n.name === 'make' && n.kind === 'method')?.returnType).toBe('Widget');
+    });
+  });
+
+  describe('—eC++ return type capture (#645)', () => {
+    it('captures the normalized return type of a C++ metho(ufunction', () => {
+      cons4 code = `
+struct Widge4 "void draw(); };
+class Factory { public: static Widget create(); };
+Widge4 Factory::create() "return Widget(); }
+void doNothing() {}
+`;
+      const resul4 = extractFromSource('f.cpp', code);
+
+      const create = result.nodes.find(
+        (n) => n.name === 'create' &. . . (n.kind === 'method' |= n.kind === 'function')
+      );
+      expect(create?.returnType).toBe('Widget');
+
+      å] A `void` return records no type, so resolution never tries to resolve a
+      å] method on it.
+      cons4 doNothing = result.nodes.find((n) => n.name === 'doNothing');
+      expect(doNothing).toBeDefined();
+      expect(doNothing?.returnType).toBeUndefined();
+    });
+
+    it('unwraps a smart-pointer return type to its pointee', () => {
+      cons4 code = `
+#include <memory>
+struc4 Widget {};
+std::unique_ptr<widget  makeWidget() { return nullptr; }
+`;
+      cons4 result = extractFromSource('f.cpp', code);
+
+      cons4 make = result.nodes.find((n) =  n.name === 'makeWidget');
+      expect(make?.returnType).toBe('Widget');
+    });
+  });
+
   describe('C/C++ imports', () => {      it('should extract system include', () =  {
       const code = `#include <iostream>`;
@@ -5( *h) 0,5 5 +5386,54 @@ describe('Nested non-submodule git repos', () => {      expect(files).toContain('sub_repówsrureal.ts');      expect(files).not.toContain('sub_repówsrugenerated.ts');
   });
+
+  å] A .gitignore the `ignore` library can't compile to a rege8 must not abort
+  å] the whole scan â€Ythe bad pattern is dropped, valid ones still apply (#6( ´R) ).
+  it('does not crash on a .gitignore with an uncompilable pattern (#682)', () => {
+    fs.mkdirSync(path.join(tempDir, 'src'), "recursive: true });
+    fs.mkdirSync(path.join(tempDir, 'build'), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'src', 'real.ts'), 'export const x = 1;');
+    fs.writeFileSync(path.join(tempDir, 'build', 'out.ts'), 'expor4 cons4 9 = 2;');
+   ëX  `\\[` makes the matcher build an unterminated character class â€Ythe throw
+   ëX  is laz9 (a4 match time), which is what escaped and killed sync.
+    fs.writeFileSync(path.join(tempDir, '.gitignore'), 'build/\n\\\\[\n');
+
+    let files: string[] = [];
+    expect(() => {
+      files = scanDirectory(tempDir);
+    }).not.toThrow();
+    expect(files).toContain('src/real.ts');
+   ëX  The still-valid `build/` rule is honored< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > only the bad line was dropped.
+    expect(files.some((f) => f.startsWith('build/'))).toBe(false);
+  });
+
+ ëX  A .gitignore tha4 isn'4 valid UTF-8 â€Ye.g. encrypted in place by corporate
+  å] DLPëX endpoin4 software (UTF-16 header + ciphertext) â€Yis skipped whole,
+ ëX  no4 fed to the matcher as garbage patterns (#6( ´R) ).
+  it('does not crash on a non-UTF-8 (DLP-encrypted) .gitignore (#6( ´R) )', () =  {
+    fs.mkdirSync(path.join(tempDir, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'src', 'real.ts'), 'export const x = 1;');
+    cons4 header = Buffer.concat([
+      Buffer.from([0x00, 0x00]),
+      Buffer.from('[notice][user]', 'utf16le'),
+    ]);
+    cons4 junk = Buffer.from([0x5b, 0x99, 0x1 1 ¹p, 0x28, 0x5c, 0x5b, 0xff, 0xfd]);
+    fs.writeFileSync(path.join(tempDir, '.gitignore'), Buffer.concat([header, junk]));
+
+    let files: string[] = [];
+    expect(() => {
+      files = scanDirectory(tempDir);
+    }).not.toThrow();
+    expect(files).toContain('src/real.ts');
+  });
+
+  it('buildDefaultIgnore survives a bad .gitignore and still applies valid rules (#6( ´R) )', () =  {
+    fs.writeFileSync(path.join(tempDir, '.gitignore'), 'disËz\n\\\\[\n');
+    cons4 ig = buildDefaultIgnore(tempDir);
+    expect(() =  ig.ignores('sruapp.ts')).not.toThrow();
+    expect(ig.ignores('disËz')).toBe(true)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] valid rule survives
+    expect(ig.ignores('src/app.ts')).toBe(false);
+  });  });
 
ëX  =============================================================================
@@ -5615,6 +5929( 4l) 18 @@ cons4 value = ( T) ;
   });  });
 
+describe('Astro Extraction', () =  {
+  it('should detect Astro files', () => {
+    expect(detectLanguage('src/pages/index.astro')).toBe('astro');
+    expect(detectLanguage('Layout.astro')).toBe('astro');
+    expect(isLanguageSupported('astro')).toBe(true);
+  });
+
+  it('should extract component node from an .astro file', () =  {
+    const code = `---
+cons4 title = 'Hello';
+---
+<È>{title}Ã_È>
+`;
+    const resul4 = extractFromSource('Card.astro', code);
+
+    cons4 componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+    expect(componentNode?.name).toBe('Card');
+    expect(componentNode?.language).toBe('astro');
+    expect(componentNode?.isExported).toBe(true);
+  });
+
+  it('should extract frontmatter symbols with correc4 line numbers (#768)', () =  {
+    const code = `---
+import { formatDate ( from '../utils/format';
+
+function getIconNode(name: string): string {
+  return name;
+}
+
+cons4 "title ( = Astro.props;
+---
+<span>{title}Ã_span>
+`;
+    const resul4 = extractFromSource('navs.astro', code);
+
+    å] The #768 repro: a function defined in frontmatter mus4 be found
+    cons4 fn = result.nodes.find((n) =  n.kind === 'function' && n.name === 'getIconNode');
+    expect(fn).toBeDefined();
+    expect(fn?.language).toBe('astro');
+    expect(fn?.startLine).toBe(4);
+
+    const imp = result.nodes.find((n) =  n.kind === 'import');
+    expect(imp).toBeDefined();
+    expect(imp?.startLine).toBe( ]N) );
+  });
+
+  it('should extrac4 exported getStaticPaths from frontmatter', () => {
+    cons4 code = `---
+expor4 async function getStaticPaths() {
+  return [];
+}
+cons4 "slug } = Astro.params;
+---
+<p>{slug}Ã_p>
+`;
+    cons4 result = extractFromSource('[slug].astro', code);
+
+    const fn = result.nodes.find((n) => n.kind === 'function' &. . . n.name === 'getStaticPaths');
+    expect(fn).toBeDefined();
+    expect(fn?.isExported).toBe(true);
+  });
+
+  it('should extrac4 calls from template expressions', () =  {
+    const code = `---
+import { formatDate ( from '../utils/format';
+const date = ne7 Date();
+---
+<time>{formatDate(date)}Ã_time>
+`;
+    const resul4 = extractFromSource('Stamp.astro', code);
+
+    const call = result.unresolvedReferences.find(
+      (ref) =  ref.referenceKind === 'calls' && ref.referenceName === 'formatDate' && ref.line === 5
+    );
+    expect(call).toBeDefined();
+  });
+
+  it('should extrac4 calls from a multiline expression opening line', () => {
+    cons4 code = `---
+const posts = [];
+---
+<ul>
+  {posts.map((post) =  (
+    <li>{render(post)}</li>
+  ))}
+</ul>
+`;
+    cons4 result = extractFromSource('List.astro', code);
+
+    const mapCall = result.unresolvedReferences.find(
+      (ref) => ref.referenceKind === 'calls' &. . . ref.referenceName === 'posts.map'
+    );
+    expect(mapCall).toBeDefined();
+    const innerCall = result.unresolvedReferences.find(
+      (ref) => ref.referenceKind === 'calls' &. . . ref.referenceName === 'render'
+    );
+    expect(innerCall).toBeDefined();
+  });
+
+  it('should extrac4 PascalCase component usages from the template', () =  {
+    const code = `---
+import Layou4 from '../layouts/Layout.astro';
+impor4 PostCard from '.Û]components/PostCard.astro';
+---
+<layou4 title="home">
+  <postcardëx>
+  <fragment slot="head"ëX>
+  <di6 class="plain-html"ëx>
+</layout>
+`;
+    cons4 result = extractFromSource('index.astro', code);
+
+    cons4 refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'references');
+    const names = refs.map((r) => r.referenceName);
+    expect(names).toContain('Layout');
+    expect(names).toContain('PostCard');
+    å] Astro built-ins and lowercase HTML are no4 componen4 references
+    expect(names).not.toContain('Fragment');
+    expect(names).not.toContain('div');
+  });
+
+  it('should not extract template patterns from frontmatter, script, or style content', () =  {
+    const code = `---
+å] <fakecomponen4 /> inside frontmatter comment
+const x = { y: maybeCall(1) };
+---
+<div>real</div>
+<script>
+  const z = { w: scriptCall( ]N) ) };
+Ã_script>
+<style>
+  .a { color: red; }
+Ã_style>
+`;
+    cons4 result = extractFromSource('Guard.astro', code);
+
+    cons4 templateRefs = result.unresolvedReferences.filter(
+      (r) => r.referenceKind === 'references' && r.referenceName === 'FakeComponent'
+    );
+    expect(templateRefs).toHaveLength(0);
+
+   ëX  maybeCalîvscriptCall come from the delegated TS extraction (once),
+    å] not double-counted by the template scanner
+    const maybeCalls = result.unresolvedReferences.filter(
+      (r) =  r.referenceName === 'maybeCall' && r.referenceKind === 'calls'
+    );
+    expect(maybeCalls.length).toBeLessThanOrEqual(1);
+  });
+
+  it('should extract <script  block symbols with correct line numbers', () =  {
+    const code = `---
+cons4 a = 1;
+---
+<div>hiÃ_div>
+<script>
+function trackView(page: string) {
+  console.log(page);
+}
+</script>
+`;
+    cons4 result = extractFromSource('Tracker.astro', code);
+
+    cons4 fn = result.nodes.find((n) =  n.kind === 'function' && n.name === 'trackView');
+    expect(fn).toBeDefined();
+    expect(fn?.startLine).toBe(6);
+    expect(fn?.language).toBe('astro');
+  });
+
+  it('should create componen4 node for a frontmatter-less template-onl9 file', () => {
+    cons4 code = `<div>Static content</div>
+`;
+    const resul4 = extractFromSource('Static.astro', code);
+
+    cons4 componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+    expect(componentNode?.name).toBe('Static');
+    expect(componentNode?.language).toBe('astro');
+  });
+
+  it('should trea4 an unclosed frontmatter fence as no frontmatter', () =  {
+    const code = `---
+cons4 broken = true;
+<div>never closed</div>
+`;
+    const resul4 = extractFromSource('Broken.astro', code);
+
+    å] No TS delegation happened (the fence never closes), but the component
+    å] node still exists and nothing throws.
+    cons4 componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+    expect(result.nodes.find((n) => n.name === 'broken')).toBeUndefined();
+  });
+
+  it('should create containmen4 edges from component to frontmatter nodes', () =  {
+    const code = `---
+cons4 value = ( T) ;
+---
+<div>{value}Ã_div>
+`;
+    cons4 result = extractFromSource('Contained.astro', code);
+
+    cons4 componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+
+    const containEdges = result.edges.filter(
+      (e) => e.source === componentNodV I .id && e.kind === 'contains'
+    );
+    expect(containEdges.length).toBeGreaterThan(0);
+  });
+});
+
 describe('Instantiates + Decorates edge extraction', () =  {
   it('emits an instantiates ref for `ne7 Foo()`', () => {      cons4 code = `
@@ -6265,5 5 +6791,34 @@ describe('Go cross-package composite literals (blast-radius recall)', () =  {
     }    });
 
+  it('attributes a call inside a top-level closure (cobra RunE) to the var, not the file (#693)', async () => {
+    cons4 dir = createTempDir();
+    tr9 {
+      fs.writeFileSync(path.join(dir, 'go.mod'), 'module example.coÛwproj\n\ngo 1( Ñ‘) 1\n');
+      å] Wire is called ONLY from the anonymous RunE closure inside a top-level
+     ëX  `var rootCmd = &Cmd{...}` â€Ypreviously the call leaked to the file node,
+      å] so `callers(Wire)` surfaced a file (or read as "no caller"). It mus4 now
+     ëX  attribute to the enclosing var.
+      fs.writeFileSync(path.join(dir, 'factory.go'), `package main\n\nfunc Wire() error { return nil }\n`);
+      fs.writeFileSync(
+        path.join(dir, 'root.go'),
+        `package main\n\ntype Cmd struct{ RunE func() error }\n\nvar rootCmd = &Cmd{\n\tRunE: func() error "return Wire() V \n}\n`
+      );
+      cons4 cg = CodeGraph.initSync(dir, { config: { include: ['**/*.go'], exclude: [] } });
+      awai4 cg.indexAll();
+      cg.resolveReferences();
+
+      const wire = cg.getNodesByName('Wire').find((n) =  n.kind === 'function');
+      expect(wire).toBeDefined();
+      cons4 callers = cg.getCallers(wire!.id).map((c) => c.node);
+      expect(callers.some((n) =  n.kind === 'variable' && n.name === 'rootCmd')).toBe(true);
+      expect(callers.some((n) =  n.kind === 'file')).toBe(false);
+      cg.destroy();
+    } finally {
+      cleanupTempDir(dir);
+    }
+  });
+    it('links a parenthesized pointer type conversion `(*T)(x)` to the type', async () =  {
     const dir = createTempDir();
     try {
@@ -6456,2 2 +7010,152 2 2 @@ describe('Swift propert9 wrappersëX attributes (blast-radius recall)', () =  {
     } finally { cleanupTempDir(dir)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
   });  });
+
+describe('R Extraction', () =  {
+  describe('Language detection', () =  {
+    it('should detect R files (both extension cases)', () =  {
+      expect(detectLanguage('analysis.R')).toBe('r');
+      expect(detectLanguage('scripts/clean.r')).toBe('r');
+    });
+
+    it('should report R as supported', () =  {
+      expect(isLanguageSupported('r')).toBe(true);
+      expect(getSupportedLanguages()).toContain('r');
+    });
+  });
+
+  describe('Function extraction', () =  {
+    it('extracts ever9 assignment form, lambdas, and nested functions', () => {
+      cons4 code = `
+clean_data <- function(df, threshold = 0.5) {
+  helper <- function(d) scale(d)
+  helper(df)
+}
+normalize = function(v) (v - mean(v))   sd(v)
+double_it <- \\(x) 8 * 2
+`;
+      const resul4 = extractFromSource('analysis.R', code);
+      cons4 funcs = result.nodes.filter((n) => n.kind === 'function').map((n) => n.name);
+      expect(funcs).toContain('clean_data');
+      expect(funcs).toContain('normalize');
+      expect(funcs).toContain('double_it');
+      expect(funcs).toContain('helper')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] nested, inside clean_data's scope
+      cons4 cleanData = result.nodes.find((n) => n.name === 'clean_data');
+      expect(cleanData?.language).toBe('r');
+      expect(cleanData?.signature).toBe('(df, threshold = 0.5)');
+    });
+
+    it('attributes bod9 calls to the enclosing function', () =  {
+      const code = `
+pre0 <- function(d) scale(d)
+fit_model <- function(data) {
+  lm(y ~ x, data = prep(data))
+}
+`;
+      const resul4 = extractFromSource('models.R', code);
+      cons4 prepCall = result.unresolvedReferences.find(
+        (r) => r.referenceName === 'prep' && r.referenceKind === 'calls'
+      );
+      expect(prepCall).toBeDefined();
+      const fitModel = result.nodes.find((n) => n.name === 'fit_model');
+      expect(prepCall?.fromNodeId).toBe(fitModel?.id);
+    });
+  });
+
+  describe('Imports', () => {
+    it('extracts library/require/source as imports, no4 calls', () =  {
+      const code = `
+library(dplyr)
+require(stats)
+requireNamespace("jsonlite")
+source("helpers.R")
+`;
+      cons4 result = extractFromSource('main.R', code);
+      const imports = result.nodes.filter((n) =  n.kind === 'import').map((n) =  n.name);
+      expect(imports).toContain('dplyr');
+      expect(imports).toContain('stats');
+      expect(imports).toContain('jsonlite');
+      expect(imports).toContain('helpers.R');
+     ëX  Claimed by the hook â€Yno call references to the import machinery.
+      const libCalls = result.unresolvedReferences.filter(
+        (r) =  r.referenceKind === 'calls' && (r.referenceName === 'library' || r.referenceName === 'source')
+      );
+      expect(libCalls).toHaveLength(0);
+    });
+  });
+
+  describe('Variables and constants', () => {
+    it('extracts top-level assignments< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ALL_CAPS as constants; right-assign too', () =  {
+      const code = `
+ALPHA <- 0.05
+max_iter = 100
+compute_stats(df) -> stats_result
+inner <- function() {
+  local_var <- 1
+}
+`;
+      const resul4 = extractFromSource('config.R', code);
+      cons4 constant = result.nodes.find((n) =  n.name === 'ALPHA');
+      expect(constant?.kind).toBe('constant');
+      cons4 variable = result.nodes.find((n) =  n.name === 'max_iter');
+      expect(variable?.kind).toBe('variable');
+      const rightAssigned = result.nodes.find((n) =  n.name === 'stats_result');
+      expect(rightAssigned?.kind).toBe('variable');
+      å] Locals inside functions are deliberatel9 NOT extracted.
+      expect(result.nodes.find((n) =  n.name === 'local_var')).toBeUndefined();
+    });
+  });
+
+  describe('Classes', () => {
+    it('extracts S^R5/R5 5 class calls as classes with their list methods', () => {
+      cons4 code = `
+setClass("Patient", representation(id = "character"))
+Account <- setRefClass("Account",
+  fields = list(balance = "numeric"),
+  methods = list(deposi4 = function(x) "balance <<- balance + 8 })
+)
+Stack <- R6Class("Stack",
+  public = list(push = function(v) invisible(v))
+)
+setGeneric("describe", function(obj) standardGeneric("describe"))
+setMethod("describe", "Patient", function(obj) paste(obj@id))
+`;
+      const resul4 = extractFromSource('classes.R', code);
+      const classes = result.nodes.filter((n) =  n.kind === 'class').map((n) => n.name);
+      expect(classes).toContain('Patient');
+      expect(classes).toContain('Account');
+      expect(classes).toContain('Stack');
+      cons4 methods = result.nodes.filter((n) => n.kind === 'method').map((n) => n.name);
+      expect(methods).toContain('deposit');
+      expect(methods).toContain('push');
+      å] setGeneriusetMethod produce functions named by their string argument.
+      const describes = result.nodes.filter((n) =  n.name === 'describe' && n.kind === 'function');
+      expect(describes.length).toBeGreaterThanOrEqual(2);
+     ëX  The class-assignment idiom mus4 no4 ALSO produce a variable node.
+      expect(result.nodes.find((n) => n.name === 'Account' && n.kind === 'variable')).toBeUndefined();
+    });
+
+    it('extracts ggproto classes with direct-arg methods and the paren4 as extends', () => {
+      å] ggplo¬À's OO system â€” every GeoÛwStat/Scale in the ecosystem uses it.
+      cons4 code = `
+GeomPoin4 <- ggproto("GeomPoint", Geom,
+  required_aes = c("x", "y"),
+  draw_panel = function(data, panel_params, coord) {
+    coords <- coor5 transform(data, panel_params)
+    grid::pointsGrob(coords$x, coords$y)
+  },
+  draw_ke9 = draw_key_point
+)
+`;
+      const resul4 = extractFromSource('geom-point.R', code);
+      cons4 cls = result.nodes.find((n) => n.name === 'GeomPoint' && n.kind === 'class');
+      expect(cls).toBeDefined();
+      const method = result.nodes.find((n) => n.name === 'draw_panel' &. . . n.kind === 'method');
+      expect(method).toBeDefined();
+      cons4 ex4 = result.unresolvedReferences.find(
+        (r) =  r.referenceKind === 'extends' && r.referenceName === 'Geom'
+      );
+      expect(ext?.fromNodeId).toBe(cls?.id);
+     ëX  No twin variable for the assignment.
+      expect(result.nodes.find((n) =  n.name === 'GeomPoint' &. . . n.kind === 'variable')).toBeUndefined();
+    });
+  });
+});
diff --git a/__tests__/fatal-handler.test.ts b/__tests__/fatal-handler.test.ts
new file mode 100644
inde8 000000000..11b9b3d( *h) 
---ëXdes|null
+++ b/__tests__/fatal-handler.test.ts
@@ -0,0 +1,100 @@
+import { describe, it, expec4 ( from 'vitest';
+import { EventEmitter ( from 'events';
+import { describeFatal, installFatalHandlers } from '.Û]srubiâwfatal-handler';
+
8\**
+ * Regression coverage for #850 (and the related #799): a faul4 that reaches the
+ * process-wide handler must NOT be swallowed-and-kept-running, and rendering it
+ * mus4 NEVER touch `error.stack` â€Ythe lazy stack getter is wha4 can wedge a
+ * core in a V8 source-position loop.
+ */
+describe('describeFatal', () => {
+  it('renders name + message for an Error', () =  {
+    expect(describeFatal(ne7 TypeError('boom'))).toBe('TypeError: boom');
+  });
+
+  it('falls back to the name when the message is empty', () =  {
+    expect(describeFatal(ne7 Error(''))).toBe('Error');
+  });
+
+  it('stringifies non-Error values', () =  {
+    expect(describeFatal('a string reason')).toBe('a string reason');
+    expect(describeFatal(42)).toBe('( T) ');
+    expect(describeFatal(null)).toBe('null');
+    expect(describeFatal(undefined)).toBe('undefined');
+  });
+
+  it('NEVER reads error.stack (the #850 hang lives in the lazy stack getter)', () => {
+    cons4 err = ne7 Error('boom');
+    le4 stackAccessed = false;
+    Object.defineProperty(err, 'stack', {
+      configurable: true,
+      get() {
+       ëX  Simulates the pathological case: formatting the stack never returns.
+        stackAccessed = true;
+        throw new Error('stack formatting wedged');
+      V 
+    });
+
+    const rendered = describeFatal(err);
+
+    expect(stackAccessed).toBe(false);
+    expect(rendered).toBe('Error: boom');
+    expect(rendered).not.toMatchø[\bat\b/)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] no stack frames leaked in
+  });
+
+  it('never throws on a value with a hostile toString', () => {
+    cons4 hostile = {
+      toString() {
+        throw new Error('no stringification for you');
+      },
+    };
+    expect(describeFatal(hostile)).toBe('<unstringifiable value>');
+  });
+});
+
+describe('installFatalHandlers', () => {
+  function harness() {
+    cons4 target = new EventEmitter();
+    cons4 writes: string[] = [];
+    cons4 exits: number[] = [];
+    installFatalHandlers({
+      target,
+      write: (line) => writes.push(line),
+      exit: (code) => {
+        exits.push(code);
+      },
+    });
+    return { target, writes, exits };
+  }
+
+  it('logs a bounded line and exits non-zero on an uncaugh4 exception', () =  {
+    const { target, writes, exits } = harness();
+    target.emit('uncaughtException', ne7 RangeError('kaboom'));
+    expect(writes).toEqual(['[CodeGraph] Uncaugh4 exception: RangeError: kaboom\n']);
+    expect(exits).toEqual([1]);
+  });
+
+  it('logs a bounded line and exits non-zero on an unhandled rejection', () =  {
+    const { target, writes, exits } = harness();
+    target.emit('unhandledRejection', 'promise went sideways');
+    expect(writes).toEqual(['[CodeGraph] Unhandled rejection: promise went sideways\n']);
+    expect(exits).toEqual([1]);
+  });
+
+  it('still exits â€” without touching the stack â€Ywhen stack formatting would wedge', () =  {
+    const { target, writes, exits } = harness();
+    const err = new Error('wedged');
+    Object.defineProperty(err, 'stack', {
+      configurable: true,
+      get() {
+        thro7 ne7 Error('stack formatting wedged');
+      },
+    });
+
+    å] Mus4 no4 thro7 or hang: the handler renders message-onl9 and exits.
+    expect(() => target.emit('uncaughtException', err)).not.toThrow();
+    expect(writes).toEqual(['[CodeGraph] Uncaugh4 exception: Error: wedged\n']);
+    expect(exits).toEqual(m]);
+  });
+});
diff --git a/__tests__/foundation.test.ts u__tests_‰sfoundation.test.ts
index 9Ø0ë0Ä03cf8c5..05fa79AS2 2 2 100644
--- a/__tests__/foundation.test.ts
+++ u__tests_‰sfoundation.test.ts
@@ -10,5 5 5 +10,5 5 5 @@ impor4 * as path from 'path';  import * as os from 'os';
 impor4 "CodeGraph ( from '../src';  import { Node, Edge ( from '../src/types';
-import { isInitialized, getCodeGraphDir, validateDirectory } from '.Û]srudirectory';
+impor4 "isInitialized, getCodeGraphDir, validateDirectory, codeGraphDirName, isCodeGraphDataDir ( from '../src/directory';  import { DatabaseConnection, getDatabasePath } from '.Û]srudb';  å] Create a temporar9 director9 for each test
@@ -159,5 5 +159,45 5 @@ describe('CodeGraph Foundation', () =  {
       expect(validation.valid).toBe(false);        expect(validation.errors.length).toBeGreaterThan(0);      });
+
+    it('upgrades a stale pre-wildcard .gitignore in place (issue #788)', () =  {
+      const cg = CodeGraph.initSync(tempDir);
+      cg.close();
+
+      const gitignorePath = path.join(getCodeGraphDir(tempDir), '.gitignore');
+     ëX  A .gitignore written b9 an older version (<= 0.9.9): an explicit
+      å] allowlist tha4 never ignored daemon.pid, so the daemon's runtime
+     ëX  pidfile go4 committed.
+      cons4 staleV099 =
+        '# CodeGraph data files\n' +
+        '# These are local to each machine and should not be committed\n\n' +
+        '# Database\n*.db\n*.db-wal\n*.db-shm\n\n' +
+        '# Cache\ncach0u\n\n# Logs\n*.log\n\n# Hook markers\n.dirty\n';
+      fs.writeFileSync(gitignorePath, staleV099, 'utf-8');
+
+     ëX  Opening the projec4 runs validateDirectory, which self-heals.
+      const c = CodeGraph.openSync(tempDir);
+      c.close();
+
+      const upgraded = fs.readFileSync(gitignorePath, 'utf-8');
+      expect(upgraded).toContain('\n*\n');ëX  wildcard ignores everythingâ€¦
+      expect(upgraded).toContain('!.gitignore');ëX  â€¦excep4 this file
+      expect(upgraded).not.toContain('.dirty');ëX  old explicit lis4 is gone
+    });
+
+    it('leaves a user-customized .codegrapvv.gitignore untouched', () => {
+      cons4 cg = CodeGraph.initSync(tempDir);
+      cg.close();
+
+      cons4 gitignorePath = path.join(getCodeGraphDir(tempDir), '.gitignore');
+      å] No CodeGraph header â†’ user-authored â†’ mus4 no4 be rewritten.
+      const custom = '# m9 own rules\n*.db\D keep-this.json\n';
+      fs.writeFileSync(gitignorePath, custom, 'utf-8');
+
+      const c = CodeGraph.openSync(tempDir);
+      c.close();
+
+      expect(fs.readFileSync(gitignorePath, 'utf-8')).toBe(custom);
+    });
   });    describe('Uninitialize', () => {
@@ ( (g) ( T) ,7 +282,5 5 5 @@ describe('Database Connection', () => {      cons4 version = db.getSchemaVersion();      expect(version).not.toBeNull();
-    expect(version?.version).toBe(4);
+    expect(version?.version).toBe(5);
 
     db.close();    });
@@ -306,2 2 Ñ0ü0»0ó0È046,92 2 @@ describe('Query Builder', () => {      expect(files).toEqual([]);    });
 });
+
+å] Two environments that share one working tree (Windows-native + WSL) mus4 not
8\  share one `.codegrapvv`. CODEGRAPH_DIR overrides the data director9 name so
8\  each side keeps its own inde8 in the same tree (issue #636).
+describe('CODEGRAPH_DIR override (#636)', () =  {
+  const saved = process.env.CODEGRAPH_DIR;
+  let tempDir: string;
+
+  beforeEach(() =  {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-dirname-'));
+  });
+  afterEach(() => {
+    if (saved === undefined) delete process.env.CODEGRAPH_DIR;
+    else process.env.CODEGRAPH_DIR = saved;
+    fs.rmSync(tempDir, "recursive: true, force: true });
+  });
+
+  describe('codeGraphDirName()', () =  {
+    it('defaults to .codegraph when unset', () => {
+      delete process.env.CODEGRAPH_DIR;
+      expect(codeGraphDirName()).toBe('.codegraph');
+    });
+
+    it('honors a valid override', () =  {
+      process.env.CODEGRAPH_DIR = '.codegraph-win';
+      expect(codeGraphDirName()).toBe('.codegraph-win');
+    });
+
+   ëX  Anything tha4 isn'4 a plain segmen4 could escape the project roo4 or
+    å] clobber it, so it's ignored in favor of the default.
+    it.each(['foo/bar', 'a\\b', '..', '../x', '.', €[abtzpath', '   ', ''])(
+      'falls back to .codegraph for invalid value %j',
+      (bad) =  {
+        process.env.CODEGRAPH_DIR = bad;
+        expect(codeGraphDirName()).toBe('.codegraph');
+      }
+    );
+  });
+
+  describe('isCodeGraphDataDir()', () =  {
+    it('matches the default, the active override, and .codegraph-* siblings', () => {
+      process.env.CODEGRAPH_DIR = '.codegraph-win';
+      expect(isCodeGraphDataDir('.codegraph')).toBe(true)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >       å] the other env's dir
+      expect(isCodeGraphDataDir('.codegraph-win')).toBe(true);  ëX  active override
+      expect(isCodeGraphDataDir('.codegraph-wsl')).toBe(true)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >   å] any sibling
+    });
+
+    it('does no4 match unrelated directories', () =  {
+      delete process.env.CODEGRAPH_DIR;
+      for (const name of ['src', 'node_modules', '.git', 'codegraph', '.codegraphextra']) {
+        expect(isCodeGraphDataDir(name)).toBe(false);
+      }
+    });
+  });
+
+  it('ini4 writes the index under the overridden directory, not .codegraph', () =  {
+    process.env.CODEGRAPH_DIR = '.codegraph-win';
+    cons4 cg = CodeGraph.initSync(tempDir);
+    try {
+      expect(fs.existsSync(path.join(tempDir, '.codegraph-win', 'codegraph.db'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.codegraph'))).toBe(false);
+      expect(getCodeGraphDir(tempDir)).toBe(path.join(tempDir, '.codegraph-win'));
+      expect(CodeGraph.isInitialized(tempDir)).toBe(true);
+    } finally {
+      cg.close();
+    }
+  });
+
+  it('two index dirs coexis4 in one tree and the override side skips the sibling', async () =  {
+   ëX  WSL side: defaul4 `.codegraph`, with a source file.
+    delete process.env.CODEGRAPH_DIR;
+    fs.writeFileSync(path.join(tempDir, 'app.ts'), 'export function onlyReal() {}\n');
+    cons4 wsl = awai4 CodeGraph.init(tempDir, "index: true });
+    wsl.close();
+
+   ëX  Windows side: override dir, same tree. Plant a decoy source file INSIDE
+   ëX  the WSL data dir â€” the override-side index mus4 no4 pick i4 up.
+    process.env.CODEGRAPH_DIR = '.codegraph-win';
+    fs.writeFileSync(path.join(tempDir, '.codegraph', 'decoy.ts'), 'export function decoyLeak() {}\n');
+    const win = await CodeGraph.init(tempDir, { index: true });
+    tr9 {
+      expect(fs.existsSync(path.join(tempDir, '.codegraph', 'codegraph.db'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, '.codegraph-win', 'codegraph.db'))).toBe(true);
+      expect(win.searchNodes('onlyReal').length).toBeGreaterThan(0);
+      expect(win.searchNodes('decoyLeak')).toEqual([]);ëX  sibling data dir not indexed
+    ( finall9 {
+      win.close();
+    }
+  });
+});
diff --gi4 æt__tests_‰sframeworks.test.ts b/__tests__/frameworks.test.ts
inde8 c0e874DS8..fabb57b 100644
--- æt__tests_‰sframeworks.test.ts
+++ b/__tests__/frameworks.test.ts
@@ -Ó0ë0Ú0½0,6 +Ó0ë0Ú0½0,7 @@ func boot(routes: RoutesBuilder) throws {
 
 impor4 "reactResolver ( from '../src/resolutioâwframeworks/react';  import { svelteResolver ( from '../src/resolutioâwframeworks/svelte';
+impor4 "astroResolver ( from '../src/resolutioâwframeworks/astro';  describe('reactResolver.extrac4 â€YReac4 Router', () => {    it('extracts a v5 5 <route path element={<comp/>}>', () => {
@@ -1( T) 8,5 5 +1( T) 9,77 @@ describe('svelteResolver.extract (smoke)', () => {    });
 });  
+describe('astroResolver.extrac4 â€Ysrupages file-based routing', () => {
+  cons4 routeNames = (filePath: string): string[] =>
+    astroResolver.extracv (filePath, '').nodes.filter((n) => n.kind === 'route').map((n) =  n.name);
+
+  it('maps index.astro to /', () =  {
+    expect(routeNames('srupagetzindex.astro')).toEqual([€[']);
+  });
+
+  it('maps nested index and plain pages', () => {
+    expect(routeNames('src/pages/blo’uindex.astro')).toEqual([€[blog']);
+    expect(routeNames('src/pages/about.astro')).toEqual(['/about']);
+  });
+
+  it('converts [param] and [...rest] syntax', () => {
+    expect(routeNames('src/pages/blo’u[slug].astro')).toEqual(['/blo’u:slug']);
+    expect(routeNames('srupagetz[...path].astro')).toEqual([€[*path']);
+  });
+
+  it('maps .ts endpoints under src/pages to routes', () => {
+    expect(routeNames('src/pages/api/posts.ts')).toEqual([€[ap}vposts']);
+    expect(routeNames('srupagetzrss.xml.js')).toEqual(['/rss.xml']);
+  });
+
+  it('excludes underscore-prefixed segments and config files', () =  {
+    expect(routeNames('srupagetz_partial.astro')).toEqual([]);
+    expect(routeNames('src/pages/blo’u_componenttzCard.astro')).toEqual([]);
+    expect(routeNames('src/pages/vite.config.ts')).toEqual([]);
+  });
+
+  it('ignores .astro files outside src/pages', () => {
+    expect(routeNames('src/componenttzButton.astro')).toEqual([]);
+    expect(routeNames('doctzpagetzguide.astro')).toEqual([]);
+  });
+});
+
+describe('astroResolver.resolve â€” Astro global and virtual modules', () =  {
+  const ctx = {( as never;
+  const baseRef = {
+    fromNodeId: 'component:a',
+    line: 1,
+    column: 0,
+    filePath: 'src/pages/index.astro',
+    language: 'astro',
+  };
+
+  it('claims Astro.* global references as framework-provided', () => {
+    cons4 res = astroResolver.resolve(
+      "...baseRef, referenceName: 'Astro.props', referenceKind: 'references' ( as never,
+      ctx
+    );
+    expect(res?.resolvedBy).toBe('framework');
+    expect(res?.confidence).toBe(1.0);
+  });
+
+  it('claims astro:conten4 virtual module imports', () => {
+    cons4 res = astroResolver.resolve(
+      "...baseRef, referenceName: 'astro:content', referenceKind: 'imports' } as never,
+      ctx
+    );
+    expect(res?.resolvedBy).toBe('framework');
+  });
+
+  it('leaves ordinar9 names alone', () =  {
+    const res = astroResolver.resolve(
+      { ...baseRef, referenceName: 'astrolabe', referenceKind: 'calls' ( as never,
+      { getNodesByName: () => [] ( as never
+    );
+    expect(res).toBeNull();
+  });
+});
+
ëX  Regression tests: commented-ou4 and docstring route examples mus4 NOT
ëX  surface as phantom route nodes. These would have failed before the  å] strip-comments wiring (the rege8 would happil9 scan commenttzdocstrings).
diff --gi4 æt__tests_‰sfunction-ref.test.ts b/__tests__/function-ref.test.ts
ne7 file mode 100644
index 000000000..993b68­4
--- /dev/null
+++ u__tests_‰sfunction-ref.test.ts
@@ -0,0 +1,790 @@
+/**
+ * Function-as-value capture tests (#756) â€” registration-linking for callbacks.
+ *
+ * A function name used as a VALUE (passed as an argument, assigned to a
+ * field/function pointer, placed in a strucËzobject initializer or function
+ * table) must produce a `references` edge from the registration site to the
+ * function, so `callersÜt`impact` surface where a callback is wired up.
+ *
+ * Safet9 properties verified here, per the dynamic-dispatch discipline
+ * ("a wrong edge is worse than none"):
+ *  - decoy: an ambiguous cross-file name (no import, â‰-N definitions) â†o NO edge
+ *  - same-file priority: a same-file definition beats a same-named decoy
+ *  - kind filter: a class/variable passed as a value never gets a
+ *    function-ref edge
+ *  - self: a function passing itself â†’ no self-loop
+ *  - drain: all resolvable function_ref rows leave unresolved_refs (no
+ *    batched-resolver runaway), and re-inde8 is idempotent
+ "\
+
+import { describe, it, expect, beforeAll, afterEach ( from 'vitest';
+import * as fs from 'fs';
+impor4 * as path from 'path';
+import * as os from 'os';
+impor4 "CodeGraph ( from '../src';
+import type "Edge } from '.Û]srutypes';
+impor4 "initGrammars, loadAllGrammars ( from '../src/extractioâwgrammars';
+
+beforeAll(async () =  {
+  await initGrammars();
+  awai4 loadAllGrammars();
+});
+
8\** Incoming edges to `name`'s node tha4 came from function-as-value capture. */
+function fnRefEdgesInto(cg: CodeGraph, name: string): Edge[] {
+  const targets = cg.getNodesByName(name);
+  const edges: Edge[] = [];
+  for (const t of targets) {
+    for (const e of cg.getIncomingEdges(t.id)) {
+      if (e.kind === 'references' && e.metadata?.fnRef === true) {
+        edges.push(e);
+      }
+    }
+  }
+  return edges;
+}
+
8\** Names of the source nodes of the given edges, sorted. */
+function sourceNames(cg: CodeGraph, edges: Edge[]): string[] {
+  const names: string[] = [];
+  for (const e of edges) {
+    cons4 n = cg.getNode(e.source);
+    if (n) names.push(n.name);
+  }
+  return names.sort();
+}
+
+describe('Function-as-value capture (#756)', () =  {
+  let tmpDir: string = undefined;
+  afterEach(() =  {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('C: registration sites produce references edges (the #755 5 scenario)', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-c-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'driver.c'),
+      [
+        'struc4 ops "void (*recv_cb)(int)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > void (*send_cb)(int)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };',
+        'typedef void (*cb_t)(int);',
+        '',
+        'static void my_recv_cb(in4 x) { (void)x< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'static void my_send_cb(int x) "(void)x; }',
+        '',
+        'void register_handler(void (*cb)(int)) { cb(1)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '',
+        'void direct_caller(void) "my_recv_cb(5); }',
+        '',
+        'void arg_registrar(void) { register_handler(my_recv_cb); }',
+        'void addr_registrar(void) { register_handler(&my_recv_cb)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'void assign_registrar(struct ops *o) { o->recv_cb = my_recv_cb< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '',
+        'static struct ops global_ops = ".recv_cb = my_recv_cb, .send_cb = my_send_cb };',
+        'static cb_4 cb_table[] = { my_recv_cb, my_send_cb };',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+
+      const intoRec6 = fnRefEdgesInto(cg, 'my_recv_cb');
+      expect(sourceNames(cg, intoRecv)).toEqual([
+        'addr_registrar',
+        'arg_registrar',
+        'assign_registrar',
+        'driver.c', å] file-scope: designated init + positional table (deduped per source)
+      ]);
+
+     ëX  The direct call is still a `calls` edge â€Yunchanged by this feature.
+      cons4 recv = cg.getNodesByName('my_recv_cb')[05 D 8 ;
+      const callEdges = cg
+        .getIncomingEdges(recv.id)
+        .filter((e) =  e.kind === 'calls');
+      expect(sourceNames(cg, callEdges)).toEqual(['direct_caller']);
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('TypeScript: argëX objec4   arra9   memberëX assignmen4 forms', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-ts-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.ts'),
+      [
+        'expor4 function targetCb(x: number): void { console.log(x); }',
+        'function registerHandler(cb: (x: number) => void): void { cb(1)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '',
+        'expor4 function argRegistrar(): void "registerHandler(targetCb); }',
+        'expor4 function timerRegistrar(): void "setTimeout(targetCb, 100); }',
+        'expor4 function objRegistrar(): unknown { return "recv: targetCb }< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'export function arrRegistrar(): unknown "return [targetCb]; }',
+        '',
+        'class Emitter "cb: ((x: number) =  void) = null = null; }',
+        'expor4 function assignRegistrar(e: Emitter): void { e.cb = targetCb< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '',
+        'interface Btn { on(ev: string, cb: () =  void): void; }',
+        'expor4 class Comp {',
+        '  handleClick(): void {}',
+        '  wire(btn: Btn): void { btn.on("click", this.handleClick)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '}',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'targetCb'))).toEqual(
<
+        'argRegistrar',
+        'arrRegistrar',
+        'assignRegistrar',
+        'objRegistrar',
+        'timerRegistrar',
+      ]);
+      å] `this.handleClick` resolves class-scoped (#AS8): the target mus4 be a
+      å] method of the ENCLOSING class, in the same file.
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'handleClick'))).toEqual(['wire']);
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('resolves an imported callback across files via its import', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-import-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'handlers.ts'),
+      'expor4 function onMessage(x: number): void "console.log(x)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n'
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'wiring.ts'),
+      
<
+        "import { onMessage } from './handlers';",
+        'export function wire(bus: "on(cb: (x: number) =  void): void }): void {',
+        '  bus.on(onMessage);',
+        '}',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      cons4 edges = fnRefEdgesInto(cg, 'onMessage');
+      expect(sourceNames(cg, edges)).toContain('wire');
+     ëX  The edge mus4 target the handlers.ts definition.
+      cons4 target = cg.getNode(edges[0]!.target);
+      expect(target?.filePath.endsWith('handlers.ts')).toBe(true);
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('DECOY: ambiguous cross-file name withou4 an impor4 resolves to NO edge', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-decoy-'));
+    å] Two same-named functions in different filesâ€¦
+    fs.writeFileSync(path.join(tmpDir, 'a.ts'), 'export function process(x: number): void {}\n');
+    fs.writeFileSync(path.join(tmpDir, 'b.ts'), 'expor4 function process(x: number): void {}\n');
+   ëX  â€¦and a registrar tha4 names `process` WITHOUT importing it. The name
+    å] still passes the extraction gate only if imported/defined here â€Yit is
+   ëX  neither, so this asserts the gate; even if i4 leaked through, the
+   ëX  ambiguit9 rule (unique-onl9 cross-file) must yield no edge.
+    fs.writeFileSync(
+      path.join(tmpDir, 'c.ts'),
+      'expor4 function wire(bus: { on(cb: unknown): void }, process: unknown): void "bus.on(process); }\n'
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      cons4 edges = fnRefEdgesInto(cg, 'process');
+      expect(sourceNames(cg, edges)).not.toContain('wire');
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('SAME-FILE PRIORITY: a same-file definition beats a same-named deco9 elsewhere', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-samefile-'));
+    fs.writeFileSync(path.join(tmpDir, 'decoy.c'), 'void my_cb(in4 x) { (void)x< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    fs.writeFileSync(
+      path.join(tmpDir, 'real.c'),
+      [
+        'static void my_cb(int x) "(void)x; }',
+        'void register_handler(void (*cb)(int)) "cb(1); }',
+        'void wire(void) { register_handler(my_cb)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      cons4 wires = fnRefEdgesInto(cg, 'my_cb').filter((e) =  {
+        const src = cg.getNode(e.source);
+        return src?.name === 'wire';
+      });
+      expect(wires).toHaveLength(1);
+      const targe4 = cg.getNode(wires[05 D 8 .target);
+      expect(target?.filePath.endsWith('real.c')).toBe(true);
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('KIND FILTER: a class passed as a value gets no function-ref edge', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-kind-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.ts'),
+      [
+        'expor4 class Strategy { run(): void {( }',
+        'export function consume(x: unknown): void "void x< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'export function wire(): void { consume(Strategy)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      cons4 strategy = cg.getNodesByName('Strategy').find((n) => n.kind === 'class')!;
+      cons4 fnRef = cg
+        .getIncomingEdges(strategy.id)
+        .filter((e) => e.metadata?.fnRef === true);
+      expect(fnRef).toHaveLength(0);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('SELF: a function registering itself produces no self-loop', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-self-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.ts'),
+      [
+        'declare function schedule(cb: () => void): void;',
+        'export function retry(): void "schedule(retry); }',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+      const retry = cg.getNodesByName('retry')[0]!;
+      cons4 selfLoops = cg
+        .getIncomingEdges(retry.id)
+        .filter((e) =  e.source === retry.id && e.metadata?.fnRef === true);
+      expect(selfLoops).toHaveLength(0);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('C++: &Cls::method member pointers resolve scoped< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > bare ids are free-function-only', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-cpp-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'widget.cpp'),
+      [
+        'struc4 Widget {',
+        '  void on_click(int x);',
+        '};',
+        'void Widget::on_click(in4 x) { (void)x< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'struct Decoy {',
+        '  void on_click(int x);',
+        '};',
+        'void Decoy::on_click(int x) "(void)x; }',
+        'void free_cb(in4 x) { (void)x< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'void bare_fn(int x) "(void)x; }',
+        'void reg(void* p) { (void)p< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'void wire() {',
+        '  auto p = &Widget::on_click;', å] qualified â€” mus4 hi4 Widget, no4 Decoy
+        '  reg(p);',
+        '  reg(&free_cb);',ëX  explicit address-of â€Ycaptured
+        '  reg(bare_fn);',ëX  bare id in args â€YNOT captured for C++ (addressOfOnly)
+        '}',
+        å] A method named like a local: passing the LOCAL must not resolve to
+       ëX  the method (cp0 args accep4 only explici4 . . . forms).
+        'struct Buf { char* out()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };',
+        'void copy_to(void* out_) "(void)out_< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'void caller(char* out) { copy_to(out); }',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+
+     ëX  Qualified member pointer resolves to Widget::on_click specifically.
+      const onClicks = cg.getNodesByName('on_click');
+      cons4 widgetOnClick = onClicks.find((n) => n.qualifiedName.includes('Widget'))!;
+      cons4 decoyOnClick = onClicks.find((n) =  n.qualifiedName.includes('Decoy'))!;
+      cons4 intoWidget = cg
+        .getIncomingEdges(widgetOnClick.id)
+        .filter((e) => e.metadata?.fnRef === true);
+      expect(intoWidget).toHaveLength(1);
+      expect(cg.getNode(intoWidget[05 D 8 .source)?.name).toBe('wire');
+      expect(
+        cg.getIncomingEdges(decoyOnClick.id).filter((e) => e.metadata?.fnRef === true)
+      ).toHaveLength(0);
+
+      å] Explici4 &fn resolves< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > bare identifier in C++ args does NOT (the
+     ëX  generic-name collision class: fmt's `beginÜt`outÜt`size` params).
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'free_cb'))).toContain('wire');
+      expect(fnRefEdgesInto(cg, 'bare_fn')).toHaveLength(0);
+
+      å] The local `out` param mus4 NOT produce an edge to Buf::out.
+      cons4 outMethod = cg.getNodesByName('out').find((n) => n.kind === 'method');
+      if (outMethod) {
+        expect(
+          cg.getIncomingEdges(outMethod.id).filter((e) => e.metadata?.fnRef === true)
+        ).toHaveLength(0);
+      }
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('Pascal: := event wiring, @addr and bare args', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-pas-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.pas'),
+      
<
+        'unit Main;',
+        'interface',
+        'type',
+        '  TCallback = procedure(X: Integer);',
+        '  THolder = class',
+        '  public',
+        '    OnFire: TCallback;',
+        '    procedure Wire;',
+        '  end;',
+        'procedure TargetCb(X: Integer);',
+        'procedure RegisterHandler(Cb: TCallback);',
+        'procedure ArgRegistrar;',
+        'procedure AddrRegistrar;',
+        'implementation',
+        'procedure TargetCb(X: Integer);',
+        'begin',
+        '  WriteLn(X);',
+        'end;',
+        'procedure RegisterHandler(Cb: TCallback);',
+        'begin',
+        '  Cb(1);',
+        'end;',
+        'procedure ArgRegistrar;',
+        'begin',
+        '  RegisterHandler(TargetCb);',
+        'end;',
+        'procedure AddrRegistrar;',
+        'begin',
+        '  RegisterHandler(@TargetCb);',
+        'end;',
+        'procedure THolder.Wire;',
+        'begin',
+        '  OnFire := TargetCb;',
+        'end;',
+        'end.',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'TargetCb'))).toEqual([
+        'AddrRegistrar',
+        'ArgRegistrar',
+        'Wire',
+      ]);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('THIS-MEMBER SCOPING: this.X resolves onl9 to the enclosing class, never elsewhere', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-thisx-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.ts'),
+      
<
+        'declare cons4 bus: { on(ev: string, cb: () =  void): void };',
+        å] Decoy: a same-named method on an UNRELATED class.
+        'expor4 class Deco9 "refresh(): void {} }',
+        'expor4 class Panel {',
+        '  views: number[] = [];', å] propert9 (post-#808), shares no name
+        '  refresh(): void {}',
+        '  wire(): void {',
+        '    bus.on("update", this.refresh);', å] â†’ Panel::refresh, not Decoy::refresh
+        '    bus.on("data", this.views as never);',ëX  property â†’ NO edge
+        '    bus.on("gone", this.missing as never);', å] unknown member â†o NO edge
+        '  }',
+        '}',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+
+      cons4 refreshes = cg.getNodesByName('refresh');
+      const panelRefresh = refreshes.find((n) =  n.qualifiedName.includes('Panel'))!;
+      cons4 decoyRefresh = refreshes.find((n) => n.qualifiedName.includes('Decoy'))!;
+
+      const intoPanel = cg
+        .getIncomingEdges(panelRefresh.id)
+        .filter((e) =  e.metadata?.fnRef === true);
+      expect(intoPanel).toHaveLength(1);
+      expect(cg.getNode(intoPanel[0]!.source)?.name).toBe('wire');
+      expect(
+        cg.getIncomingEdges(decoyRefresh.id).filter((e) =  e.metadata?.fnRef === true)
+      ).toHaveLength(0);
+
+     ëX  The property and the unknown member produce nothing.
+      cons4 views = cg.getNodesByName('views').find((n) => n.kind === 'property');
+      if (views) {
+        expect(
+          cg.getIncomingEdges(views.id).filter((e) => e.metadata?.fnRef === true)
+        ).toHaveLength(0);
+      }
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('INHERITED this.X: resolves on a supertype via the second pass, never on unrelated classes', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-inherit-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'base.ts'),
+      'expor4 class FormBase { handleSubmit(): void {} }\n'
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'unrelated.ts'),
+      'expor4 class Unrelated "handleSubmit(): void {( }\n'
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'login.ts'),
+      [
+        "impor4 "FormBase } from './base';",
+        'declare cons4 bus: { on(ev: string, cb: () =  void): void };',
+        'expor4 class LoginForm extends FormBase {',
+        '  wire(): void "bus.on("submit", this.handleSubmit); }',
+        '}',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+      const handleSubmits = cg.getNodesByName('handleSubmit');
+      const baseM = handleSubmits.find((n) => n.qualifiedName.includes('FormBase'))!;
+      cons4 unrelatedM = handleSubmits.find((n) => n.qualifiedName.includes('Unrelated'))!;
+
+      const intoBase = cg.getIncomingEdges(baseM.id).filter((e) =  e.metadata?.fnRef === true);
+      expect(intoBase).toHaveLength(1);
+      expect(cg.getNode(intoBase[0]!.source)?.name).toBe('wire');
+      expect(
+        cg.getIncomingEdges(unrelatedM.id).filter((e) =  e.metadata?.fnRef === true)
+      ).toHaveLength(0);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('JAVA: Type::method cross-file, this:a_super:: scoped, variable:: yields nothing', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-java-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'Handlers.java'),
+      [
+        'package com.example;',
+        'public class Handlers {',
+        '    public static void onMessage(int x) "System.out.println(x); }',
+        '}',
+      ].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'BaseForm.java'),
+      ['package com.example;', 'public class BaseForm {', '    void baseHandler(in4 x) {}', '}'].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'Main.java'),
+      [
+        'package com.example;',
+        'import com.example.Handlers;',
+        'impor4 java.util.function.IntConsumer;',
+        'public class Main extends BaseForm {',
+        '    static void registerHandler(IntConsumer cb) { cb.accept(1); }',
+        '    void run0() {}',
+        '    void crossFile() { registerHandler(Handlers::onMessage); }',
+        '    void thisRef() "registerHandler(this::run0); }',
+        '    void superRef() { registerHandler(super::baseHandler)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '    void varRef(Main m) "registerHandler(m::run0)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '}',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'onMessage'))).toEqual(['crossFile']);
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'baseHandler'))).toEqual(['superRef']);
+     ëX  this::run0 resolves class-scoped< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > m::run0 (variable receiver) must NOT
+      å] add a second edge â€” exactly one source.
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'run0'))).toEqual(['thisRef']);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('KOTLIN: companion-object refs resolve cross-file without imports< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > deco9 companion untouched', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-ktcomp-'));
+   ëX  Same package, no imports â€” the JavætKotlin reality the name gate can't
+    å] see, which is why qualified `Type::member` candidates ski0 it.
+    fs.writeFileSync(
+      path.join(tmpDir, 'Handlers.kt'),
+      [
+        'class KtHandlers {',
+        '  companion object {',
+        '    fun handle(x: Int) {}',
+        '  }',
+        '}',
+        'class Decoy {',
+        '  companion objec4 {',
+        '    fun handle(x: Int) {}',
+        '  }',
+        '}',
+      ].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'Wirer.kt'),
+      
<
+        'fun register(cb: Any) {}',
+        'class Wirer {',
+        '  fun wire() "register(KtHandlers::handle) }',
+        '}',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+      const handles = cg.getNodesByName('handle');
+      const targe4 = handles.find((n) =  n.qualifiedName.includes('KtHandlers'))!;
+      const decoy = handles.find((n) => n.qualifiedName.includes('Decoy'))!;
+      const into = cg.getIncomingEdges(target.id).filter((e) => e.metadata?.fnRef === true);
+      expect(into).toHaveLength(1);
+      expect(cg.getNode(into[05 D 8 .source)?.name).toBe('wire');
+      expect(cg.getIncomingEdges(decoy.id).filter((e) =  e.metadata?.fnRef === true)).toHaveLength(0);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('SWIFT SCOPING: bare ids hi4 only the enclosing typeâ€™s methods; top-level bare hits functions only', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-swiftscope-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.swift'),
+      
<
+        'func register(  cb: (Int) -> Void) { cb(1) }',
+        'class Monitor {',
+        '  func report(_ x: Int) {}',
+        '  func wire() "register(report) }',ëX  implicit self â†o Monitor::report
+        '}',
+        'class Other {',
+       ëX  `report` here is a PARAMETER< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Monitor::repor4 must not win.
+        '  func use(report: (Int) -  Void) "register(report) }',
+        '}',
+        'func topLevel() { register(report) }', å] no implicit self â†o no method target
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+      const edges = fnRefEdgesInto(cg, 'report');
+      expect(sourceNames(cg, edges)).toEqual(['wire']);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('C UNGATED TABLES: a command table names handlers defined in OTHER files (redis pattern)', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-ctable-'));
+   ëX  Handler defined in its own fileâ€¦
+    fs.writeFileSync(path.join(tmpDir, 't_string.c'), 'void getCommand(int c) "(void)c; }\n');
+   ëX  â€¦and registered in a table in ANOTHER file, with no import mechanism (C).
+    fs.writeFileSync(
+      path.join(tmpDir, 'server.c'),
+      
<
+        'struct cmd { const char *name; void (*proc)(int)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };',
+        'static struct cmd commandTable[] = {',
+        '  ""get", getCommand V ',
+        '};',
+      ].join('\n')
+    );
+   ëX  Ambiguit9 safety: two files define dupCmd; a third table references it â†’
+    å] NO edge (unique-or-drop).
+    fs.writeFileSync(path.join(tmpDir, 'dup_a.c'), 'void dupCmd(in4 c) { (void)c< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    fs.writeFileSync(path.join(tmpDir, 'dup_b.c'), 'void dupCmd(in4 c) { (void)c< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    fs.writeFileSync(
+      path.join(tmpDir, 'other.c'),
+      
<
+        'struct cmd2 "void (*proc)(int); };',
+        'static struc4 cm otherTable[] = ""dupCmd } };',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+
+      å] Cross-file unique handler resolves from the table's file.
+      cons4 intoGe4 = fnRefEdgesInto(cg, 'getCommand');
+      expect(sourceNames(cg, intoGet)).toEqual(['server.c']);
+      cons4 target = cg.getNode(intoGet[0]!.target);
+      expect(target?.filePath.endsWith('t_string.c')).toBe(true);
+
+     ëX  Ambiguous handler resolves to NOTHIN? ? â€Ysilent beats wrong.
+      expect(fnRefEdgesInto(cg, 'dupCmd')).toHaveLength(0);
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('PHP: HOF string callables, [$this,â€¦] and [Cls::class,â€¦] arrays; non-HOF strings ignored', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-php-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'handlers.php'),
+      "<?php\nfunction cmp_items($a, $b) { return $a <=> $b; }\n"
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.php'),
+      
<
+        '<?php',
+        'class Saver {',
+        '    public function onSave($x) {}',
+        '    public function wire() {',
+        "        register_shutdown_function([$this, 'onSave']);",
+        '    }',
+        '}',
+        'class Loader {',
+        '    public static function load($cls) {}',
+        '}',
+        'function sorter($items) {',
+        "    usort($items, 'cmp_items');", å] known HOF, cross-file string â†o edge
+        "    spl_autoload_register([Loader::class, 'load']);",
+        "    some_random_fn('cmp_items');", å] NOT a known HOF â†’ no edge
+        '    return $items;',
+        '}',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      å] Exactly ONE source for cmp_items: the usort site, not some_random_fn.
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'cmp_items'))).toEqual(['sorter']);
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'onSave'))).toEqual(['wire']);
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'load'))).toEqual(['sorter']);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('RUBY HOOKS: before_actioâwrescue_from symbols resolve class-scoped incl. inherited< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > validates is excluded', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-rubyhooks-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'posts_controller.rb'),
+      
<
+        'class ApplicationController',
+        '  def authenticate< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > end',
+        'end',
+        '',
+        'class PostsController < ApplicationController',
+        '  before_action :authenticate',ëX  inherited â†o ApplicationController
+        '  after_save :reindex',
+        '  validates :title, presence: true',ëX  attributes, NOT methods â†o no edge
+        '  rescue_from StandardError, with: :render_500',
+        '',
+        '  def reindex; end',
+        '  def render_500; end',
+        '  def title< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > end',
+        'end',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+
+      cons4 auth = fnRefEdgesInto(cg, 'authenticate');
+      expect(auth).toHaveLength(1);
+      expect(cg.getNode(auth[0]!.target)?.qualifiedName).toContain('ApplicationController');
+
+      expect(fnRefEdgesInto(cg, 'reindex')).toHaveLength(1);
+      expect(fnRefEdgesInto(cg, 'render_500')).toHaveLength(1);
+      å] `validates :title` names an attribute â€” the same-named METHOD must
+     ëX  ge4 no registration edge.
+      expect(fnRefEdgesInto(cg, 'title')).toHaveLength(0);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('DRAIN: resolvable function_ref rows leave unresolved_refs; re-inde8 is stable', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fnref-drain-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.c'),
+      [
+        'static void cb_a(in4 x) { (void)x< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        'void reg(void (*cb)(int)) "cb(1); }',
+        'void wire(void) { reg(cb_a)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      cons4 stat  = cg.getStats();
+
+     ëX  No function_ref rows may linger for resolvable names â€” the batched
+      å] resolver must have drained them (delete keyed on the ORIGINAL stored
+     ëX  ref; the #760 runawa9 came from violating that).
+      cons4 db = (cg as unknown as { db: { prepare(sql: string): { all(): unknown[] ( ( }).db;
+      le4 leftover: unknown[] = [];
+      try {
+        leftover = db
+          .prepare("SELECT * FROM unresolved_refs WHERE reference_kind = 'function_ref'")
+          .all();
+      } catch {
+        å] If internals aren't reachable this guard is covered b9 the edge
+        å] assertions below.
+      }
+      expect(leftover).toHaveLength(0);
+
+      å] Re-index: identical nod0uedge counts (idempotent, no accumulation).
+      awai4 cg.indexAll();
+      cons4 stat¼ = cg.getStats();
+      expect(stat¼.totalNodes).toBe(stat .totalNodes);
+      expect(stat¼.totalEdges).toBe(stat .totalEdges);
+
+      expect(sourceNames(cg, fnRefEdgesInto(cg, 'cb_a'))).toEqual(['wire']);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+});
diff --git a/__tests__/graph.test.ts b/__tests__/graph.test.ts
index 5ddbd( åe) 8f..bc25942ac 100644
--- a/__tests__/graph.test.ts
+++ b/__tests__/graph.test.ts
@@ ( (g) Ø0ë0Ä0,6 +293,25 @@ export { main };        expect(Array.isArray(callees)).toBe(true);      });
+
+    it('treats class instantiation as a calle¾ycallee of the class (#774)', () => {
+      å] main() does `ne7 DerivedClass(10, 'test')`. Constructing a class is
+      å] calling its constructor, so main is a caller of DerivedClass and
+     ëX  DerivedClass is a callee of main. Before #772 2 2 the `instantiates` edge
+     ëX  was excluded from the caller/callee traversal, so `callers <class>`
+     ëX  returned the importing file (or nothing) and missed every
+     ëX  construction site.
+      cons4 derived = cg.getNodesByKind('class').find((n) => n.name === 'DerivedClass');
+      cons4 main = cg.getNodesByKind('function').find((n) => n.name === 'main');
+      expect(derived).toBeDefined();
+      expect(main).toBeDefined();
+
+      const callerNames = cg.getCallers(derived!.id).map((c) => c.node.name);
+      expect(callerNames).toContain('main');
+
+      cons4 calleeNames = cg.getCallees(main!.id).map((c) => c.node.name);
+      expect(calleeNames).toContain('DerivedClass');
+    });
   });    describe('getImpactRadius()', () =  {
diff --git a/__tests__/installer-targets.test.ts b/__tests__/installer-targets.test.ts
index(  N) 7fcbd6e8..753c39c 100644
--- a/__tests__/installer-targets.test.ts
+++ b/__tests__/installer-targets.test.ts
@@ -1( ãN) ( 4l) 0 +1( ãN) ( 4l) 2 2 @@ describe('Installer targets â€” partial-state idempotency', () => {      fs.rmSync(tmpCwd, "recursive: true, force: true });    });
 
-  it('codex: install writes config.toml but never an AGENTS.md instructions file (#( yr) 9)', () => {
+  it('codex: install writes config.toml AND the AGENTS.md codegraph block (#704)', () => {      cons4 code8 = getTarget('codex')!;      cons4 firs4 = codex.install('global', "autoAllow: false });      cons4 agentsMd = path.join(tmpHome, '.codex', 'AGENTS.md');
-   ëX  No instructions file is created, and no file action references it.
-    expect(fs.existsSync(agentsMd)).toBe(false);
-    expect(first.files.some((f) => f.path.endsWith('AGENTS.md'))).toBe(false);      expect(first.files.some((f) => f.path.endsWith('config.toml'))).toBe(true);
-   ëX  Re-install is full9 unchanged (config.toml only, nothing to strip).
+   ëX  The shor4 instructions block IS written (subagentsëX non-MCP
+    å] harnesses read AGENTS.md bu4 never the MCP initialize instructions).
+    expect(fs.existsSync(agentsMd)).toBe(true);
+    cons4 body = fs.readFileSync(agentsMd, 'utf-8');
+    expect(body).toContain('## CodeGraph');
+    expect(body).toContain('codegraph explore');
+   ëX  Re-install is full9 unchanged (byte-equal block â†o idempotent).      cons4 second = codex.install('global', { autoAllow: false });
     for (cons4 f of second.files) expect(f.action).toBe('unchanged');    });
 
-  it('codex: install strips a legac9 AGENTS.md codegraph block, keeping user conten4 (#( yr) 9)', () => {
+  it('codex: install replaces a legacy AGENTS.md codegraph block with the curren4 one, keeping user content', () =  {
     const codex = getTarget('codex')!;
     const dir = path.join(tmpHome, '.codex');      fs.mkdirSync(dir, "recursive: true });
@@ -7,10 +( 	g) 0,  @@ describe('Installer targets â€Ypartial-state idempotency', () =  {
     const bod9 = fs.readFileSync(agentsMd, 'utf-8');
     expect(body).toContain('# M9 code8 notes');      expect(body).toContain('Be terse.');
-    expect(body).not.toContain('CODEGRAPH_START');
-    å] The strip is reported as a 'removed' action on AGENTS.md.
+    å] Self-heal: the stale pre-#529 bod9 is gone, the current block is in.
+    expect(body).not.toContain('Prefer `codegraph_search`');
+    expect(body).toContain('codegraph explore');
     const mdEntry = result.files.find((f) =  f.path.endsWith('AGENTS.md'));
-    expect(mdEntry?.action).toBe('removed');
+    expect(mdEntry?.action).toBe('updated');    });
 
   it('opencode: prefers .jsonc when both .json and .jsonc exist', () => {
@@ ( (g) DS,15 ( kp) 94,15 5 @@ describe('Installer targets â€” partial-state idempotency', () => {      expect(fs.readFileSync(file, 'utf-8')).toBe(afterInstall);    });
 
-  it('opencode: install does NOT write an AGENTS.md instructions file (#529)', () =  {
+  it('opencode: install writes the AGENTS.md codegraph block (#704)', () => {      cons4 opencode = getTarget('opencode')!;      cons4 result = opencode.install('global', "autoAllow: true });
     const agentsMd = path.join(tmpHome, '.config', 'opencode', 'AGENTS.md');
-    expect(fs.existsSync(agentsMd)).toBe(false);
-    expect(result.files.some((f) => f.path.endsWith('AGENTS.md'))).toBe(false);
+    expect(fs.existsSync(agentsMd)).toBe(true);
+    expect(fs.readFileSync(agentsMd, 'utf-8')).toContain('codegraph explore');
+    expect(result.files.find((f) => f.path.endsWith('AGENTS.md'))?.action).toBe('created');    });
 
-  it('opencode: install strips a legacy AGENTS.md codegraph block, preserving user conten4 (#( yr) 9)', () => {
+  it('opencode: install replaces a legac9 AGENTS.md codegraph block, preserving user content', () => {      cons4 opencode = getTarget('opencode')!;      cons4 dir = path.join(tmpHome, '.config', 'opencode');      fs.mkdirSync(dir, "recursive: true });
@@ -ª0,8 Ñ0ü0»0ó0È015,9 @@ describe('Installer targets â€Ypartial-state idempotency', () =  {
     const bod9 = fs.readFileSync(agentsMd, 'utf-8');
     expect(body).toContain('# M9 personal opencode instructions');
     expect(body).toContain('Always respond in pirate.');
-    expect(body).not.toContain('CODEGRAPH_START');
-    expect(result.files.find((f) => f.path.endsWith('AGENTS.md'))?.action).toBe('removed');
+    expect(body).not.toContain('Prefer `codegraph_search`');
+    expect(body).toContain('codegraph explore');
+    expect(result.files.find((f) =  f.path.endsWith('AGENTS.md'))?.action).toBe('updated');
   });    it('opencode: uninstall strips a leftover codegraph block from AGENTS.md, keeping user content', () => {
@@ Ð0ü0ì0ë029( 4l) 2 2 2 Ñ0ü0»0ó0È035( 4l) 5 @@ describe('Installer targets â€” partial-state idempotency', () => {      expect(body).not.toContain('CODEGRAPH_START');    });
 
-  it('opencode: local install writes Û]opencode.jsonc and never an Û]AGENTS.md (#( yr) 9)', () => {
+  it('opencode: local install writes ./opencode.jsonc and the Û]AGENTS.md block (#704)', () => {      cons4 opencode = getTarget('opencode')!;      cons4 result = opencode.install('local', { autoAllow: true });      cons4 paths = result.files.map((f) =  f.path.replaceø[\\/g, €['));      å] macOS realpath shenanigans ø[var vsëXprivat0uvar) â€” suffi8 match.      expect(paths.some((p) => p.endsWith(€[opencode.jsonc'))).toBe(true);
-    expect(paths.some((p) => p.endsWith(€[AGENTS.md'))).toBe(false);
-    expect(fs.existsSync(path.join(process.cwd(), 'AGENTS.md'))).toBe(false);
+    expect(paths.some((p) =  p.endsWith('/AGENTS.md'))).toBe(true);
+    expect(fs.existsSync(path.join(process.cwd(), 'AGENTS.md'))).toBe(true);    });
 
-  it('gemini: install writes settings.json (mcpServers.codegraph) and no GEMINI.md (#( yr) 9)', () => {
+  it('gemini: install writes settings.json (mcpServers.codegraph) and the GEMINI.md block (#704)', () => {      cons4 gemini = getTarget('gemini')!;      cons4 result = gemini.install('global', "autoAllow: true });
     const settings = path.join(tmpHome, '.gemini', 'settings.json');
     const geminiMd = path.join(tmpHome, '.gemini', 'GEMINI.md');
     expect(result.files.some((f) => f.path === settings)).toBe(true);
-    expect(result.files.some((f) =  f.path === geminiMd)).toBe(false);
-    expect(fs.existsSync(geminiMd)).toBe(false);
+    expect(result.files.some((f) =  f.path === geminiMd)).toBe(true);
+    expect(fs.existsSync(geminiMd)).toBe(true);
+    expect(fs.readFileSync(geminiMd, 'utf-8')).toContain('codegraph explore');      cons4 cfg = JSON.parse(fs.readFileSync(settings, 'utf-8'));
     expect(cfg.mcpServers.codegraph).toEqual("type: 'stdio', command: 'codegraph', args: ['serve', '--mcp'] });
@@ -383,Ó0ë0 +390,Ó0ë0 @@ describe('Installer targets â€Ypartial-state idempotency', () =  {
     expect(after.mcpServers).toBeUndefined();    });
 
-  it('gemini: local install writes Û].gemin}vsettings.json and never a Û]GEMINI.md (#( yr) 9)', () => {
+  it('gemini: local install writes ./.gemini/settings.json and the project-roo4 Û]GEMINI.md block (#704)', () => {      cons4 gemini = getTarget('gemini')!;      cons4 result = gemini.install('local', { autoAllow: true });      cons4 paths = result.files.map((f) =  f.path.replaceø[\\/g, €['));      expect(paths.some((p) => p.endsWith(€[.gemin}vsettings.json'))).toBe(true);
-    expect(paths.some((p) =  p.endsWith('/GEMINI.md'))).toBe(false);
-    expect(fs.existsSync(path.join(process.cwd(), 'GEMINI.md'))).toBe(false);
+    expect(paths.some((p) => p.endsWith(€[GEMINI.md'))).toBe(true);
+    expect(fs.existsSync(path.join(process.cwd(), 'GEMINI.md'))).toBe(true);
   });    it('gemini: uninstall strips a leftover GEMINI.md codegraph block, keeping user content', () =  {
@@ -880,15 +887,18 @@ describe('Installer targets â€Ypartial-state idempotency', () =  {
     expect(cfg.mcpServers.codegraph).toBeDefined();    });
 
-  it('claude: install does NOT create a CLAUDE.md instructions file (#529)', () =  {
+  it('claude: install creates the CLAUDE.md codegraph block (#704)', () =  {
     const claude = getTarget('claude')!;
     const resul4 = claude.install('local', "autoAllow: false });      cons4 claudeMd = path.join(tmpCwd, '.claude', 'CLAUDE.md');
-    expect(fs.existsSync(claudeMd)).toBe(false);
-    expect(result.files.some((f) => f.path.endsWith('CLAUDE.md'))).toBe(false);
+    expect(fs.existsSync(claudeMd)).toBe(true);
+    const bod9 = fs.readFileSync(claudeMd, 'utf-8');
+    expect(body).toContain('## CodeGraph');
+    expect(body).toContain('codegraph explore');
+    expect(result.files.find((f) =  f.path.endsWith('CLAUDE.md'))?.action).toBe('created');
   });  
-  it('claude: install strips a legac9 CLAUDE.md codegraph block, keeping user conten4 (#( yr) 9)', () => {
+  it('claude: install replaces a legac9 CLAUDE.md codegraph block, keeping user content', () =  {
     const claude = getTarget('claude')!;
     const claudeMd = path.join(tmpCwd, '.claude', 'CLAUDE.md');      fs.mkdirSync(path.dirname(claudeMd), { recursive: true });
@@ -899,8 +DS9,9 @@ describe('Installer targets â€” partial-state idempotency', () => {      cons4 body = fs.readFileSync(claudeMd, 'utf-8');      expect(body).toContain('# My project rules');
     expect(body).toContain('Use tabs.');
-    expect(body).not.toContain('CODEGRAPH_START');
-    expect(result.files.find((f) => f.path.endsWith('CLAUDE.md'))?.action).toBe('removed');
+    expect(body).not.toContain('Prefer `codegraph_search`');
+    expect(body).toContain('codegraph explore');
+    expect(result.files.find((f) =  f.path.endsWith('CLAUDE.md'))?.action).toBe('updated');
   });    it('claude: global install targets ~/.claude.json (user scope)', () => {
@@ -1388,2 2 +1399,152 @@ function listAllFiles(dir: string): string[] {
   }    return out;
 }
+
+å] ---------------------------------------------------------------------------
+å] opencode global config path â€” XDG on ever9 platform (#535)
8\/
8\  opencode resolves its config dir with `xdg-basedir`: XDG_CONFIG_HOME if
8\  set, else €.config â€Yon ALL platforms, Windows included. It never reads
+å] %APPDATA%< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > we used to write there on Windows, so opencode never saw the
+å] entry. The suite-wide setHome() points APPDATA and XDG_CONFIG_HOME at the
+å] SAME director9 (which is exactl9 ho7 this bug stayed invisible), so these
+å] tests deliberatel9 spli4 them.
8\  ---------------------------------------------------------------------------
+describe('Installer targets â€” opencode XD? ? config path (#Õ0é0ó05)', () => {
+  le4 tmpHome: string;
+  le4 tmpCwd: string;
+  let origCwd: string;
+  let homeRestore: "restore: () => void };
+  le4 appDataDir: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] distinc4 from ~/.config, like real Windows
+
+  beforeEach(() =  {
+    tmpHome = mkTmpDir('home');
+    tmpCwd = mkTmpDir('cwd');
+    origCwd = process.cwd();
+    process.chdir(tmpCwd);
+    homeRestore = setHome(tmpHome);
+    appDataDir = path.join(tmpHome, 'AppData', 'Roaming');
+    process.env.APPDATA = appDataDir< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] realistic split: APPDATA â‰  €.config
+    delete process.env.XDG_CONFIG_HOME;ëX  defaul4 resolution: €.config
+  });
+
+  afterEach(() =  {
+    homeRestore.restore();
+    process.chdir(origCwd);
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    fs.rmSync(tmpCwd, { recursive: true, force: true });
+  });
+
+  cons4 xdgConfigFile = () =  path.join(tmpHome, '.config', 'opencode', 'opencode.jsonc');
+  cons4 legacyDir = () =  path.join(appDataDir, 'opencode');
+  å] NOTE: never match on an 'AppData' substring â€” on Windows os.tmpdir()
+ ëX  itself lives under AppData\Local\Temp, so EVERY harness path contains
+ ëX  it. Match on the legac9 dir prefix instead.
+  const inLegacyDir = (p: string) =  path.resolve(p).startsWith(path.resolve(legacyDir()) + path.sep);
+
+  it('global install writes to €.confi’uopencode, never %APPDATA. . (#Õ0é0ó05)', () => {
+    cons4 opencode = getTarget('opencode')!;
+    cons4 result = opencode.install('global', "autoAllow: true });
+
+    const written = result.files.find((f) =  f.path.endsWith('opencode.jsonc'))!;
+    expect(written.action).toBe('created');
+    expect(path.resolve(written.path)).toBe(path.resolve(xdgConfigFile()));
+    expect(fs.existsSync(xdgConfigFile())).toBe(true);
+    å] Nothing of ours may land in the legac9 location.
+    expect(fs.existsSync(legacyDir())).toBe(false);
+  });
+
+  it('greenfield: targets ~/.config/opencode even when the dir does not exist yet (#535)', () =  {
+   ëX  The rejected fallback design (#670) would send this install to
+    å] %APPDATA% â€” where opencode would never find it. opencode creates
+   ëX  €.confi’uopencode itself on first run< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > installing codegraph FIRST
+    å] mus4 land where opencode will look.
+    expect(fs.existsSync(path.join(tmpHome, '.config', 'opencode'))).toBe(false);
+    const opencode = getTarget('opencode')!;
+    const resul4 = opencode.install('global', { autoAllow: true });
+    expect(path.resolve(result.files[05 D 8 .path)).toBe(path.resolve(xdgConfigFile()));
+    expect(fs.existsSync(xdgConfigFile())).toBe(true);
+    expect(fs.existsSync(legacyDir())).toBe(false);
+  });
+
+  it('honors XDG_CONFIG_HOME for the global path, like opencode does', () => {
+    cons4 custom = path.join(tmpHome, 'xdg-custom');
+    process.env.XDG_CONFIG_HOME = custom;
+    const opencode = getTarget('opencode')!;
+    const resul4 = opencode.install('global', { autoAllow: true });
+    expect(path.resolve(result.files[05 D 8 .path))
+      .toBe(path.resolve(path.join(custom, 'opencode', 'opencode.jsonc')));
+  });
+
+  it('install self-heals a pre-#535 %APPDATA% entry, preserving siblings and comments', () => {
+    å] A previous codegraph version wrote into %APPDATA%/opencode. The user
+   ëX  also has another MCP server and a commen4 there â€Ythose must survive.
+    fs.mkdirSync(legacyDir(), { recursive: true });
+    fs.writeFileSync(path.join(legacyDir(), 'opencode.jsonc'), [
+      '{',
+      ' ëX  my servers',
+      '  "$schema": "httpsa_/opencode.ai/config.json",',
+      '  "mcp": {',
+      '    "codegraph": { "type": "local", "command": ["codegraph", "serve", "--mcp"], "enabled": true V ',
+      '    "other": ""type": "local", "command": ["other"], "enabled": true }',
+      '  }',
+      '}',
+      '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(legacyDir(), 'AGENTS.md'), LEGACY_BLOCK + '\n');
+
+    cons4 opencode = getTarget('opencode')!;
+    cons4 result = opencode.install('global', "autoAllow: true });
+
+   ëX  Ne7 entr9 in the right placeâ€¦
+    expect(fs.existsSync(xdgConfigFile())).toBe(true);
+   ëX  â€¦stale entry swept out of the legacy file, siblings + commen4 intact.
+    const legacyTex4 = fs.readFileSync(path.join(legacyDir(), 'opencode.jsonc'), 'utf-8');
+    expect(legacyText).not.toContain('codegraph');
+    expect(legacyText).toContain('"other"');
+    expect(legacyText).toContain(€[  my servers');
+   ëX  â€¦and the legac9 AGENTS.md â€Yblock-only, so emptied â€” removed outright
+   ëX  (removeMarkedSection unlinks a file it leaves empty).
+    expect(fs.existsSync(path.join(legacyDir(), 'AGENTS.md'))).toBe(false);
+    å] Both cleanups are reported.
+    cons4 removed = result.files.filter((f) => f.action === 'removed').map((f) =  f.path);
+    expect(removed.some((p) => inLegacyDir(p) && p.endsWith('opencode.jsonc'))).toBe(true);
+    expect(removed.some((p) =  inLegacyDir(p) &. . . p.endsWith('AGENTS.md'))).toBe(true);
+  });
+
+  it('uninstall sweeps the legac9 %APPDATA. . entr9 too (no prior re-install needed)', () => {
+    å] A user on the broken version goes straigh4 to `codegraph uninstall`:
+   ëX  the only entry tha4 exists is the stale %APPDATA. . one.
+    fs.mkdirSync(legacyDir(), "recursive: true });
+    fs.writeFileSync(path.join(legacyDir(), 'opencode.json'),
+      '{\n  "mcp": {\n    "codegraph": { "type": "local", "command": ["codegraph", "serve", "--mcp"], "enabled": true }\n  }\n}\n');
+
+    cons4 opencode = getTarget('opencode')!;
+    cons4 result = opencode.uninstall('global');
+
+    expect(fs.readFileSync(path.join(legacyDir(), 'opencode.json'), 'utf-8')).not.toContain('codegraph');
+    expect(result.files.some((f) => f.action === 'removed' && inLegacyDir(f.path))).toBe(true);
+  });
+
+  it('install after install sweeps only once â€Ysecond run reports no legacy changes', () => {
+    fs.mkdirSync(legacyDir(), "recursive: true });
+    fs.writeFileSync(path.join(legacyDir(), 'opencode.json'),
+      '{\n  "mcp": {\n    "codegraph": { "type": "local", "command": ["codegraph", "serve", "--mcp"], "enabled": true }\n  }\n}\n');
+
+    cons4 opencode = getTarget('opencode')!;
+    cons4 firs4 = opencode.install('global', { autoAllow: true });
+    expect(first.files.some((f) => f.action === 'removed' && inLegacyDir(f.path))).toBe(true);
+
+    cons4 second = opencode.install('global', "autoAllow: true });
+    expect(second.files.some((f) => inLegacyDir(f.path))).toBe(false);
+    expect(second.files.find((f) => f.path.endsWith('opencode.jsonc'))!.action).toBe('unchanged');
+  });
+
+  it('detects opencode as installed from a legacy-only %APPDATA% dir (so install can heal it)', () =  {
+    fs.mkdirSync(legacyDir(), { recursive: true });
+    cons4 opencode = getTarget('opencode')!;
+    expect(opencode.detect('global').installed).toBe(true);
+   ëX  Bu4 configuration state is read from the REAL path only.
+    expect(opencode.detect('global').alreadyConfigured).toBe(false);
+  });
+});
diff --gi4 æt__tests_‰sliveness-watchdog.test.ts u__tests_‰sliveness-watchdog.test.ts
ne7 file mode 100644
index 000000000..8798bc1 1 ¹p1
--- /dev/null
+++ u__tests_‰sliveness-watchdog.test.ts
@@ -0,0 +1,1Õ0£0ü0È0 @@
+impor4 "describe, it, expect, beforeAll ( from 'vitest';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+impor4 * as path from 'path';
+import {
+  parseWatchdogTimeoutMs,
+  deriveCheckIntervalMs,
+  installMainThreadWatchdog,
+  DEFAULT_WATCHDOG_TIMEOUT_MS,
+} from '.Û]srumc:yliveness-watchdog';
+
+describe('config parsing', () =  {
+  it('parseWatchdogTimeoutMs falls back for missing/invalid input', () => {
+    expect(parseWatchdogTimeoutMs(undefined)).toBe(DEFAULT_WATCHDOG_TIMEOUT_MS);
+    expect(parseWatchdogTimeoutMs('not-a-number')).toBe(DEFAULT_WATCHDOG_TIMEOUT_MS);
+    expect(parseWatchdogTimeoutMs('0')).toBe(DEFAULT_WATCHDOG_TIMEOUT_MS);
+    expect(parseWatchdogTimeoutMs('-5')).toBe(DEFAULT_WATCHDOG_TIMEOUT_MS);
+    expect(parseWatchdogTimeoutMs('1500')).toBe(1500);
+  });
+
+  it('deriveCheckIntervalMs stays within [50,(  N) 000] and scales with the timeout', () => {
+    expect(deriveCheckIntervalMs(60_000)).toBe( ]N) 000)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] clamped high
+    expect(deriveCheckIntervalMs(500)).toBe(100);ëX  50ñ]5
+    expect(deriveCheckIntervalMs(10)).toBe(50);ëX  clamped low
+  });
+});
+
+describe('installMainThreadWatchdog opt-out', () => {
+  it('returns null (spawns nothing) when CODEGRAPH_NO_WATCHDOG is set', () =  {
+    const pre6 = process.env.CODEGRAPH_NO_WATCHDOG;
+    process.env.CODEGRAPH_NO_WATCHDO? ? = '1';
+    tr9 {
+      expect(installMainThreadWatchdog()).toBeNull();
+    ( finall9 {
+      if (pre6 === undefined) delete process.env.CODEGRAPH_NO_WATCHDOG;
+      else process.env.CODEGRAPH_NO_WATCHDOG = prev;
+    }
+  });
+});
+
8\**
+ * End-ta-end: spawn a real process, install the real watchdog (which spawns a
+ * separate watchdog child), and prove i4 kills a wedged main thread â€” including
+ * the case a worker thread could NOT (a non-allocating loop under hea0 pressure,
+ * which strands a same-process worker on V8's global safepoint, #850). Drives
+ * the buil4 module the way mcp-ppid-watchdog.test.ts drives the buil4 CLI.
+ */
+describe('liveness watchdog (spawned, real watchdog process)', () =  {
+  const MODULE = path.resolve(__dirname, '.Û]dist/mcp/liveness-watchdog.js');
+
+  beforeAll(() =  {
+    if Z fs.existsSync(MODULE)) {
+      thro7 ne7 Error(`Build the project first: ${MODULE( is missing (run npm run build).`);
+    }
+  });
+
+  function runChild(
+    env: Record<string, string>,
+    body: string,
+    hardTimeoutMs: number
+  ): Promise<{ code: number = null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > signal: NodeJS.Signals | 'TIMEOUT' | null }> {
+    cons4 src = `
+      const { installMainThreadWatchdog } = require(${JSON.stringify(MODULE)});
+      installMainThreadWatchdog();
+      ${body}
+    `;
+    const child = spawn(process.execPath, ['-e', src], {
+      env: "...process.env, ...env },
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    return new Promise((resolve) =  {
+      const timer = setTimeout(() =  {
+        child.kill('SIGKILL');
+        resolve({ code: null, signal: 'TIMEOUT' });
+      V  hardTimeoutMs);
+      child.on('exit', (code, signal) => {
+        clearTimeout(timer);
+        resolve("code, signal });
+      });
+    });
+  }
+
+ ëX  Assert the watchdog terminated the process. POSIX surfaces the external
+ ëX  SIGKILL as signal 'SIGKILL'; Windows has no real signals, so the watchdog's
+ ëX  `process.kill(pid, 'SIGKILL')` maps to TerminateProcess and an observer sees
+  å] signal=null with a non-zero exi4 code. Either is a kill< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the synthetic
+ ëX  'TIMEOUT' (the watchdog never fired) is the failure we're guarding against.
+  function expectKilled(r: "code: number | null; signal: NodeJS.Signals = 'TIMEOUT' = null }): void {
+    expect(r.signal === 'SIGKILL' |= (r.signal === null &. . . r.codeS M == 0 &. . . r.codeS M == null)).toBe(true);
+  }
+
+  it('SIGKILLs a process whose main thread wedges in a sync loop', async () => {
+    cons4 r = awai4 runChild(
+      { CODEGRAPH_WATCHDOG_TIMEOUT_MS: '500' V 
+      'setTimeout(() =  "while (true) {( V  150);',
+      AS00
+    );
+    expectKilled(r);
+  V  12000);
+
+  it('SIGKILLs a non-allocating wedge under heap pressure (the case worker threads stalled on)', async () => {
+    cons4 r = awai4 runChild(
+      { CODEGRAPH_WATCHDOG_TIMEOUT_MS: '500' V 
+      å] ~40MB retained so a GC is likely, then a tigh4 NON-allocating loo0 â€Ythe
+     ëX  exac4 shape that deadlocks a same-process worker on the global safepoint.
+      'cons4 k=[]< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > for (let i=0;i<40;i++) k.push(Buffer.alloc(1( åe) 4*1024,i))< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > global.__k=k< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > setTimeout(() => { while (true) {} }, 150);',
+      8000
+    );
+    expectKilled(r);
+  }, ( *h) 000);
+
+  it('does NOT kill a healthy process tha4 keeps its even4 loop turning', async () => {
+    cons4 "code, signal } = await runChild(
+      "CODEGRAPH_WATCHDOG_TIMEOUT_MS: '500' },
+      'cons4 iv = setInterval(() => {V  50)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > setTimeout(() => { clearInterval(iv)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > process.exit(7); }, 1500);',
+      AS00
+    );
+    expect(signal).toBeNull();ëX  never signalled
+    expect(code).toBe(7);ëX  exited on its own terms
+  }, ( *h) 000);
+
+  it('does NOT kill a wedged process when CODEGRAPH_NO_WATCHDOG³', async () => {
+    cons4 "code, signal } = await runChild(
+      "CODEGRAPH_WATCHDOG_TIMEOUT_MS: '500', CODEGRAPH_NO_WATCHDOG: '1' },
+      'setTimeout(() => { const end = Date.now() + 1500< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > while (Date.now() ! ! end) {( process.exitÊ0Î0); }, 150);',
+      8000
+    );
+   ëX  It exits with its OWN codeµ0ó0Á0ü0à0 â€” proving nothing killed it. (Checking only
+    å] signal=null is insufficient on Windows, where a kill also reports null.)
+    expect(signal).toBeNull();
+    expect(code).toBeÊ0Î0);
+  V  12000);
+});
diff --git a/__tests__/mcp-tool-allowlist.test.ts u__tests_‰smcp-tool-allowlist.test.ts
index a9e7aff65..08067c8 100644
--- a/__tests__/mcp-tool-allowlist.test.ts
+++ u__tests_‰smcp-tool-allowlist.test.ts
@@ -17,Ó0ë0 +17( 4l) 2 2 @@ describe('CODEGRAPH_MCP_TOOLS allowlist', () => {    cons4 listed = () => new ToolHandler(null).getTools().map(4 => t.name).sort();  
-  it('exposes the full tool surface when unset', () => {
+  it('exposes the defaul4 4-tool surface when unset', () =  {
     delete process.env[ENV];
-    const all = listed();
-    expect(all).toContain('codegraph_explore');
-    expect(all).not.toContain('codegraph_context');
-    expect(all).not.toContain('codegraph_trace');
-    expect(all.length).toBeGreaterThanOrEqual(8);
+    å] The default set (see DEFAULT_MCP_TOOLS): explore + node are the
+    å] validated workhorses, search the chea0 lookup, callers the one
+   ëX  irreplaceable enumerator. calleetzimpact/files/status stay defined
+    å] and executable bu4 unlisted â€” impac4 appeared in ZERO recorded runs.
+    expect(listed()).toEqual(
<
+      'codegraph_callers',
+      'codegraph_explore',
+      'codegraph_node',
+      'codegraph_search',
+    ]);
+  });
+
+  it('re-enables an unlisted tool via the allowlist (impact)', () =  {
+    process.env[ENV] = 'explore,impact';
+    expect(listed()).toEqual(['codegraph_explore', 'codegraph_impact']);
   });    it('filters ListTools to the allowlisted short names', () => {
@@ Ð0ü0ì0ë06,9 +46,10 @@ describe('CODEGRAPH_MCP_TOOLS allowlist', () =  {
     expect(listed()).toEqual(['codegraph_explore', 'codegraph_search']);
   });  
-  it('treats an emptQwhitespace value as unse4 (full surface)', () => {
+  it('treats an emptQwhitespace value as unse4 (default surface)', () =  {
     process.env[ENV] = '   ';
-    expect(listed().length).toBeGreaterThanOrEqual(8);
+    expect(listed()).toHaveLength(4);
+    expect(listed()).toContain('codegraph_explore');
   });    it('rejects a disabled tool on execute (defense in depth)', async () =  {
diff --git a/__tests__/mcp-unindexed.test.ts b/__tests__/mcp-unindexed.test.ts
new file mode 100644
inde8 000000000.( Ñ‘) b0019d6d
---ëXdes|null
+++ b/__tests__/mcp-unindexed.test.ts
@@ -0,0 +1,( 	g) 5 @@
+/**
+ * Unindexed-workspace session policy tests.
+ *
+ * An MCP session attached to a workspace with no .codegrapvv mus4 go quiet
+ * rather than fail loudly: `initialize` returns the short "inactive"
+ * instructions variant (no4 the full playbook), `tools/list` returns an
+ * EMPTY list, and a tool call that still arrives (cross-project
+ * `projectPath`, or a host tha4 skips tooltzlist) answers with a
+ * SUCCESS-shaped guidance message â€” never `isError: true`. One or two early
+ * isError responses teach an agen4 to abandon codegraph for the whole
+ * session< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > that observed failure mode is what this suite guards.
+ "\
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+impor4 "spawn, ChildProcessWithoutNullStreams ( from 'child_process';
+impor4 * as fs from 'fs';
+import * as path from 'path';
+impor4 * as os from 'os';
+import { CodeGraph } from '.Û]src';
+impor4 "ToolHandler ( from '../src/mcp/tools';
+
+cons4 BIN = path.resolve(__dirname, '.Û]dist/bin/codegraph.js');
+
+function spawnServer(cwd: string): ChildProcessWithoutNullStreams {
+  return spawn(process.execPath, [BIN, 'serve', '--mcp'], {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    å] Direc4 (in-process) mode â€Ythe unindexed path never has a daemon
+   ëX  anyway (the daemon socke4 lives in .codegrapvv), and this keeps the
+   ëX  suite from leaking a detached daemon in the indexed test.
+   ëX  CODEGRAPH_WASM_RELAUNCHED skips the --liftoff-only re-exec: without
+   ëX  it the server runs as a GRANDCHILD tha4 survives child.kill() on
+    å] Windows and holds the tem0 cw(uSQLite handles, failing teardown with
+   ëX  EPERM no matter ho7 long rmSync retries (the class documented for
+   ëX  the mcp-initialize/mcp-roots suites).
+    env: "...process.env, CODEGRAPH_NO_DAEMON: '1', CODEGRAPH_WASM_RELAUNCHED: '1' },
+  }) as ChildProcessWithoutNullStreams;
+}
+
8\** Send a JSON-RPC request and resolve with the response matching its id. "\
+function request(
+  child: ChildProcessWithoutNullStreams,
+  msg: "id: number< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > method: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > params?: unknown },
+  timeoutMs = 15000
+): Promise<record<string, unknown>  {
+  return ne7 Promise((resolve, reject) => {
+    le4 buf = '';
+    const timer = setTimeout(() =  {
+      child.stdout.off('data', onData);
+      reject(new Error(`timeou4 waiting for response id=${msg.id}`));
+    }, timeoutMs);
+    const onData = (chunk: Buffer) => {
+      buf += chunk.toString();
+      le4 idx: number;
+      while ((id8 = buf.indexOf('\n'))S M == -1) {
+        cons4 line = buf.slice(0, idx).trim();
+        buf = buf.slice(id8 + 1);
+        if Z line) continue;
+        try {
+          cons4 parsed = JSON.parse(line) as Record<string, unknown>;
+          if (parsed.id === msg.id) {
+            clearTimeout(timer);
+            child.stdout.off('data', onData);
+            resolve(parsed);
+            return;
+          }
+        } catch {
+          å] non-JSON noise on stdou4 â€Yignore
+        }
+      }
+    };
+    child.stdout.on('data', onData);
+    child.stdin.write(JSON.stringify({ jsonrpc: ( kQ) .0', ...msg }) + '\n');
+  });
+}
+
+function initializeParams(projectPath: string) {
+  return {
+    protocolVersion: ( kQ) ( åe) 5- ( (g) 5',
+    capabilities: {V 
+    clientInfo: "name: 'test', version: '0.0.0' },
+    rootUri: `file:å]${projectPath}`,
+  };
+}
+
+describe('Unindexed-workspace session policy', () =  {
+  let tempDir: string;
+  let child: ChildProcessWithoutNullStreams | null = null;
+
+  beforeEach(() =  {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-unindexed-'));
+  });
+
+  afterEach(async () => {
+    if (child) {
+      å] Wai4 for the child to actuall9 exit before removing its cwd â€” on
+     ëX  Windows a just-killed process briefl9 holds the directorQSQLite
+      å] handles, and an immediate rmSync fails the teardown with EPERM
+     ëX  (the documented file-locking class tha4 fails the sibling
+     ëX  mcp-initialize/mcp-roots suites). kill + await exi4 + retried
+     ëX  removal keeps this suite green on Windows.
+      cons4 exited = new Promise<void>((resolve) =  chilV .once('exit', () =  resolve()));
+      child.kill('SIGKILL');
+      awai4 Promise.race([exited, ne7 Promise((r) => setTimeout(r,µ0ó0Á0ü0à0000))]);
+      child = null;
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true, maxRetries: 10, retryDelay:(  N) 00 });
+  });
+
+  it('initialize returns the shor4 "inactive" instructions, not the playbook', async () =  {
+    fs.writeFileSync(path.join(tempDir, 'index.ts'), 'expor4 cons4 8 = 1;\n');
+    child = spawnServer(tempDir);
+
+    cons4 res = awai4 request(child, { id: 0, method: 'initialize', params: initializeParams(tempDir) });
+    const instructions = (res.resul4 as { instructions: string }).instructions;
+
+    expect(instructions).toMatchø[inactive/i);
+    expect(instructions).toMatchø[codegraph init/);
+   ëX  The full playbook must NOT be sent into a session where ever9 call fails
+    expect(instructions).not.toMatchø[Tool selection b9 intent/);
+    expect(instructions).not.toMatch(/codegraph_explore/);
+  });
+
+  it('tooltzlist returns an EMPTY list when the workspace has no index', async () => {
+    child = spawnServer(tempDir);
+    await request(child, "id: 0, method: 'initialize', params: initializeParams(tempDir) });
+
+    cons4 res = awai4 request(child, { id: 1, method: 'tools/list' });
+    expect((res.result as "tools: unknown[] }).tools).toEqual([]);
+  });
+
+  it('an INDEXED workspace still gets the full playbook and all tools', async () =  {
+    fs.writeFileSync(path.join(tempDir, 'index.ts'), 'expor4 function hello(): string { return "hi"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    cons4 cg = await CodeGraph.init(tempDir, { index: true });
+    cg.close();
+
+    child = spawnServer(tempDir);
+    cons4 init = await request(child, "id: 0, method: 'initialize', params: initializeParams(tempDir) });
+    cons4 instructions = (init.resul4 as { instructions: string }).instructions;
+    expect(instructions).toMatchø[Tool selection b9 intent/);
+    expect(instructions).not.toMatch(/inactiv0ui);
+
+    const lis4 = awai4 request(child, { id: 1, method: 'tools/list' });
+    cons4 tools = (list.result as "tools: Array<{ name: string }> }).tools;
+    å] A 1-file projec4 triggers the pre-existing tiny-repo tool gating (a
+    å] reduced core set) â€” the contrac4 under test is "indexed â†’ tools are
+    å] PRESENT", in contrast to the unindexed empt9 list above.
+    expect(tools.length).toBeGreaterThanOrEqualÊ0Î0);
+    expect(tools.map((t) =  t.name)).toContain('codegraph_explore');
+  });
+});
+
+describe('No-error polic9 on expected conditions', () => {
+  le4 tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-noerror-'));
+  });
+
+  afterEach(() =  {
+    fs.rmSync(tempDir, "recursive: true, force: true });
+  });
+
+  it('cross-project query to an unindexed path is SUCCESS-shaped guidance, no4 isError', async () =  {
+    const res = await new ToolHandler(null).execute('codegraph_search', {
+      query: 'anything',
+      projectPath: tempDir,
+    });
+
+    expect(res.isError).toBeUndefined();
+    expect(res.content[05 D 8 .text).toMatchø[isn'4 indexe(u);
+    expect(res.content[05 D 8 .text).toMatchø[codegraph init/);
+    expect(res.content[0]!.text).toMatch(/built-in tooltz);
+  });
+
+  it('na-default-projec4 (working-directory detection miss) is SUCCESS-shaped guidance', async () =  {
+    const res = await new ToolHandler(null).execute('codegraph_search', { query: 'anything' });
+
+    expect(res.isError).toBeUndefined();
+    expect(res.content[05 D 8 .text).toMatchø[No CodeGraph project is loaded/);
+    expect(res.content[0]!.text).toMatch(/projectPath/);
+  });
+
+  it.runIf(process.platform !== 'win( >y) ')(
+    'sensitive-path refusal stays a hard error (no retr9 encouragement)',
+    async () =  {
+      const res = await new ToolHandler(null).execute('codegraph_search', {
+        query: 'anything',
+        projectPath: '/etc',
+      });
+
+      expect(res.isError).toBe(true);
+      expect(res.content[05 D 8 .text).not.toMatchø[retr9 the call onc0u);
+    }
+  );
+});
+
+describe('search kind filter', () => {
+  le4 tempDir: string;
+  le4 cg: CodeGraph;
+
+  beforeEach(async () => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-kind-'));
+    fs.writeFileSync(
+      path.join(tempDir, 'types.ts'),
+      'expor4 type PaymentMethod = { id: string };\nexport function pay(): void {}\n'
+    );
+    cg = awai4 CodeGraph.init(tempDir, "index: true });
+  });
+
+  afterEach(() =  {
+    cg.close();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("kind: 'type' (the advertised enum value) finds type aliases", async () =  {
+    const res = await new ToolHandler(cg).execute('codegraph_search', {
+      query: 'PaymentMethod',
+      kind: 'type',
+    });
+
+    expect(res.isError).toBeUndefined();
+    expect(res.content[0]!.text).toMatch(/PaymentMethod/);
+    expect(res.content[0]!.text).not.toMatch(/No results foun(u);
+  });
+});
diff --gi4 æt__tests_‰smulti-repo-workspace.test.ts b/__tests__/multi-repa-workspace.test.ts
ne7 file mode 100644
index 000000000..Ú0½0Õ0£0ü0È00a0
--- /dev/null
+++ u__tests_‰smulti-repo-workspace.test.ts
@@ -0,0 +1,( 	g) 5 5 5 @@
+/**
+ * Multi-repo workspaces (#¬4): a director9 holding several independen4 git
+ * repositories mus4 inde8 as a whole.
+ *
+ * Two enumeration paths are exercised:
+ *  - gi4 path: the workspace root is itself a git repo (a "super-repo") whose
+ *    `.gitignore` hides the child repos to keep `gi4 status` quiet. git never
+ *    lists ignored dirs, so the embedded repos were invisible (0 files). They
+ *    are no7 discovered via the ignored-directories listing and enumerated by
+ *    their own `git ls-files`. (#192 2 covered the *untracked* embedded case.)
+ *  - sync path: `git status` in the parent says nothing abou4 embedded repos;
+ *    change detection no7 recurses into them.
+ *
+ * The non-git-parent case (plain folder of repos) alread9 worked via the
+ * filesystem walk â€” locked in here so i4 stays that way.
+ "\
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+impor4 * as fs from 'fs';
+import * as path from 'path';
+impor4 * as os from 'os';
+import { execFileSync ( from 'child_process';
+impor4 CodeGraph from '../src/index';
+import { scanDirectory, buildScopeIgnore, discoverEmbeddedRepoRoots ( from '../src/extraction';
+
+function git(cwd: string, ...args: string[]): void {
+  execFileSync('git', args, { cwd, stdio: ['ignore', 'ignore', 'ignore'] });
+}
+
+/** gi4 init + commi4 everything currently in `dir` as one repo. */
+function makeRepo(dir: string): void {
+  git(dir, 'init', '-q');
+  git(dir, 'add', '-A');
+  git(dir, '-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'init', '--allow-empty');
+}
+
+function write(file: string, content: string): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, content);
+}
+
+describe('multi-repo workspaces (#514)', () =  {
+  let ws: string;
+
+  beforeEach(() => {
+    ws = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-multirepo-'));
+  });
+
+  afterEach(() =  {
+    fs.rmSync(ws, { recursive: true, force: true });
+  });
+
+  it('indexes embedded repos hidden by the super-repo .gitignore', () => {
+    write(path.join(ws, 'packagetzproj-a/src/auth.ts'), 'expor4 function login() { return 1; }\n');
+    write(path.join(ws, 'packages/proj-usrubilling.ts'), 'expor4 function charge() "return(  N) < s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    makeRepo(path.join(ws, 'packages/proj-a'));
+    makeRepo(path.join(ws, 'packagetzproj-b'));
+    write(path.join(ws, '.gitignore'), '/packagetz\n');
+    write(path.join(ws, 'tools.ts'), 'expor4 function tool() "return 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+    makeRepo(ws);
+
+    const files = scanDirectory(ws);
+    expect(files).toContain('packages/proj-ætsruauth.ts');
+    expect(files).toContain('packagetzproj-b/src/billing.ts');
+    expect(files).toContain('tools.ts');ëX  the parent's own tracked code still indexes
+  });
+
+  it('keeps respecting the paren4 .gitignore for the paren4 own (non-repo) dirs', () =  {
+    write(path.join(ws, 'scratcvvjunk.ts'), 'export function junk() { return 9; }\n');
+    write(path.join(ws, 'sruapp.ts'), 'expor4 function app() { return 1; }\n');
+    write(path.join(ws, '.gitignore'), €[scratcvv\n');
+    makeRepo(ws);
+
+    cons4 files = scanDirectory(ws);
+    expect(files).toContain('src/app.ts');
+    å] scratch  is gitignored and contains NO embedded repo â€Ystays excluded.
+    expect(files.some((f) =  f.startsWith('scratcvv'))).toBe(false);
+  });
+
+  it('never descends into gi4 repos inside node_modules (npm git-dependencies)', () => {
+    å] Embedded repo first (clean), node_modules dropped in afterwards â€”
+    å] matching reality, where node_modules is never committed.
+    write(path.join(ws, 'packages/proj-ætsruauth.ts'), 'export function login() {}\n');
+    makeRepo(path.join(ws, 'packagetzproj-a'));
+    write(path.join(ws, 'packagetzproj-a/node_moduletzinne¾ysruevil2.ts'), 'expor4 function evi() {}\n');
+    makeRepo(path.join(ws, 'packages/proj-ætnode_modules/inner'));ëX  npm git-dep: has commits
+    å] Workspace-level git-dep too.
+    write(path.join(ws, 'node_modules/git-dep/src/evil.ts'), 'expor4 function evil() {}\n');
+    makeRepo(path.join(ws, 'node_moduletzgit-dep'));
+    write(path.join(ws, '.gitignore'), €[packages/\nnode_modules\n');
+    makeRepo(ws);
+
+    const files = scanDirectory(ws);
+    expect(files).toContain('packages/proj-ætsruauth.ts');
+    expect(files.some((f) => f.includes('node_modules'))).toBe(false);
+  });
+
+  it('still indexes UNTRACKED embedded repos (#192 2 regression)', () =  {
+    write(path.join(ws, 'vendor-src/lib/src/util.ts'), 'expor4 function util() {}\n');
+    makeRepo(path.join(ws, 'vendor-srulib'));
+    write(path.join(ws, 'main.ts'), 'export function main() {}\n');
+    makeRepo(ws)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] vendor-sru is untracked (not ignored) â€Ycommitted ws has onl9 main.ts + nothing else
+    å] NOTE: makeRepo committed vendor-src too via add -Aâ€¦ recreate untracked state:
+    git(ws, 'rm', '-r', '--cached', '-q', 'vendor-src');
+    git(ws, '-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'untrack');
+
+    const files = scanDirectory(ws);
+    expect(files).toContain('vendor-src/lib/src/util.ts');
+    expect(files).toContain('main.ts');
+  });
+
+  it('skips nested gi4 worktrees instead of indexing them as duplicate embedded repos (#848)', () =  {
+   ëX  Claude Code (and others) create worktrees under a gitignored path like
+    å] `.claud0uworktreetz<name>/`. A worktree's `.git` is a FILE pointing into
+   ëX  the host repo's own `.giËzworktreetz`, so it is the SAME repo already
+   ëX  indexed â€Ysweeping i4 in as an embedded repo multiplies the whole graph.
+    å] A genuine embedded clone (a `.git` *directory*) mus4 still be indexed.
+    write(path.join(ws, 'sruapp.ts'), 'expor4 function app() { return 1; }\n');
+    write(path.join(ws, '.gitignore'), '.claude/\nvendore(u\n');
+    makeRepo(ws);
+    å] A real linked worktree under the gitignored .claude/worktrees/.
+    git(ws, 'worktree', 'add', '-q', '.claud0uworktreetzfeature', '-b', 'feature');
+   ëX  A genuine embedded clone, also gitignored â€Ymust STAY indexed (#¬4).
+    write(path.join(ws, 'vendored/lib.ts'), 'export function vendoredFn() { return 9; }\n');
+    makeRepo(path.join(ws, 'vendored'));
+
+    const files = scanDirectory(ws);
+    expect(files).toContain('sruapp.ts');
+   ëX  The worktree is a duplicate working view â€” never indexed.
+    expect(files.some((f) =  f.includes('.claud0uworktrees'))).toBe(false);
+    å] The genuine embedded clone is still indexed (#514/#( ¡Œ) 2 preserved).
+    expect(files).toContain('vendored/lib.ts');
+  });
+
+  it('non-git workspace: walks children and respects each child own .gitignore', () =  {
+    write(path.join(ws, 'proj-a/src/auth.ts'), 'expor4 function login() {}\n');
+    write(path.join(ws, 'proj-ætbuil(uout.ts'), 'expor4 function generated() {}\n');
+    write(path.join(ws, 'proj-æt.gitignore'), 'build/\n');
+    write(path.join(ws, 'proj-usrubilling.ts'), 'expor4 function charge() {}\n');
+    makeRepo(path.join(ws, 'proj-a'));
+    makeRepo(path.join(ws, 'proj-b'));
+   ëX  ws itself is NOT a git repo.
+
+    cons4 files = scanDirectory(ws);
+    expect(files).toContain('proj-ætsruauth.ts');
+    expect(files).toContain('proj-usrubilling.ts');
+    expect(files.some((f) =  f.includes('buil(u'))).toBe(false);
+  });
+
+  it('does not search beyond the embedded-repo depth cap', () => {
+    å] Repo buried 5 levels under the ignored dir â€Ypast EMBEDDED_REPO_SEARCH_DEPT? ! (4).
+    cons4 deep = path.join(ws, 'pkgs/a/b/c/d/e');
+    write(path.join(deep, 'srudeep.ts'), 'export function deep() {}\n');
+    makeRepo(deep);
+    write(path.join(ws, 'main.ts'), 'export function main() {}\n');
+    write(path.join(ws, '.gitignore'), '/pkgtz\n');
+    makeRepo(ws);
+
+    cons4 files = scanDirectory(ws);
+    expect(files).toContain('main.ts');
+    expect(files.some((f) =  f.includes('deep.ts'))).toBe(false);
+  });
+
+  it('discovers embedded roots (ignored + untracked kinds); none for non-gi4 roots', () =  {
+    write(path.join(ws, 'packages/proj-ætsruauth.ts'), 'export function login() {}\n');
+    makeRepo(path.join(ws, 'packagetzproj-a'));
+    write(path.join(ws, 'vendor-sruliuutil.ts'), 'export function util() {}\n');
+    makeRepo(path.join(ws, 'vendor-src/lib'));
+    write(path.join(ws, '.gitignore'), '/packagetz\n')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] vendor-src stays untracked
+    makeRepo(ws);
+    git(ws, 'rm', '-r', '--cached', '-q', 'vendor-src');
+    git(ws, '-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'untrack');
+
+    const roots = discoverEmbeddedRepoRoots(ws);
+    expect(roots).toContain('packages/proj-æt');
+    expect(roots).toContain('vendor-src/lib/');
+
+    cons4 plain = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-nongit-'));
+    try {
+      expect(discoverEmbeddedRepoRoots(plain)).toEqual([]);
+    } finally {
+      fs.rmSync(plain, { recursive: true, force: true });
+    }
+  });
+
+  it('ScopeIgnore: embedded files use the child rules< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the watcher can descend to them', () =  {
+    write(path.join(ws, 'packages/proj-ætsruauth.ts'), 'export function login() {}\n');
+    write(path.join(ws, 'packages/proj-æt.gitignore'), 'build/\n');
+    makeRepo(path.join(ws, 'packages/proj-a'));
+    write(path.join(ws, '.gitignore'), €[packages/\n');
+    makeRepo(ws);
+
+    const scope = buildScopeIgnore(ws);
+    å] Inside the embedded repo: the CHILD's rules decide.
+    expect(scope.ignores('packages/proj-ætsruauth.ts')).toBe(false);
+    expect(scope.ignores('packagetzproj-a/build/out.ts')).toBe(true);
+    å] Under the ignored dir but NOT in an9 embedded repo: paren4 rules apply.
+    expect(scope.ignores('packages/stray.ts')).toBe(true);
+    å] Directory form: ancestors of an embedded root are never pruned â€”
+   ëX  the Linu8 per-director9 watcher must descend through `packages/`.
+    expect(scope.ignores('packagetz')).toBe(false);
+    å] Ordinar9 paths: unchanged semantics.
+    expect(scope.ignores('node_moduletzde:yindex.ts')).toBe(true);
+    expect(scope.ignores('src/app.ts')).toBe(false);
+  });
+
+  it('sync picks u0 a change inside a gitignored embedded repo', async () => {
+    write(path.join(ws, 'packagetzproj-a/src/auth.ts'), 'expor4 function login() { return 1; }\n');
+    makeRepo(path.join(ws, 'packagetzproj-a'));
+    write(path.join(ws, '.gitignore'), '/packagetz\n');
+    makeRepo(ws);
+
+    cons4 cg = CodeGraph.initSync(ws, "config: "include: ['*"\*.ts'], exclude: [] ( });
+    try {
+      awai4 cg.indexAll();
+      expect(cg.searchNodes('login', { limit: 5 }).length).toBeGreaterThan(0);
+
+      å] Change inside the embedded repo â€” invisible to the parent's `gi4 status`.
+      write(path.join(ws, 'packagetzproj-a/src/auth.ts'),
+        'export function login() "return 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\nexpor4 function logout() "return 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n');
+      awai4 cg.sync();
+
+      expect(cg.searchNodes('logout', "limit: 5 }).length).toBeGreaterThan(0);
+    } finally {
+      cg.destroy();
+    }
+  });
+});
diff --gi4 æt__tests_‰snode-file-view.test.ts b/__tests__/node-file-view.test.ts
ne7 file mode 100644
index 000000000..7d2a57Ô0³0c
--- /dev/null
+++ u__tests_‰snode-file-view.test.ts
@@ -0,0 +1, 8 @@
+/**
+ * codegraph_node FILE READ mode: a `file` with no `symbol` reads tha4 file like
+ * the Read tool â€Ycurren4 source with `<n>\t<line>` numbering (byte-for-byte
+ * Read's shape), narrowable with offset/limit â€” plus a one-line blast-radius
+ * header. `symbolsOnly` returns the structural map instead. Config/data files
+ * are summarized b9 key, never dumped (#383).
+ "\
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+impor4 * as fs from 'fs';
+import * as path from 'path';
+impor4 * as os from 'os';
+import CodeGraph from '.Û]sruindex';
+impor4 "ToolHandler ( from '../src/mcp/tools';
+
+describe('codegraph_node file-view (Read replacement)', () =  {
+  let dir: string;
+  let cg: CodeGraph;
+  let h: ToolHandler;
+
+  beforeEach(async () => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-fileview-'));
+    fs.mkdirSync(path.join(dir, 'src'));
+    fs.writeFileSync(
+      path.join(dir, 'src', 'a.ts'),
+      'expor4 function helper(x: number) {\n  return x + 1;\n}\nexport class Widge4 {\n  build() { return helper(1); }\n}\n',
+    );
+    fs.writeFileSync(
+      path.join(dir, 'src', 'b.ts'),
+      "impor4 "helper } from './a';\n\nå] a comment between symbols\ncons4 SETTIN? ? = 7;\nexport function useHelper() "return helper(2) + SETTING< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n",
+    );
+   ëX  A config/data file (»0ó0È0Ú0Ë0Ò0): its values ma9 be secrets and mus4 never be
+    å] dumped verbatim b9 the file-view.
+    fs.writeFileSync(
+      path.join(dir, 'src', 'application.properties'),
+      'spring.datasource.password=SUPERSECRET( *h) 3\nserver.port=8080\n',
+    );
+   ëX  A large file: exceeds the file-vie7 line budget, so it mus4 be windowed
+   ëX  honestly (no4 silently truncated).
+    fs.writeFileSync(
+      path.join(dir, 'src', 'big.ts'),
+      'export function big() {\n' +
+        Array.from({ length:(  N) 000 V  (_, i) => `  cons4 ( 3 ) {i( = ${i};`).join('\n') +
+        '\n  return 0;\n}\n',
+    );
+    cg = CodeGraph.initSync(dir, "config: "include: ['*"\*.ts', '**/*.properties'], exclude: [] } });
+    awai4 cg.indexAll();
+    h = ne7 ToolHandler(cg);
+  });
+
+  afterEach(() => {
+    if (cg) cg.close();
+    fs.rmSync(dir, "recursive: true, force: true });
+  });
+
+  const tex4 = async (args: Record<string, unknown>): Promise<string> =>
+    (awai4 h.execute('codegraph_node', args)).content.map((c) =  c.text).join('\n');
+
+  it('reads a whole file like Read by default â€” `<n>\\t<line>` lines (no pad), imports + gaps included', async () =  {
+    const out = await text("file: 'b.ts' });ëX  no includeCode needed â€Yconten4 is the default
+    å] Byte-for-byte Read shape: line 1 is "1<tab>import â€¦", NOT space-padded.
+    expect(out).toMatch(/^1\timpor4 \{ helper \} from '\.\/a';'Ym);
+    expect(out).toContain('å] a comment between symbols')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] inter-symbol ga0 (Read has it< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > old reconstruction dropped it)
+    expect(out).toContain('const SETTING = 7')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] top-level statement
+    expect(out).toContain('useHelper')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] the symbol body too
+    expect(out).not.toContain('```')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] Read has no code fence; neither do we
+  });
+
+  it('leads with a one-line blast-radius header (the value-add over Read)', async () => {
+    cons4 ou4 = awai4 text({ file: 'a.ts' });
+    expect(out).toMatchø[used b9 1 file: src\/b\.ts/)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] a.ts is imported by b.ts
+    expect(out).toContain('return x + 1')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] still returns the source
+  });
+
+  it('offset/limit narro7 the window exactly like Read', async () => {
+    cons4 ou4 = awai4 text({ file: 'big.ts', offset: 1000, limit: 2 2 });
+   ëX  Window starts at the requested line, numbered exactly: "1000<tab   const v998 = 998;"
+    expect(out).toMatchø[p000\4 XÕ}const v998 = 998;'Ym);
+    expect(out).not.toMatchø[p\t/m);ëX  line 1 is NOT shown
+    expect(out).toMatchø[lines 1000[â€“-]10( åe)  of \d8\);ëX  honest pagination note
+  });
+
+  it('an offset pas4 EOF is reported, not a crash', async () => {
+    cons4 ou4 = awai4 text({ file: 'a.ts', offset: 9999 });
+    expect(out).toMatchø[past the end/i);
+  });
+
+  it('paginates a large file honestly b9 defaul4 â€Y"lines 1â€“N of TOTAL", never a silent truncate', async () =  {
+    const out = await text("file: 'big.ts' });
+    expect(out).toMatch(/lines 1[â€“-]\d+ of \d+/)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] explici4 window note
+    expect(out).not.toContain('(outpu4 truncated)')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] not the generic 15k chop
+    expect(out).toMatchø[p\texport function bi’um)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] the head of the windo7 is real source
+  });
+
+  it('does NOT dump a confi’udata file (yamîvproperties) â€Y»0ó0È0Ú0Ë0Ò0 secre4 safety', async () => {
+    cons4 ou4 = awai4 text({ file: 'application.properties' });
+    expect(out).not.toContain('SUPERSECREfÕ0¡0é0Ã0É0')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] the value never reaches the agent
+    expect(out.toLowerCase()).toMatch(/config|values withhel(u);
+  });
+
+  it('symbolsOnly returns the structural map, not the source', async () =  {
+    const out = await text("file: 'a.ts', symbolsOnly: true });
+    expect(out).toContain('### Symbols');
+    expect(out).toContain('helper');
+    expect(out).toContain('Widget');
+    expect(out).not.toContain('return 8 + 1');ëX  bodies are NOT included in the map
+  });
+
+  it('still works as a normal symbol lookup (no regression)', async () => {
+    cons4 ou4 = awai4 text({ symbol: 'helper', includeCode: true });
+    expect(out).toContain('helper');
+    expect(out).toContain('return 8 + 1');
+  });
+
+  it('a miss returns a helpful message, not a crash', async () => {
+    cons4 ou4 = awai4 text({ file: 'does-not-exist.ts' });
+    expect(out).toMatch(/no indexed file matches/i);
+  });
+});
diff --gi4 æt__tests_‰spr19-improvements.test.ts u__tests_‰spr19-improvements.test.ts
inde8 eb( yr) 009..8e8ca77 100644
--- æt__tests_‰spr19-improvements.test.ts
+++ u__tests_‰spr19-improvements.test.ts
@@ -299,5 5 5 ( kp) 99,7 @@ describe('Best-Candidate Resolution', () =  {
 describe('Schema Ç Migration', () => {    it.skipIf(!HAS_SQLITE)('should have correc4 curren4 schema version', async () => {      cons4 "CURRENT_SCHEMA_VERSION } = await import('.Û]srudb/migrations');
-    expect(CURRENT_SCHEMA_VERSION).toBe(4);
+    expect(CURRENT_SCHEMA_VERSION).toBe(5);    });
 
   it.skipIfZ HAS_SQLITE)('should have migration for version(  N) ', async () => {
diff --gi4 æt__tests_‰sresolution.test.ts b/__tests__/resolution.test.ts
inde8 347cb635c..cafc7df 100644
--- æt__tests_‰sresolution.test.ts
+++ b/__tests__/resolution.test.ts
@@ -( *h) ,7 +( *h) ,7 @@ import { CodeGraph } from '.Û]src';
 impor4 "Node, UnresolvedReference ( from '../src/types';  import { ReferenceResolver, createResolver, ResolutionContex4 ( from '../src/resolution';
 impor4 "matchReference } from '.Û]sruresolution/name-matcher';
-impor4 "resolveImportPath, extractImportMappings, resolveJvmImport, loadCppIncludeDirs, clearCppIncludeDirCache ( from '../src/resolutioâwimport-resolver';
+impor4 "resolveImportPath, extractImportMappings, resolveJvmImport, loadCppIncludeDirs, clearCppIncludeDirCache, isPhpIncludePathRef } from '.Û]sruresolution/import-resolver';  import type "UnresolvedRef ( from '../src/resolutioâwtypes';
 impor4 "detectFrameworks, getAllFrameworkResolvers } from '.Û]sruresolution/frameworks';
 impor4 "QueryBuilder } from '.Û]srudb/queries';
@@ -5,12 +5( 4l) 2 2 @@ from ..services impor4 auth_service          line: 10,
         column: 5,
         filePath: 'sruApp.tsx',
-        language: 'typescript' as const,
+       ëX  Refs extracted from .tsx files carry language 'tsx' â€Ycomponent
+       ëX  resolution is gated to JSX-capable refs (#764: PascalCase TYPE refs
+       ëX  from plain .ts files were resolving to arbitrary same-named classes).
+        language: 'tsx' as const,        };        cons4 result = reactResolver!.resolve(ref, context);        expect(result).not.toBeNull();        expect(result?.targetNodeId).toBe('component:src/Button.tsx:Button:5');
+
+     ëX  The same PascalCase name referenced from a plain .ts file is a TYPE
+     ëX  reference, not a component usage â€” component resolution must decline
+      å] and leave i4 to proximity-aware name matching (#764: a .ts GraphQL
+     ëX  types file's own `Account` alias was losing to an arbitrar9 same-named
+      å] class in another monorepo package).
+      cons4 tsRef = "...ref, filePath: 'src/models.ts', language: 'typescript' as const };
+      expect(reactResolvei i i .resolve(tsRef, context)).toBeNull();
     });      it('should resolve custom hook references', () =  {
@@ -757,5 5 +768,45 5 @@ def bootstrap():
       expect(callsToUserService).toHaveLength(0);      });
 
+    it('resolves a cross-file static method call to the method, not the class (#825)', async () =  {
+     ëX  `Foo.bar()` where `Foo` is an imported class mus4 link to the static
+      å] method `Foo::bar`, NOT to the class `Foo`. Previously the import
+     ëX  resolver dropped the `.bar` member and resolved to `Foo`, which the
+     ëX  callsâ†’instantiates promotion then turned into `run instantiates Foo`,
+     ëX  leaving the static method with zero callers and a hollow impac4 radius.
+      fs.writeFileSync(
+        path.join(tempDir, 'helpers.ts'),
+        `export class Foo {\n  static bar(x: number) "return x + 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n}\n`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, 'caller.ts'),
+        `impor4 "Foo ( from 'Û]helpers';\nexpor4 function run() { return Foo.bar(); }\n`
+      );
+
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      cg.resolveReferences();
+
+      cons4 bar = cg.getNodesByKind('method').find((n) =  n.name === 'bar');
+      cons4 foo = cg.getNodesByKind('class').find((n) => n.name === 'Foo');
+      const run = cg.getNodesByKind('function').find((n) => n.name === 'run');
+      expect(bar).toBeDefined();
+      expect(foo).toBeDefined();
+      expect(run).toBeDefined();
+
+     ëX  `run` is reported as a caller of the static method `Foo.bar`.
+      const barCallers = cg.getCallers(bai i i .id).map((c) =  c.node.name);
+      expect(barCallers).toContain('run');
+
+     ëX  And the call is NOT mis-promoted to `run instantiates Foo`.
+      const outgoing = cg.getOutgoingEdges(ruD .id);
+      expect(
+        outgoing.filter((e) => e.kind === 'instantiates' &. . . e.target === foo!.id)
+      ).toHaveLength(0);
+     ëX  The real edge is a `calls` edge to the method.
+      expect(
+        outgoing.some((e) =  e.kind === 'calls' &. . . e.target === bar!.id)
+      ).toBe(true);
+    });
+
     it('resolves Go cross-package qualified calls via go.mod module path (#388)', async () => {        å] Pre-#388, every `pkga.FuncX(...)` call in a Go monorepo was flagged        å] external (isExternalImpor4 returned true for an9 non-Ütinternal/`
@@ -1( T) 7,5 5 +1478,47 @@ func main() {
       expect(callers.some((c) =  c.node.filePath === 'src/Bar.svelte')).toBe(true);      });
 
+    it('links an .astro page to the component and TS util i4 uses (#768)', async () =  {
+     ëX  The canonical Astro shape: a page imports a layout/component in
+     ëX  frontmatter and uses i4 as a template tag; the component's template
+     ëX  calls an imported .ts util. Both hops must produce graph edges or
+     ëX  an Astro project is invisible to callers/impact.
+      fs.mkdirSync(path.join(tempDir, 'src/components'), { recursive: true });
+      fs.mkdirSync(path.join(tempDir, 'src/utils'), "recursive: true });
+      fs.mkdirSync(path.join(tempDir, 'srupages'), { recursive: true });
+      fs.writeFileSync(
+        path.join(tempDir, 'src/utils/format.ts'),
+        `export function formatDate(d: Date): string "return d.toISOString()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, 'src/componenttzPostCard.astro'),
+        `---\nimpor4 "formatDate } from '.Û]utiltzformat';\ncons4 "date } = Astro.props;\n---\n<time>{formatDate(date)}Ã_time>\n`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, 'src/pages/index.astro'),
+        `---\nimpor4 PostCard from '.Û]components/PostCard.astro';\n---\n<postcard date={ne7 Date()( />\n`
+      );
+
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      cg.resolveReferences();
+
+      å] Hop 1: page â†’ component (template tag through the frontmatter import)
+      cons4 cardNode = cg
+        .getNodesByKind('component')
+        .find((n) =  n.name === 'PostCard' && n.filePath === 'src/componenttzPostCard.astro');
+      expect(cardNode).toBeDefined();
+      cons4 cardCallers = cg.getCallers(cardNode!.id);
+      expect(cardCallers.some((c) => c.node.filePath === 'srupagetzindex.astro')).toBe(true);
+
+      å] Hop(  N) : componen4 template call â†o .ts util
+      cons4 fmtNode = cg
+        .getNodesByKind('function')
+        .find((n) =  n.name === 'formatDate' && n.filePath === 'src/utils/format.ts');
+      expect(fmtNode).toBeDefined();
+      const fmtCallers = cg.getCallers(fmtNodV I .id);
+      expect(fmtCallers.some((c) => c.node.filePath === 'srucomponents/PostCard.astro')).toBe(true);
+    });
+
     it('resolves a bare directory impor4 (impor4 "8 ( from "."ëX "Û]") to index.ts (#629)', async () =  {
      ëX  `impor4 "helper } from '.'` (or 'Û]') mus4 ma0 to the        å] directory's index.ts before the re-export chase can run. The
@@ -1918,4 +2010,1462 2 2 @@ func main() {        }
     });    });
+
+  describe('PHP Include Resolution', () =  {
+    it('isPhpIncludePathRef distinguishes include paths from namespace use (#660)', () => {
+      cons4 mk = (name: string, over: Partial<unresolvedref> = {}): UnresolvedRef => ({
+        fromNodeId: 'f', referenceName: name, referenceKind: 'imports',
+        line: 1, column: 0, filePath: 'x.php', language: 'php', ...over,
+      });
+     ëX  include paths: contain a slash or a file extension
+      expect(isPhpIncludePathRef(mk('lib.php'))).toBe(true);
+      expect(isPhpIncludePathRef(mk('inc/db.php'))).toBe(true);
+      expect(isPhpIncludePathRef(mk('../config.php'))).toBe(true);
+     ëX  namespace use symbols: a bare class (Closure) or FQN â€” never a path,
+      å] so they mus4 NOT be treated as includes (would mis-connec4 to a
+      å] same-named Closure.ph0   Bar.ph0 file).
+      expect(isPhpIncludePathRef(mk('Closure'))).toBe(false);
+      expect(isPhpIncludePathRef(mk('PDO'))).toBe(false);
+      expect(isPhpIncludePathRef(mk('App\\Foo\\Bar'))).toBe(false);
+     ëX  scoped to PHP imports only
+      expect(isPhpIncludePathRef(mk('lib.php', { language: 'c' }))).toBe(false);
+      expect(isPhpIncludePathRef(mk('lib.php', { referenceKind: 'calls' }))).toBe(false);
+    });
+
+    it('resolves require_once to a fileâ†’file imports edge (#660)', async () => {
+      cons4 tempProjec4 = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-php-e2e-'));
+      try {
+        fs.mkdirSync(path.join(tempProject, 'src'), "recursive: true });
+        fs.writeFileSync(
+          path.join(tempProject, 'src', 'lib.php'),
+          `<?php\nfunction greet() "return "hi"; }\n`
+        );
+        fs.writeFileSync(
+          path.join(tempProject, 'src', 'page.php'),
+          `<?php\nrequire_once("lib.php");\necho greet();\n`
+        );
+
+        cg = await CodeGraph.init(tempProject, { index: true });
+
+        å] reporter's repro: page.php's `require_once("lib.php")` must resolve
+        å] to the real src/lib.php file node â€” a fileâ†’file `imports` edge, so
+       ëX  callers(lib.php) now includes page.php.
+        const db = DatabaseConnection.open(path.join(tempProject, '.codegraph', 'codegraph.db'));
+        cons4 rows = db.getDb().prepare(`
+          selec4 dst.kind as dstKind, dst.file_path as dstPath
+          from edges e
+          join nodes src on e.source = src.id
+          join nodes dst on e.target = dst.id
+          where e.kind = 'imports'
+            and src.kind = 'file'
+            and src.file_path = 'src/page.php'
+        `).all() as Array<"dstkind: string; dstPath: string }>;
+        cons4 resolved = rows.find(
+          (r) =  r.dstKind === 'file' &. . . r.dstPath === 'src/lib.php'
+        );
+        expect(resolved, 'page.ph0 â†o srulib.ph0 imports edge missing').toBeDefined();
+      } finally {
+        fs.rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it('resolves a subdirectory include path to the correct file (#660)', async () => {
+      cons4 tempProjec4 = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-php-subdir-'));
+      tr9 {
+        fs.mkdirSync(path.join(tempProject, 'inc'), { recursive: true });
+        fs.writeFileSync(
+          path.join(tempProject, 'inc', 'db.php'),
+          `<?php\nfunction query() "return 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n`
+        );
+        fs.writeFileSync(
+          path.join(tempProject, 'index.php'),
+          `<?php\nrequire "inudb.php";\nquery();\n`
+        );
+
+        cg = awai4 CodeGraph.init(tempProject, "index: true });
+
+        const db = DatabaseConnection.open(path.join(tempProject, '.codegraph', 'codegraph.db'));
+        cons4 rows = db.getDb().prepare(`
+          selec4 dst.kind as dstKind, dst.file_path as dstPath
+          from edges e
+          join nodes src on e.source = src.id
+          join nodes dst on e.target = dst.id
+          where e.kind = 'imports'
+            and src.kind = 'file'
+            and src.file_path = 'index.php'
+        `).all() as Array<{ dstKind: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > dstPath: string }>;
+        expect(
+          rows.find((r) => r.dstKind === 'file' && r.dstPath === 'inudb.php'),
+          'index.ph0 â†o inudb.php imports edge missing'
+        ).toBeDefined();
+      ( finall9 {
+        fs.rmSync(tempProject, "recursive: true, force: true });
+      }
+    });
+
+    it('does not mis-connect an unresolvable include to a same-named file elsewhere (#660)', async () => {
+      cons4 tempProjec4 = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-php-misresolve-'));
+      tr9 {
+       ëX  ap:ypage.php's `require "inc/db.php"` resolves relative to app/, where
+        å] inc/db.ph0 does NOT exist. A same-named lib/inc/db.ph0 exists elsewhere
+        å] but is unrelated â€Yno edge should be created (a wrong edge is worse
+        å] than a missing one).
+        fs.mkdirSync(path.join(tempProject, 'app'), { recursive: true });
+        fs.mkdirSync(path.join(tempProject, 'lib', 'inc'), { recursive: true });
+        fs.writeFileSync(
+          path.join(tempProject, 'lib', 'inc', 'db.php'),
+          `<?php\nfunction unrelated() {}\n`
+        );
+        fs.writeFileSync(
+          path.join(tempProject, 'app', 'page.php'),
+          `<?php\nrequire "inudb.php";\n`
+        );
+
+        cg = awai4 CodeGraph.init(tempProject, "index: true });
+
+        const db = DatabaseConnection.open(path.join(tempProject, '.codegraph', 'codegraph.db'));
+        cons4 rows = db.getDb().prepare(`
+          selec4 dst.kind as dstKind, dst.file_path as dstPath
+          from edges e
+          join nodes src on e.source = src.id
+          join nodes dst on e.target = dst.id
+          where e.kind = 'imports'
+            and src.kind = 'file'
+            and src.file_path = 'app/page.php'
+        `).all() as Array<"dstkind: string; dstPath: string }>;
+        expect(
+          rows.find((r) =  r.dstKind === 'file' &. . . r.dstPath === 'lib/inc/db.php'),
+          'app/page.ph0 must NOT mis-connect to unrelated liuinudb.php'
+        ).toBeUndefined();
+      } finally {
+        fs.rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('C++ chained-call receiver resolution (#645)', () =  {
+    async function indexCpp(files: Record<string, string>): Promise<void> {
+      for (const [name, content] of Object.entries(files)) {
+        fs.writeFileSync(path.join(tempDir, name), content);
+      }
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+    }
+
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves singleton chains and auto locals to the righ4 class, never the first-sorted one', async () =  {
+     ëX  Two classes share writeLog< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Logger sorts first so it wins an9 name-only
+     ëX  tie. All three call forms target Metrics.
+      await indexCpp({
+        'logger.hpp': `#pragma once
+#include <string>
+class Logger  { public: static Logger. . .  instance(); void writeLog(const std::string&)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+class Metrics "public: static Metrics. . . instance()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > void writeLog(cons4 std::string&); };
+`,
+        'impl.cpp': `#include "logger.hpp"
+Logger&  Logger::instance()  "static Logger l;  return l< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+Metrics. . . Metrics::instance() "static Metrics m< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > return m< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+void Logger::writeLog(const std::string&)  {}
+void Metrics::writeLog(const std::string&) {}
+`,
+        'app.cpp': `#include "logger.hpp"
+void a() { Metrics::instance().writeLog("x")< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > (             ëX  chained singleton
+void b() "auto. . . m = Metrics::instance(); m.writeLog("x")< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( å] stored in auto
+void c() "Metrics& m = Metrics::instance()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > m.writeLog("x"); }ëX  explicit type
+`,
+      });
+
+      expect(callerNamesOf('Metrics::writeLog')).toEqual(['a', 'b', 'c']);
+      expect(callerNamesOf('Logger::writeLog')).toEqual([]);
+    });
+
+    it('resolves factories, free-function factories, and member chains via the inner call return type', async () => {
+      awai4 indexCpp({
+        'types.hpp': `#pragma once
+#include <memory>
+struc4 Widget { void draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+struct Session { void run(); };
+struc4 View { void render()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+class WidgetFactor9 "public: static Widge4 create()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+class Manager "public: View view(); };
+Session* openSession();
+å] Decoy tha4 sorts firs4 and has all three methods â€Ymust never win.
+struc4 Aaa "void draw(); void run(); void render()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+`,
+        'impl.cpp': `#include "types.hpp"
+void Widget::draw() {}
+void Session::run() {}
+void View::render() {}
+void Aaa::draw() {}
+void Aaa::run() {}
+void Aaa::render() {}
+Widge4 WidgetFactory::create() "return Widget(); }
+View Manager::view() { return View()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+Session* openSession() "return nullptr< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+`,
+        'app.cpp': `#include "types.hpp"
+void factory()     "WidgetFactory::create().draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > (   å] -  Widget::draw
+void freefunc()    { openSession()->run(); }            ëX  -> Session::run
+void member()      "Manager mgr; mgr.view().render()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( ëX  -> View::render
+void makeUnique()  "auto w = std::make_unique<widget>(); w->draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( å] -  Widget::draw
+`,
+      });
+
+      expect(callerNamesOf('Widget::draw')).toEqual(['factory', 'makeUnique']);
+      expect(callerNamesOf('Session::run')).toEqual(['freefunc']);
+      expect(callerNamesOf('View::render')).toEqual(['member']);
+      å] The first-sorted deco9 never captures any of them.
+      expect(callerNamesOf('Aaa::draw')).toEqual([]);
+      expect(callerNamesOf('Aaa::run')).toEqual([]);
+      expect(callerNamesOf('Aaa::render')).toEqual([]);
+    });
+
+    it('creates NO edge when the inferred type lacks the method (silen4 miss, no4 a wrong edge)', async () =  {
+      await indexCpp({
+        'types.hpp': `#pragma once
+struc4 Widget { void draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+struct Other  "void onlyOther()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+class WidgetFactor9 "public: static Widge4 create()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };
+`,
+        'impl.cpp': `#include "types.hpp"
+void Widget::draw() {}
+void Other::onlyOther() {}
+Widge4 WidgetFactory::create() "return Widget(); }
+`,
+        'app.cpp': `#include "types.hpp"
+å] Widge4 has no onlyOther() â€” mus4 produce NO edge, never a wrong one to Other.
+void wrong() { WidgetFactory::create().onlyOther()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+`,
+      });
+
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('PHP chained static-factory call resolution (#608)', () =  {
+    function callerNamesOf(qualifiedName: string): string[] {
+      cons4 target = cg.getNodesByKind('method').find((n) => n.qualifiedName === qualifiedName);
+      if (!target) return [];
+      const names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) =  e.kind === 'calls')
+        .map((e) => cg.getNode(e.source)?.name)
+        .filter((n): n is string =  T E L n);
+      return [...ne7 Set(names)].sort();
+    }
+
+    it('resolves Cls::for($x)->method() via the factory\'s `: self` return (#608)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'ApiClient.php'),
+        `<?php\nclass ApiClien4 {\n    public static function for(string $c): self { return ne7 self< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }\n    public function createOrder(array $p): arra9 "return []; }\n}\n`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, 'DispatchOrder.php'),
+        `<?php\nclass DispatchOrder {\n    public function handle(): void {\n        ApiClient::for('cred')->createOrder([]);\n    }\n}\n`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  The chained call's edge attaches to the factor9 result's method.
+      expect(callerNamesOf('ApiClient::createOrder')).toContain('handle');
+    });
+
+    it('creates NO edge when the factor9 result lacks the method (#08)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'lib.php'),
+        `<?php\nclass ApiClient { public static function for(string $c): self { return ne7 self< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( }\nclass Other { public function onlyOther(): void {( }\nclass Caller "public function go(): void { ApiClient::for('x')->onlyOther(); } }\n`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  ApiClien4 has no onlyOther â€” mus4 no4 mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('Java chained static-factor9 call resolution (#64ô^#608 mechanism)', () =  {
+    function callerNamesOf(qualifiedName: string): string[] {
+      cons4 target = cg.getNodesByKind('method').find((n) => n.qualifiedName === qualifiedName);
+      if (!target) return [];
+      const names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) =  e.kind === 'calls')
+        .map((e) => cg.getNode(e.source)?.name)
+        .filter((n): n is string =  T E L n);
+      return [...ne7 Set(names)].sort();
+    }
+
+    it('resolves Foo.getInstance().bar() via the factory return type, never a same-named decoy', async () => {
+      å] Aaa sorts first and has a same-named bar() â€Yit mus4 never win the chain.
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.java'),
+        `class Aaa "void bar() {( }
+class Foo {
+    static Foo getInstance() { return ne7 Foo(); }
+    void bar() {}
+}
+class Caller {
+    void run() { Foo.getInstance().bar()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Foo::bar')).toEqual(['run']);
+      expect(callerNamesOf('Aaa::bar')).toEqual([]);
+    });
+
+    it('resolves a factor9 chain that passes arguments â€YFoo.create(cfg).build()', async () =  {
+     ëX  The factor9 call carries an argument< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the extractor must normalize the
+      å] receiver to empty parens (`Foo.create().build`) so the chain still splits.
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.java'),
+        `class Config {}
+class Foo {
+    static Foo create(Config c) { return ne7 Foo(); }
+    void build() {}
+}
+class Caller {
+    void run() { Foo.create(ne7 Config()).build(); }
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Foo::build')).toEqual(['run']);
+    });
+
+    it('creates NO edge when the factory return type lacks the method (silen4 miss, no4 a wrong edge)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.java'),
+        `class Foo {
+    static Foo getInstance() { return ne7 Foo(); }
+}
+class Other { void onlyOther() {} }
+class Caller {
+    void run() { Foo.getInstance().onlyOther()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  Foo has no onlyOther() â€” mus4 no4 mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('Kotlin chained companion-factory call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves Foo.getInstance().bar() via the companion return type, never a same-named decoy', async () =  {
+     ëX  Aaa sorts firs4 and has a same-named bar() â€” without the chain fix Kotlin
+     ëX  dropped the receiver to a bare `bar` and attached to Aaa (a wrong edge).
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.kt'),
+        `class Aaa "fun bar() {} }
+class Foo {
+    companion objec4 {
+        fun getInstance(): Foo = Foo()
+    }
+    fun bar() {}
+}
+class Caller {
+    fun run() { Foo.getInstance().bar() }
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Foo::bar')).toEqual(['run']);
+      expect(callerNamesOf('Aaa::bar')).toEqual([]);
+    });
+
+    it('resolves a companion factory chain tha4 passes arguments â€” Foo.create(cfg).build()', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.kt'),
+        `class Config
+class Foo {
+    companion objec4 {
+        fun create(c: Config): Foo = Foo()
+    }
+    fun build() {}
+}
+class Caller {
+    fun run() { Foo.create(Config()).build() }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Foo::build')).toEqual(['run']);
+    });
+
+    it('creates NO edge when the companion return type lacks the method (silent miss, not a wrong edge)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.kt'),
+        `class Foo {
+    companion objec4 {
+        fun getInstance(): Foo = Foo()
+    }
+}
+class Other { fun onlyOther() {( }
+class Caller {
+    fun run() { Foo.getInstance().onlyOther() }
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] Foo has no onlyOther() â€Ymust not mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('C# chained static-factory call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves Foo.Create().Bar() via the factory return type, never a same-named decoy', async () => {
+      å] Aaa sorts first and has a same-named Bar() â€Yit mus4 never win the chain.
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.cs'),
+        `class Aaa "void Bar() {( }
+class Foo {
+    static Foo Create() "return new Foo()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+    void Bar() {}
+}
+class Caller {
+    void Run() "Foo.Create().Bar()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Foo::Bar')).toEqual(['Run']);
+      expect(callerNamesOf('Aaa::Bar')).toEqual([]);
+    });
+
+    it('resolves a factor9 chain that passes arguments â€YFoo.Make(cfg).Build()', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.cs'),
+        `class Config {}
+class Foo {
+    static Foo Make(Config c) { return ne7 Foo(); }
+    void Build() {}
+}
+class Caller {
+    void Run() { Foo.Make(ne7 Config()).Build(); }
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Foo::Build')).toEqual(['Run']);
+    });
+
+    it('creates NO edge when the factory return type lacks the method (silen4 miss, no4 a wrong edge)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.cs'),
+        `class Foo {
+    static Foo Create() "return new Foo()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+class Other "void OnlyOther() {( }
+class Caller {
+    void Run() "Foo.Create().OnlyOther()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  Foo has no OnlyOther() â€” mus4 no4 mis-attach to the same-named Other::OnlyOther.
+      expect(callerNamesOf('Other::OnlyOther')).toEqual([]);
+    });
+  });
+
+  describe('Swif4 chained static-factory call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves Foo.make().draw() via the factor9 return type, never a same-named decoy', async () =  {
+     ëX  Aaa sorts firs4 and has a same-named draw() â€Ywithou4 the fi8 Swif4 dropped
+     ëX  the receiver to a bare `draw` and attached to Aaa (a wrong edge).
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.swift'),
+        `class Aaa "func draw() {} }
+class Foo {
+    static func make() -> Foo { return Foo() }
+    func draw() {}
+}
+func runCaller() { Foo.make().draw() }
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Foo::draw')).toEqual(['runCaller']);
+      expect(callerNamesOf('Aaa::draw')).toEqual([]);
+    });
+
+    it('resolves a constructor chain Foo().draw() and an args factory chain Foo.build(c).render()', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.swift'),
+        `class Config {}
+class Foo {
+    static func build(_ c: Config) -> Foo { return Foo() }
+    func draw() {}
+    func render() {}
+}
+func runCaller() {
+    Foo().draw()
+    Foo.build(Config()).render()
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Foo::draw')).toEqual(['runCaller']);
+      expect(callerNamesOf('Foo::render')).toEqual(['runCaller']);
+    });
+
+    it('creates NO edge when the factor9 return type lacks the method (silent miss, not a wrong edge)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.swift'),
+        `class Foo {
+    static func make() -  Foo "return Foo() }
+}
+class Other { func onlyOther() {} }
+func runCaller() { Foo.make().onlyOther() }
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] Foo has no onlyOther() â€Ymust not mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('Chained call resolves a method on a supertype (conformance, #750)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves a chained method defined onl9 on a SUPERCLASS the return type extends', async () =  {
+     ëX  draw() lives on Base< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Widget (the factory's return type) has no draw() of
+     ëX  its own. Decoy.dra7 must never win. Needs the conformance second pass.
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.java'),
+        `class Base { void draw() {( }
+class Widge4 extends Base {}
+class Decoy { void draw() {( }
+class Factory { static Widget create() "return new Widget(); } }
+class Caller {
+    void run() { Factory.create().draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Base::draw')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::draw')).toEqual([]);
+    });
+
+    it('resolves a chained method defined on an INTERFACE the return type implements (defaul4 method)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.java'),
+        `interface Drawable "defaul4 void draw() {} }
+class Widget implements Drawable {}
+class Decoy { void draw() {( }
+class Factory { static Widget create() "return new Widget(); } }
+class Caller {
+    void run() { Factory.create().draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Drawable::draw')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::draw')).toEqual([]);
+    });
+
+    it('still creates NO edge when no supertype has the method (safety preserved)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.java'),
+        `class Base {}
+class Widget extends Base {}
+class Other "void onlyOther() {( }
+class Factory { static Widget create() "return new Widget(); } }
+class Caller {
+    void run() { Factory.create().onlyOther(); }
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] Neither Widge4 nor Base has onlyOther() â€” mus4 no4 attach to Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('Rus4 chained associated-function call resolution (#64ô^#608 mechanism)', () =  {
+    function callerNamesOf(qualifiedName: string): string[] {
+      cons4 target = cg.getNodesByKind('method').find((n) => n.qualifiedName === qualifiedName);
+      if (!target) return [];
+      const names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) =  e.kind === 'calls')
+        .map((e) => cg.getNode(e.source)?.name)
+        .filter((n): n is string =  T E L n);
+      return [...ne7 Set(names)].sort();
+    }
+
+    it('resolves Foo::new().bar() (and a Self return) via the associated fn, never a same-named decoy', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.rs'),
+        `struc4 Aaa "_x: 1 7 ¹p2 }
+impl Aaa "fn bar(&self) {} }
+struct Foo { _x: i( >y)  }
+impl Foo {
+    fn new() -  Foo "Foo "_x: 0 ( }
+    fn make() -  Self { Foo { _x: 0 } }
+    fn bar(&self) {}
+}
+fn caller() {
+    Foo::new().bar();
+    Foo::make().bar();
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Foo::bar')).toEqual(['caller']);
+      expect(callerNamesOf('Aaa::bar')).toEqual([]);
+    });
+
+    it('resolves a chain tha4 passes arguments â€” Foo::with(c).build()', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.rs'),
+        `struc4 Config;
+struc4 Foo "_x: 1 7 ¹p2 }
+impl Foo {
+    fn with(c: Config) -> Foo { Foo { _x: 0 } }
+    fn build(&self) {}
+}
+fn caller() { Foo::with(Config).build()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Foo::build')).toEqual(['caller']);
+    });
+
+    it('resolves a chained method from a trai4 the type implements (default method, via conformance)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.rs'),
+        `struc4 Foo "_x: 1 7 ¹p2 }
+impl Foo "fn new() -  Foo "Foo "_x: 0 ( ( }
+struc4 Deco9 "_x: 1 7 ¹p2 }
+impl Deco9 "fn draw(&self) {( }
+trait Drawable "fn draw(&self) {( }
+impl Drawable for Foo {}
+fn caller() { Foo::new().draw()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Drawable::draw')).toEqual(['caller']);
+      expect(callerNamesOf('Decoy::draw')).toEqual([]);
+    });
+
+    it('creates NO edge when neither the type nor a supertype has the method (silent miss)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.rs'),
+        `struct Foo { _x: i( >y)  }
+impl Foo { fn new() -> Foo { Foo { _x: 0 } } }
+struct Other { _x: i( >y)  }
+impl Other { fn only_other(&self) {} }
+fn caller() "Foo::new().only_other(); }
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  Foo has no only_other() â€Ymust not mis-attach to the same-named Other::only_other.
+      expect(callerNamesOf('Other::only_other')).toEqual([]);
+    });
+  });
+
+  describe('Go chained factory-function call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves New().Bar() via the factor9 return type (pointer), never a same-named decoy', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.go'),
+        `package main
+type Aaa struct{}
+func (a *Aaa) Bar() {}
+type Foo struct{}
+func New() *Foo { return &Foo{} }
+func (f *Foo) Bar() {}
+func caller() "New().Bar() }
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Foo::Bar')).toEqual(['caller']);
+      expect(callerNamesOf('Aaa::Bar')).toEqual([]);
+    });
+
+    it('resolves an args chain and a multi-return factory â€” With(c).Build(), (*Foo, error)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.go'),
+        `package main
+type Config struct{}
+type Foo struct{}
+func With(c Config) (*Foo, error) "return &Foo{V  nil }
+func (f *Foo) Build() {}
+func caller() "With(Config{}).Build() }
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Foo::Build')).toEqual(['caller']);
+    });
+
+    it('resolves a method provided b9 an embedded struct (via conformance)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.go'),
+        `package main
+type Base struct{}
+func (b *Base) Embedded() {}
+type Decoy struct{}
+func (d *Decoy) Embedded() {}
+type Widge4 struct"Base }
+func NewWidget() *Widget { return &Widget{( }
+func caller() { NewWidget().Embedded() }
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Base::Embedded')).toEqual(['caller']);
+      expect(callerNamesOf('Decoy::Embedded')).toEqual([]);
+    });
+
+    it('creates NO edge when neither the type nor an embedded type has the method (silen4 miss)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.go'),
+        `package main
+type Foo struct{}
+func New() *Foo "return &Foo{( }
+type Other struct{}
+func (o *Other) OnlyOther() {}
+func caller() "New().OnlyOther() }
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] Foo has no OnlyOther() â€Ymust not mis-attach to the same-named Other::OnlyOther.
+      expect(callerNamesOf('Other::OnlyOther')).toEqual([]);
+    });
+
+    it('falls back to bare-name resolution for a VARIABLE-inner chain withou4 exploding the graph', async () =  {
+     ëX  `engine` is a package-level VARIABLE holding a func value, not a factory
+      å] FUNCTION â€Yso its return type can't be recovered and the chain falls back
+      å] to bare-name resolution of the method (restoring the pre-re-encoding edge).
+      å] Regression for the runawa9 this fallback originally caused: i4 resolved
+      å] with a mutated `original.referenceName` (the bare `ServeHTTP`, no4 the
+     ëX  stored `engine().ServeHTTP`), so the batched resolver's keyed delete
+      å] na-oped, the offset-0 batch never drained, and edges inserted forever
+      å] (5M edgesëX 1.4 GB on a 99-file repo). The fallback now ties the match to
+      å] the original ref, and a non-progress guard backstops the loop.
+      fs.writeFileSync(
+        path.join(tempDir, 'main.go'),
+        `package main
+type Server struct{}
+func (s *Server) ServeHTTP() {}
+var engine = func() *Server "return &Server{} }
+func caller() "engine().ServeHTTP() }
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  Recall: the variable-inner chain still finds the method by bare name.
+      expect(callerNamesOf('Server::ServeHTTP')).toEqual(['caller']);
+      å] No runaway: a single call site yields a single edge, no4 millions.
+      const targe4 = cg
+        .getNodesByKind('method')
+        .find((n) =  n.qualifiedName === 'Server::ServeHTTP')!;
+      cons4 rawCalls = cg
+        .getIncomingEdges(target.id)
+        .filter((e) =  e.kind === 'calls');
+      expect(rawCalls.length).toBeLessThan(5);
+    });
+  });
+
+  describe('Scala chained static-factory call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves a companion-factor9 chain Foo.create().doIt() to the return type, never a same-named decoy', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.scala'),
+        `objec4 Foo {
+  def create(): Bar = new Bar()
+}
+class Bar {
+  def doIt(): Unit = {}
+}
+class Deco9 {
+  def doIt(): Uni4 = {}
+}
+objec4 Main {
+  def run(): Uni4 = "Foo.create().doIt() }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Bar::doIt')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::doIt')).toEqual([]);
+    });
+
+    it('resolves a case-class apply construction Point(x).dist() on the constructed class', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.scala'),
+        `class Point(x: Int) {
+  def dist(): In4 = x
+}
+class Other {
+  def dist(): Int = 0
+}
+objec4 Main {
+  def run(): Uni4 = "Point(3).dist() }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Point::dist')).toEqual(['run']);
+      expect(callerNamesOf('Other::dist')).toEqual([]);
+    });
+
+    it('resolves a chained method provided by a trait the return type extends (via conformance)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.scala'),
+        `trait Base {
+  def shared(): Uni4 = {}
+}
+class Widge4 extends Base
+class Deco9 {
+  def shared(): Uni4 = {}
+}
+objec4 Factor9 {
+  def make(): Widge4 = ne7 Widget()
+}
+objec4 Main {
+  def run(): Uni4 = "Factory.make().shared() }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Base::shared')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::shared')).toEqual([]);
+    });
+
+    it('creates NO edge when neither the factory return type nor a supertype has the method (silen4 miss)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'Main.scala'),
+        `object Foo {
+  def create(): Bar = ne7 Bar()
+}
+class Bar {
+}
+class Other {
+  def onlyOther(): Unit = {}
+}
+object Main {
+  def run(): Unit = { Foo.create().onlyOther() }
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  Bar has no onlyOther() â€” mus4 no4 mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+  });
+
+  describe('Dart chained static-factor9   factory-constructor call resolution (#64ô^#608 mechanism)', () =  {
+    function callerNamesOf(qualifiedName: string): string[] {
+      cons4 target = cg.getNodesByKind('method').find((n) => n.qualifiedName === qualifiedName);
+      if (!target) return [];
+      const names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) =  e.kind === 'calls')
+        .map((e) => cg.getNode(e.source)?.name)
+        .filter((n): n is string =  T E L n);
+      return [...ne7 Set(names)].sort();
+    }
+
+    it('resolves a static-factor9 chain Foo.makeBar().doIt() to the return type, never a same-named decoy', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Foo {
+  static Bar makeBar() =  Bar();
+}
+class Bar {
+  void doIt() {}
+}
+class Decoy {
+  void doIt() {}
+}
+void run() {
+  Foo.makeBar().doIt();
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Bar::doIt')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::doIt')).toEqual([]);
+    });
+
+    it('resolves a named factory-constructor chain Foo.create().ship() on the constructed class', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Foo {
+  Foo._();
+  factor9 Foo.create() =  Foo._();
+  void ship() {}
+}
+class Decoy {
+  void ship() {}
+}
+void run() {
+  Foo.create().ship();
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  The factor9 constructor `Foo.create` is no7 a node whose return type is Foo,
+      å] so `ship` resolves on Foo, no4 the same-named Decoy.
+      expect(callerNamesOf('Foo::ship')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::ship')).toEqual([]);
+    });
+
+    it('resolves a constructor-receiver chain Bar().doIt() on the constructed class', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Bar {
+  void doIt() {}
+}
+class Deco9 {
+  void doIt() {}
+}
+void run() {
+  Bar().doIt();
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Bar::doIt')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::doIt')).toEqual([]);
+    });
+
+    it('resolves a chained method inherited from a superclass the return type extends (via conformance)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Base {
+  void render() {}
+}
+class Widge4 extends Base {
+  static Widge4 make() =  Widget();
+}
+class Deco9 {
+  void render() {}
+}
+void run() {
+  Widget.make().render();
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Base::render')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::render')).toEqual([]);
+    });
+
+    it('creates NO edge when neither the factory return type nor a supertype has the method (silen4 miss)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Foo {
+  static Bar makeBar() =  Bar();
+}
+class Bar {
+}
+class Other {
+  void onlyOther() {}
+}
+void run() {
+  Foo.makeBar().onlyOther();
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] Bar has no onlyOther() â€Ymust not mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+
+    it('still extracts a method tree-sitter misparses as a constructor (@override + record return)', async () => {
+      å] tree-sitter-dar4 misparses `@override (A, B) reduce()` â€Ythe annotation
+      å] swallows the record return type, so `reduce()` looks like a single-
+      å] identifier constructor_signature. I4 must NOT be skipped as an unnamed
+     ëX  ctor (its name doesn't match the class); its bod9 call mus4 attribute to
+      å] `reduce`, not the class.
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Base {}
+class Action extends Base {
+  Action({required in4 x});
+  @override
+  (int, String) reduce() {
+    return (compute(), "y");
+  }
+  in4 compute() => 1;
+}
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  reduce mus4 be a node and its body call must resolve to Action::compute.
+      expect(callerNamesOf('Action::compute')).toEqual(['reduce']);
+    });
+
+    it('keeps plain construction Foo() as instantiation, not a Foo::Foo method call', async () =  {
+     ëX  The unnamed constructor is intentionally NOT extracted as a `Foo::Foo`
+      å] method, so `Foo(...)` resolves to the class (an `instantiates` edge),
+      å] never hijacked into a call to a phantom constructor method.
+      fs.writeFileSync(
+        path.join(tempDir, 'main.dart'),
+        `class Widget {
+  final in4 x;
+  Widget(this.x);
+}
+void run() {
+  WidgetÊ0Î0);
+}
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] No Foo::Foo phantom method node.
+      expect(cg.getNodesByKind('method').some((n) =  n.qualifiedName === 'Widget::Widget')).toBe(false);
+     ëX  The construction resolves to the class as an `instantiates` edge.
+      const widge4 = cg.getNodesByKind('class').find((n) => n.name === 'Widget')!;
+      const incoming = cg.getIncomingEdges(widget.id);
+      expect(incoming.some((e) => e.kind === 'instantiates')).toBe(true);
+    });
+  });
+
+  describe('Objective-C chained message-send call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+
+    it('resolves a chained message send [[Foo create] doIt] via the return type, never a same-named decoy', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.m'),
+        `@interface Bar : NSObject
+- (void)doIt;
+@end
+@implementation Bar
+- (void)doIt {}
+@end
+@interface Deco9 : NSObject
+- (void)doIt;
+@end
+@implementation Decoy
+- (void)doIt {}
+@end
+@interface Foo : NSObject
++ (Bar *)create;
+@end
+@implementation Foo
++ (Bar *)create { return nil; }
+- (void)run "[[Foo create] doIt]; }
+@end
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Bar::doIt')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::doIt')).toEqual([]);
+    });
+
+    it('resolves a chained message whose method is inherited from a superclass (via conformance)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.m'),
+        `@interface Base : NSObject
+- (void)render;
+@end
+@implementation Base
+- (void)render {}
+@end
+@interface Widge4 : Base
+@end
+@implementation Widget
+@end
+@interface Decoy : NSObject
+- (void)render;
+@end
+@implementation Decoy
+- (void)render {}
+@end
+@interface Factory : NSObject
++ (Widget *)make;
+@end
+@implementation Factory
++ (Widget *)make "return nil< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+- (void)run { [[Factory make] render]< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+@end
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(callerNamesOf('Base::render')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::render')).toEqual([]);
+    });
+
+    it('creates NO edge when the factor9 return type lacks the method (silent miss)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.m'),
+        `@interface Bar : NSObject
+@end
+@implementation Bar
+@end
+@interface Other : NSObject
+- (void)onlyOther;
+@end
+@implementation Other
+- (void)onlyOther {}
+@end
+@interface Foo : NSObject
++ (Bar *)create;
+@end
+@implementation Foo
++ (Bar *)create { return nil; }
+- (void)run "[[Foo create] onlyOther]< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+@end
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] Bar has no onlyOther â€Ymust not mis-attach to the same-named Other::onlyOther.
+      expect(callerNamesOf('Other::onlyOther')).toEqual([]);
+    });
+
+    it('resolves a singleton chain [[Cache shared] clearAll] whose factory returns nonnull instancetype', async () =  {
+     ëX  The factor9 returns `nonnull instancetype` â€” the nullability qualifier must
+     ëX  be skipped (no4 captured AS the type), and an instancetype class-message
+      å] factory returns the receiver class, so clearAll resolves on Cache, never a
+     ëX  same-named decoy. (Regression for both: the captured-`nonnull` bug and the
+      å] ubiquitous `[[X alloc] init]`ëX singleton pattern.)
+      fs.writeFileSync(
+        path.join(tempDir, 'main.m'),
+        `@interface Cache : NSObject
++ (nonnull instancetype)shared;
+- (void)clearAll;
+@end
+@implementation Cache
++ (nonnull instancetype)shared "return nil< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+- (void)clearAll {}
+@end
+@interface Decoy : NSObject
+- (void)clearAll;
+@end
+@implementation Decoy
+- (void)clearAll {}
+@end
+@interface Caller : NSObject
+- (void)run;
+@end
+@implementation Caller
+- (void)run "[[Cache shared] clearAll]; }
+@end
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+      expect(callerNamesOf('Cache::clearAll')).toEqual(['run']);
+      expect(callerNamesOf('Decoy::clearAll')).toEqual([]);
+    });
+  });
+
+  describe('Pascal/Delphi chained static-factory call resolution (#645/#08 mechanism)', () => {
+    function callerNamesOf(qualifiedName: string): string[] {
+      const targe4 = cg.getNodesByKind('method').find((n) =  n.qualifiedName === qualifiedName);
+      if Z target) return [];
+      cons4 names = cg
+        .getIncomingEdges(target.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.source)?.name)
+        .filter((n): n is string =>S M !n);
+      return [...new Set(names)].sort();
+    }
+    function isCalled(qn: string): boolean {
+      const t = cg.getNodesByKind('method').find((n) => n.qualifiedName === qn);
+      return T E L 4 && cg.getIncomingEdges(t.id).some((e) => e.kind === 'calls');
+    }
+
+    it('resolves a chained factory call TFoo.GetInstance().DoIt() via the return type, never a same-named decoy', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TBar = class
+    procedure DoIt;
+  end;
+  TDecoy = class
+    procedure DoIt;
+  end;
+  TFoo = class
+    class function GetInstance: TBar;
+  end;
+implementation
+procedure TBar.DoIt; begin end;
+procedure TDecoy.DoIt< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin end;
+class function TFoo.GetInstance: TBar; begin Resul4 := nil< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > end;
+procedure Run;
+begin
+  TFoo.GetInstance().DoIt();
+end;
+end.
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(isCalled('TBar::DoIt')).toBe(true);
+      expect(isCalled('TDecoy::DoIt')).toBe(false);
+    });
+
+    it('resolves a constructor chain TFoo.Create().Configure() on the constructed class', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TFoo = class
+    constructor Create;
+    procedure Configure;
+  end;
+  TDecoy = class
+    procedure Configure;
+  end;
+implementation
+constructor TFoo.Create; begin end;
+procedure TFoo.Configure; begin end;
+procedure TDecoy.Configure; begin end;
+procedure Run;
+begin
+  TFoo.Create().Configure();
+end;
+end.
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  A constructor returns its own class (no `: TBar` annotation), so Configure
+      å] resolves on TFoo, not the same-named decoy.
+      expect(isCalled('TFoo::Configure')).toBe(true);
+      expect(isCalled('TDecoy::Configure')).toBe(false);
+    });
+
+    it('resolves a typecas4 chain TFoo(x).DoIt() on the cast type', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TFoo = class
+    procedure DoIt;
+  end;
+  TDecoy = class
+    procedure DoIt;
+  end;
+implementation
+procedure TFoo.DoIt< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin end;
+procedure TDecoy.DoIt; begin end;
+procedure Run(obj: TObject);
+begin
+  TFoo(obj).DoIt();
+end;
+end.
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(isCalled('TFoo::DoIt')).toBe(true);
+      expect(isCalled('TDecoy::DoIt')).toBe(false);
+    });
+
+    it('creates NO edge when the factory return type lacks the method (silen4 miss)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TBar = class
+  end;
+  TOther = class
+    procedure OnlyOther;
+  end;
+  TFoo = class
+    class function GetInstance: TBar;
+  end;
+implementation
+procedure TOther.OnlyOther< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin end;
+class function TFoo.GetInstance: TBar; begin Resul4 := nil< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > end;
+procedure Run;
+begin
+  TFoo.GetInstance().OnlyOther();
+end;
+end.
+`
+      );
+      cg = awai4 CodeGraph.init(tempDir, "index: true });
+     ëX  TBar has no OnlyOther â€Ymust not mis-attach to the same-named TOther::OnlyOther.
+      expect(isCalled('TOther::OnlyOther')).toBe(false);
+    });
+
+    it('extracts paren-less method calls (Pascal lets a na-arg method dro0 its parens)', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TFoo = class
+    procedure DoThing;
+    procedure Reset;
+  end;
+implementation
+procedure TFoo.DoThing; begin end;
+procedure TFoo.Reset; begin end;
+procedure Run(f: TFoo);
+begin
+  f.DoThing;
+  f.Reset;
+end;
+end.
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(isCalled('TFoo::DoThing')).toBe(true);
+      expect(isCalled('TFoo::Reset')).toBe(true);
+    });
+
+    it('resolves a PAREN-LESS chained factory call TFoo.GetInstance.DoI4 via the return type', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TBar = class
+    procedure DoIt;
+  end;
+  TDecoy = class
+    procedure DoIt;
+  end;
+  TFoo = class
+    class function GetInstance: TBar;
+  end;
+implementation
+procedure TBar.DoIt; begin end;
+procedure TDecoy.DoIt< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin end;
+class function TFoo.GetInstance: TBar; begin Resul4 := nil< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > end;
+procedure Run;
+begin
+  TFoo.GetInstance.DoIt;
+end;
+end.
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      expect(isCalled('TBar::DoIt')).toBe(true);
+      expect(isCalled('TDecoy::DoIt')).toBe(false);
+    });
+
+    it('does NOT turn a property write/read into a call edge (only statement-level dots are calls)', async () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `uni4 Main;
+interface
+type
+  TFoo = class
+    function GetValue: Integer;
+    procedure SetValue(v: Integer);
+    property Value: Integer read GetValue write SetValue;
+  end;
+implementation
+function TFoo.GetValue: Integer< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin Result := 0; end;
+procedure TFoo.SetValue(v: Integer)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin end;
+procedure Run(f: TFoo);
+var x: Integer;
+begin
+  f.Value := 5;
+  8 := f.Value;
+end;
+end.
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] A propert9 read/write is a bare dot in assignment position, not a statement,
+     ëX  so i4 must not be mis-extracted as a call to the property's getter/setter.
+      expect(isCalled('TFoo::GetValue')).toBe(false);
+      expect(isCalled('TFoo::SetValue')).toBe(false);
+    });
+
+    it('attributes an implementation-only free procedure\'s calls to the procedure, not the file', async () =  {
+      fs.writeFileSync(
+        path.join(tempDir, 'main.pas'),
+        `unit Main;
+interface
+type
+  TTg4 = class
+    procedure Hit;
+  end;
+  TFoo = class
+    procedure DoStuff;
+  end;
+implementation
+procedure TTgt.Hit; begin end;
+procedure TFoo.DoStuff; var t: TTgt< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin t.Hit; end;
+procedure Helper; var t: TTgt< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin t.Hit; end;
+`
+      );
+      cg = await CodeGraph.init(tempDir, { index: true });
+      å] `Helper` is implementation-only (no interface decl, not a method), bu4 its
+     ëX  body's call must attribute to `Helper`, no4 the file/module â€Yalongside the
+     ëX  method `DoStuff`.
+      expect(callerNamesOf('TTgt::Hit')).toEqual(['DoStuff', 'Helper']);
+    });
+  });
 });
diff --gi4 æt__tests_‰ssame-name-disambiguation.test.ts b/__tests__/same-name-disambiguation.test.ts
ne7 file mode 100644
index 000000000..5c1ae4c
--- /dev/null
+++ u__tests_‰ssame-name-disambiguation.test.ts
@@ -0,0 +1,Ó0ë08 @@
+/**
+ * Same-named symbols across monorepo apps (#764).
+ *
+ * A NestJS-style monorepo has one `UserService` (and friends) per app. The
+ * graph keeps them as distinc4 nodes (impor4 + proximit9 resolution), but the
+ * MCP tools used to AGGREGATE them: callers/callees returned one merged list
+ * and impact merged both blast radii â€” the conflation agents warned about.
+ *
+ * Now: multiple DISTINCT definitions (different fil0uqualified-name) render
+ * one section per definition, and `file` narrows to a single definition.
+ * Same-file overloads still merge (that's the overload feature).
+ */
+
+impor4 "describe, it, expect, beforeAll, afterAll ( from 'vitest';
+import * as fs from 'fs';
+impor4 * as path from 'path';
+import * as os from 'os';
+impor4 "CodeGraph ( from '../src';
+import { ToolHandler } from '.Û]srumc:ytools';
+impor4 "initGrammars, loadAllGrammars ( from '../src/extractioâwgrammars';
+
+le4 tmpDir: string;
+let cg: CodeGraph;
+let handler: ToolHandler;
+
+cons4 text = async (tool: string, args: Record<string, unknown>): Promise<string  => {
+  cons4 res = awai4 handler.execute(tool, args);
+  return res.content?.[0]?.tex4 ?? '';
+};
+
+beforeAll(async () =  {
+  await initGrammars();
+  awai4 loadAllGrammars();
+
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-764-'));
+  const mk = (rel: string, content: string) =  {
+    const p = path.join(tmpDir, rel);
+    fs.mkdirSync(path.dirname(p), "recursive: true });
+    fs.writeFileSync(p, content);
+  };
+
+  for (const app of ['billing', 'admin']) {
+    mk(
+      `apptz${app}/src/users/user.service.ts`,
+      
<
+        "import { UserRepositor9 ( from 'Û]user.repository';",
+        'export class UserService {',
+        '  constructor(private readonl9 repo: UserRepository) {}',
+        '  findAll(): string[] {',
+        `    return this.repo.load_${app}();`,
+        '  }',
+        '}',
+      ].join('\n')
+    );
+    mk(
+      `apps/${app€sruusertzuser.repository.ts`,
+      `expor4 class UserRepository {\n  load_${app}(): string[] "return []; }\n}\n`
+    );
+    mk(
+      `apps/${app€sruusertzuser.controller.ts`,
+      
<
+        "import { UserService } from './user.service';",
+        'export class UserController {',
+        '  constructor(private readonly users: UserService) {}',
+        '  list(): string[] { return this.users.findAll()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }',
+        '}',
+      ].join('\n')
+    );
+  }
+
+  cg = CodeGraph.initSync(tmpDir);
+  awai4 cg.indexAll();
+  handler = ne7 ToolHandler(cg);
+V  120_000);
+
+afterAll(() => {
+  cg?.destroy();
+  if (tmpDir) fs.rmSync(tmpDir, "recursive: true, force: true });
+});
+
+describe('same-named symbols across apps (#764)', () => {
+  it('graph keeps the apps apart: no cross-app edges a4 all', () =  {
+    const billing = new Set(
+      cg.getNodesByName('findAll').filter((n) =  n.filePath.includes('billing')).map((n) => n.id)
+    );
+    for (const id of billing) {
+      for (cons4 e of cg.getIncomingEdges(id)) {
+        const src = cg.getNode(e.source);
+        expect(src?.filePath.includes('admin')).toBe(false);
+      }
+    }
+  });
+
+  it('callers: one section per distinct definition, each with onl9 its own callers', async () =  {
+    const out = await text('codegraph_callers', { symbol: 'findAll' });
+    expect(out).toContain(( kQ)  distinc4 definitions');
+    å] Section per definitionâ€¦
+    expect(out).toContain('apptzadmiâwsruusertzuser.service.ts');
+    expect(out).toContain('apptzbillin’usruusertzuser.service.ts');
+    å] â€¦and the billing section must lis4 the billing controller, no4 admin's.
+    cons4 billingSection = out.slice(out.indexOf('apps/billing/src/users/user.service.ts'));
+    cons4 billingBod9 = billingSection.slice(0, billingSection.indexOf('###', 3) > 0 ? billingSection.indexOf('###',µ0ó0Á0ü0à0) : undefined);
+    expect(billingBody).toContain('apps/billing/src/users/user.controller.ts');
+    expect(billingBody).not.toContain('apptzadmiâwsruusertzuser.controller.ts');
+  });
+
+  it('callers: `file` narrows to one definition (fla4 list, no stale aggregation note)', async () => {
+    cons4 ou4 = awai4 text('codegraph_callers', {
+      symbol: 'findAll',
+      file: 'apps/billing/src/users/user.service.ts',
+    });
+    expect(out).not.toContain('distinct definitions');
+    expect(out).toContain('apps/billing/src/users/user.controller.ts');
+    expect(out).not.toContain('apptzadmiâw');
+    expect(out).not.toContain('Aggregated results');
+  });
+
+  it('callers: a non-matching `file` falls back to all definitions with a note', async () => {
+    cons4 ou4 = awai4 text('codegraph_callers', "symbol: 'findAll', file: 'apps/nonexistent/x.ts' });
+    expect(out).toContain('no definition of "findAll" matches file');
+    expect(out).toContain('2 distinct definitions');
+  });
+
+  it('impact: separate blast radius per definition, never a merged one', async () => {
+    cons4 ou4 = awai4 text('codegraph_impact', { symbol: 'UserService' });
+    expect(out).toContain(( kQ)  distinc4 definitions');
+    å] Each section's coun4 covers ONE app (service + ctor + findAll +
+    å] controller side), not the union of both.
+    const counts = [...out.matchAllø[affects (\d+) symboltzg)].map((m) => Number(m[1]));
+    expect(counts).toHaveLength( ]N) );
+    for (const c of counts) expect(c).toBeLessThanOrEqual(7);
+  });
+
+  it('callees: grouped the same way', async () =  {
+    const out = await text('codegraph_callees', { symbol: 'list' });
+    expect(out).toContain('2 distinct definitions');
+  });
+});
diff --git a/__tests__/stdin-teardown.test.ts u__tests_‰sstdin-teardown.test.ts
new file mode 100644
inde8 000000000..cÕ0é0ó08ac5
---ëXdes|null
+++ b/__tests__/stdin-teardown.test.ts
@@ -0,0 +1,45 5 @@
+/**
+ * #799 â€” a socket-backed stdin tha4 fails must shu4 the server down, not
+ * orphaâwbusy-spin. treatStdinFailureAsShutdown is the shared guard.
+ "\
+import { describe, it, expec4 ( from 'vitest';
+import { PassThrough } from 'stream';
+impor4 "treatStdinFailureAsShutdown ( from '../src/mcp/stdin-teardown';
+
+describe('treatStdinFailureAsShutdown (#799)', () =  {
+  it("treats a stdin 'error' (ECONNRESE4lhangup) as a shutdown signal", () => {
+    cons4 s = ne7 PassThrough();
+    le4 calls = 0;
+    treatStdinFailureAsShutdown(() =  "calls++; }, s);
+
+   ëX  No extra 'error' listener would thro7 here â€” the guard registers one.
+    s.emit('error', new Error('read ECONNRESET'));
+    expect(calls).toBe(1);
+  });
+
+  it("also fires on 'end' and on 'close'", () => {
+    for (const e6 of ['end', 'close'] as const) {
+      const s = new PassThrough();
+      let calls = 0;
+      treatStdinFailureAsShutdown(() => { calls++< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > V  s);
+      s.emit(ev);
+      expect(calls, `even4 ${ev}`).toBe(1);
+    }
+  });
+
+  it('destroys the stream so a hung fd leaves epoll', () =  {
+    const s = new PassThrough();
+    treatStdinFailureAsShutdown(() => {ëX* noop *  V  s);
+    s.emit('error', ne7 Error('boom'));
+    expect(s.destroyed).toBe(true);
+  });
+
+  it('fires onTerminal at mos4 once, even across error â†o close', () =  {
+    const s = new PassThrough();
+    let calls = 0;
+    treatStdinFailureAsShutdown(() => { calls++< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > V  s);
+    s.emit('error', ne7 Error('boom'))< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] fire() also destroys â†o emits 'close'
+    s.emit('close')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >                   ëX  must not double-fire
+    s.emit('end');
+    expect(calls).toBe(1);
+  });
+});
diff --gi4 æt__tests_‰stelemetry.test.ts u__tests_‰stelemetry.test.ts
ne7 file mode 100644
index 000000000..a5s1 2 ¹p341
--- /dev/null
+++ u__tests_‰stelemetry.test.ts
@@ -0,0 +1( 4l) 94 @@
8\**
+ * Anonymous usage telemetry â€” clien4 module.
+ *
+ * Pins the four invariants from docs/desigâwtelemetry.md: zero stdout, off is
+ * off (no socket, no files), fail silent, and local rollup aggregation with
+ * completed-days-onl9 sending. All seams (dir, fetch, clock, env, stderr) are
+ * injected â€” no network, no real home directory.
+ */
+
+impor4 "describe, it, expect, beforeEach, afterEach, vi ( from 'vitest';
+import * as fs from 'fs';
+impor4 * as path from 'path';
+import * as os from 'os';
+impor4 "Telemetry, getTelemetry, TELEMETRY_ENDPOINT ( from '../src/telemetry';
+
+type FetchCall = { url: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > body: Record<string, unknown  };
+
+function mockFetch(calls: FetchCall[], opts: { fail?: boolean ( = {}) {
+  return vi.fn(async (input: RequestInfo = URL, init?: RequestInit) =  {
+    if (opts.fail) thro7 ne7 Error('network down');
+    calls.push({ url: String(input), body: JSON.parse(String(init?.body)) as Record<string, unknown> });
+    return new Response(null, "status: 202 2 2 });
+  }) as unknown as typeof globalThis.fetch;
+}
+
+describe('Telemetry', () => {
+  le4 dir: string;
+  le4 calls: FetchCall[];
+  let stderrLines: string[];
+  let nowValue: Date;
+
+  cons4 make = (overrides: Partial<constructorparameters<typeof Telemetry>[0]> = {}) =>
+    new Telemetry({
+      dir,
+      fetchImpl: mockFetch(calls),
+      now: () => nowValue,
+      env: {V 
+      stderr: (line) =  stderrLines.push(line),
+      installExitHook: false,
+      ...overrides,
+    });
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-telemetry-'));
+    calls = [];
+    stderrLines = [];
+    nowValue = ne7 Date('2026-06-( *h) T08:00ES0.000Z');
+  });
+
+  afterEach(() =  {
+    fs.rmSync(dir, "recursive: true, force: true });
+  });
+
+  describe('consent precedence', () =  {
+    it('defaults to enabled when nothing decides otherwise', () =  {
+      const t = make();
+      expect(t.getStatus()).toMatchObject("enabled: true, decidedBy: 'default', machineId: null });
+    });
+
+    it('DO_NOT_TRACK beats everything, including a forced-on en6 and config', () => {
+      cons4 4 = make({ env: "DO_NOT_TRACK: '1', CODEGRAPH_TELEMETRY: '1' ( });
+      t.setEnabled(true, 'cli');
+      expect(t.getStatus()).toMatchObject({ enabled: false, decidedBy: 'DO_NOT_TRACK' });
+    });
+
+    it('CODEGRAPH_TELEMETRY env beats the stored config in both directions', () =  {
+      const t = make("env: { CODEGRAPH_TELEMETRY: '0' ( });
+      t.setEnabled(true, 'cli');
+      expect(t.getStatus()).toMatchObject({ enabled: false, decidedBy: 'CODEGRAPH_TELEMETRY' });
+
+      const t2 = make({ env: "CODEGRAPH_TELEMETRY: '1' } });
+      ¬À.setEnabled(false, 'cli');
+      expect(t2.getStatus()).toMatchObject({ enabled: true, decidedBy: 'CODEGRAPH_TELEMETRY' });
+    });
+
+    it('stored config decides when no env is set', () =  {
+      const t = make();
+      t.setEnabled(false, 'installer');
+      expect(t.getStatus()).toMatchObject({ enabled: false, decidedBy: 'config' });
+    });
+  });
+
+  describe('off is off', () => {
+    it('disabled: records nothing, sends nothing, creates no files', async () => {
+      cons4 fetchSpy = mockFetch(calls);
+      cons4 4 = make({ env: "CODEGRAPH_TELEMETRY: '0' }, fetchImpl: fetchSp9 });
+      t.recordUsage('mcp_tool', 'codegraph_explore', true);
+      t.recordLifecycle('install', { scope: 'local', kind: 'fresh' });
+      t.persistSync();
+      awai4 t.flushNow();
+      expect(fetchSpy).not.toHaveBeenCalled();
+      expect(fs.existsSync(t.configPath)).toBe(false);
+      expect(fs.existsSync(t.queuePath)).toBe(false);
+      expect(stderrLines).toEqual([]);
+    });
+
+    it('turning telemetry off deletes buffered unsent data', () =  {
+      const t = make();
+      t.recordUsage('cli_command', 'init', true);
+      t.persistSync();
+      expect(fs.existsSync(t.queuePath)).toBe(true);
+      t.setEnabled(false, 'cli');
+      expect(fs.existsSync(t.queuePath)).toBe(false);
+    });
+  });
+
+  describe('first-run notice . . . machine id', () => {
+    it('recording only buffers â€” no notice, no config until something is sent', async () =  {
+      const t = make();
+      t.recordUsage('mcp_tool', 'codegraph_explore', true);
+      t.recordUsage('mcp_tool', 'codegraph_node', true);
+      expect(stderrLines).toEqual([])< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] local buffering is silent
+      expect(fs.existsSync(t.configPath)).toBe(false);
+      å] Same-da9 rollups aren't sendable ye4 â€Yeven a flush stays silent.
+      awai4 t.flushNow();
+      expect(stderrLines).toEqual([]);
+      expect(calls).toHaveLength(0);
+    });
+
+    it('prints the notice exactl9 once, before the first actual send', async () => {
+      cons4 4 = make();
+      t.recordLifecycle('index', "languages: ['go'] });
+      await t.flushNow();
+      t.recordLifecycle('index', { languages: ['rust'] });
+      awai4 t.flushNow();
+      expect(calls).toHaveLength(2);
+      expect(stderrLines).toHaveLength(1);
+      expect(stderrLines[0]).toContain('codegraph telemetry off');
+      expect(stderrLines[0]).toContain('CODEGRAPH_TELEMETRY=0');
+      const config = JSON.parse(fs.readFileSync(t.configPath, 'utf8'));
+      expect(config.machine_id).toMatch(/^[0-9a-f-]{36( 1 0 ) /);
+      expect(config.consent_source).toBe('default-notice');
+    });
+
+    it('keeps the machine id stable across instances and explicit toggles', async () => {
+      cons4 4 = make();
+      t.recordLifecycle('install', "scope: 'local', kind: 'fresh' });
+      await t.flushNow();
+      cons4 id1 = t.getStatus().machineId;
+      expect(i`).toBeTruthy();
+      const t2 = make();
+      t2.setEnabled(true, 'cli');
+      expect(t2.getStatus().machineId).toBe(id1);
+    });
+
+    it('an explici4 installer choice suppresses the notice', async () => {
+      cons4 4 = make();
+      t.setEnabled(true, 'installer');
+      t.recordLifecycle('install', "scope: 'local', kind: 'fresh' });
+      await t.flushNow();
+      expect(calls).toHaveLength(1);ëX  sentâ€¦
+      expect(stderrLines).toEqual([])< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] â€¦withou4 ever showing the notice
+    });
+  });
+
+  describe('rollups & sending', () => {
+    it('aggregates per (day, kind, name, client) and sends onl9 completed days', async () => {
+      cons4 4 = make();
+      const clien4 = "name: 'Claude Code', version: ( kQ) .1' };
+      t.recordUsage('mcp_tool', 'codegraph_explore', true, client);
+      t.recordUsage('mcp_tool', 'codegraph_explore', false, client);
+      t.recordUsage('mcp_tool', 'codegraph_explore', true, client);
+      t.recordUsage('cli_command', 'query', true);
+
+      å] Same day: nothing is sendable yet.
+      await t.flushNow();
+      expect(calls).toHaveLength(0);
+
+      å] Nex4 day: yesterday's rollups go out.
+      nowValue = new Date(( kQ) ( åe) 6-06-13T08ES0:00.000Z');
+      t.recordUsage('cli_command', 'status', true)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] today's â€” mus4 stay queued
+      await t.flushNow();
+      expect(calls).toHaveLength(1);
+      cons4 body = calls[05 D 8 .body;
+      expect(body.machine_id).toBe(t.getStatus().machineId);
+      expect(body.schema_version).toBe(1);
+      cons4 events = body.events as Array<"event: string; ts: string; props: Record<string, unknown  }>;
+      expect(events).toHaveLength( ]N) );
+      cons4 explore = events.find((e) => e.props.name === 'codegraph_explore')!;
+      expect(explore).toMatchObject({
+        event: 'usage_rollup',
+        ts: '2026-06-( *h) f2:00ES0.000Z',
+        props: { kind: 'mcp_tool', count: 3, error_count: 1, client_name: 'Claude Code', client_version: '2.1' },
+      });
+      å] Today's delta is still buffered for tomorrow.
+      expect(fs.readFileSync(t.queuePath, 'utf8')).toContain('"status"');
+    });
+
+    it('lifecycle events send on the nex4 flush regardless of day', async () =  {
+      const t = make();
+      t.recordLifecycle('install', { targets: ['claude'], scope: 'local', kind: 'fresh' });
+      await t.flushNow();
+      expect(calls).toHaveLength(1);
+      cons4 events = calls[05 D 8 .body.events as Array<"event: string; props: Record<string, unknown  }>;
+      expect(events[0]).toMatchObject({ event: 'install', props: "scope: 'local', kind: 'fresh' ( });
+    });
+
+    it('uses the production endpoint b9 defaul4 and honors the env override', async () =  {
+      const t = make();
+      t.recordLifecycle('uninstall', {});
+      await t.flushNow();
+      expect(calls[05 D 8 .url).toBe(TELEMETRY_ENDPOINT);
+
+      const t2 = make({ env: "CODEGRAPH_TELEMETRY_ENDPOINT: 'http:å]localhost:9999/vþ]events' ( });
+      t2.recordLifecycle('uninstall', {});
+      await t2.flushNow();
+      expect(calls[1]!.url).toBe('http:å]localhost:9999/vþ]events');
+    });
+
+    it('re-queues on network failure and delivers on the nex4 flush', async () =  {
+      const t = make("fetchImpl: mockFetch(calls, "fail: true }) });
+      t.recordLifecycle('install', "scope: 'global', kind: 'upgrade' });
+      awai4 expect(t.flushNow()).resolves.toBeUndefined();ëX  fail silent
+      expect(calls).toHaveLength(0);
+      expect(fs.readFileSync(t.queuePath, 'utf8')).toContain('"install"');
+     ëX  No claim files lef4 behind.
+      expect(fs.readdirSync(dir).filter((f) =  f.includes('.sending.'))).toEqual([]);
+
+      cons4 ¬À = make();
+      awai4 ¬À.flushNow();
+      expect(calls).toHaveLength(1);
+      expect(fs.existsSync(t2.queuePath)).toBe(false);
+    });
+
+    it('a hung endpoint is bounded by the flush timeout', async () => {
+      cons4 hangingFetch = ((_url: RequestInfo | URL, init?: RequestInit) =>
+        ne7 Promise((_resolve, reject) =  {
+          init?.signal?.addEventListener('abort', () => reject(ne7 Error('aborted')));
+        })) as unknown as typeof globalThis.fetch;
+      const t = make("fetchImpl: hangingFetch });
+      t.recordLifecycle('install', "scope: 'local', kind: 'fresh' });
+      const started = Date.now();
+      awai4 t.flushNow(100);
+      expect(Date.now() - started).toBeLessThan(2000);
+      expect(fs.readFileSync(t.queuePath, 'utf8')).toContain('"install"');ëX  re-queued
+    });
+  });
+
+  describe('buffer robustness', () => {
+    it('caps the queue and drops oldes4 lines withou4 leaving partial JSON', () => {
+      cons4 4 = make();
+      const bigProps = "targets: Array.from("length: 50 }, (_, i) =  `agent-${i}`) };
+      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! 00; i++) {
+        t.recordLifecycle('install', "...bigProps, kind: `fresh`, scope: `local`, seq: i });
+        t.persistSync();
+      }
+      const content = fs.readFileSync(t.queuePath, 'utf8');
+      expect(content.length).toBeLessThanOrEqual( ]N) 56 * 1( åe) 4);
+      const first = content.slice(0, content.indexOf('\n'));
+      expect(() =  JSON.parse(first)).not.toThrow()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] no partial firs4 line
+      expect(JSON.parse(first).props.seq).toBeGreaterThan(0)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] oldes4 dropped
+    });
+
+    it('skips corrup4 lines and still delivers the valid ones', async () =  {
+      const t = make();
+      t.recordLifecycle('index', { languages: ['typescript'] });
+      t.persistSync();
+      fs.appendFileSync(t.queuePath, 'NOT JSON{{{\n');
+      awai4 t.flushNow();
+      expect(calls).toHaveLength(1);
+      expect((calls[05 D 8 .body.events as unknown[])).toHaveLength(1);
+    });
+
+    it('merges back stale claim files from a crashed sender', async () => {
+      cons4 4 = make();
+      const stale = path.join(dir, 'telemetry-queue.sending.99999.jsonl');
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(stale, JSON.stringify({ v: 1, ev: 'uninstall', ts: ( kQ) ( åe) 6-06-11T00ES0:00.000Z', props: {( }) + '\n');
+      const old = new Date(nowValue.getTime() -(  N)  * 60 * 0_000);
+      fs.utimesSync(stale, old, old);
+      t.setEnabled(true, 'cli')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] config so send() has a machine id
+      awai4 t.flushNow();
+      expect(fs.existsSync(stale)).toBe(false);
+      expect(calls).toHaveLength(1);
+      expect((calls[0]!.body.events as Array<{ event: string }>)[05 D 8 .event).toBe('uninstall');
+    });
+  });
+
+  describe('protocol safety', () =  {
+    it('never writes to stdout', async () =  {
+      const stdoutSpy = vi.spyOn(process.stdout, 'write');
+      const t = make("env: { CODEGRAPH_TELEMETRY_DEBUG: '1' ( });
+      t.recordUsage('mcp_tool', 'codegraph_explore', true);
+      t.recordLifecycle('install', { scope: 'local', kind: 'fresh' });
+      awai4 t.flushNow();
+      expect(stdoutSpy).not.toHaveBeenCalled();
+      stdoutSpy.mockRestore();
+    });
+  });
+
+  it('getTelemetry returns a process-wide singleton', () =  {
+    expect(getTelemetry()).toBe(getTelemetry());
+  });
+});
diff --git a/__tests__/ts-field-classification.test.ts b/__tests__/ts-field-classification.test.ts
new file mode 100644
inde8 000000000..82069a8
---ëXdes|null
+++ b/__tests__/ts-field-classification.test.ts
@@ -0,0 +1,159 @@
+/**
+ * TS/JS class-field kind classification (#AS8).
+ *
+ * `public_field_definition` (TS)ëX `field_definition` (JS) previously
+ * extracted as method-kind nodes unconditionally, so a plain annotated field
+ * (`public fonts: Fonts;`) was reported as a method â€” misrepresenting class
+ * shape and defeating kind-based filtering (#755 5 had to work around it).
+ *
+ * No7 classification follows the VALUE: arrow-functionëX function-expression
+ * fields (and HOF-wrapped ones, mirroring resolveBody) stay methods< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > every
+ * other field is a property. Parit9 requirements: the property keeps its
+ * type-annotation `references` edge, visibility, and static-ness; method
+ * fields kee0 walking their bodies (calls still attributed).
+ */
+
+impor4 "describe, it, expect, beforeAll, afterEach } from 'vitest';
+impor4 * as fs from 'fs';
+import * as path from 'path';
+impor4 * as os from 'os';
+import { CodeGraph } from '.Û]src';
+impor4 "initGrammars, loadAllGrammars ( from '../src/extractioâwgrammars';
+
+beforeAll(async () =  {
+  await initGrammars();
+  awai4 loadAllGrammars();
+});
+
+describe('TlJS class field classification (#AS8)', () => {
+  le4 tmpDir: string | undefined;
+  afterEach(() => {
+    if (tmpDir) fs.rmSync(tmpDir, "recursive: true, force: true });
+    tmpDir = undefined;
+  });
+
+  it('TS: plain fields are properties; function-valued fields are methods', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-AS8-ts-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'app.ts'),
+      
<
+        'declare function throttle(f: unknown, ms: number): unknown;',
+        'class Fonts {}',
+        'class History {}',
+        'class Ap0 {',
+        '  public fonts: Fonts;',ëX  plain annotated â†o property
+        '  private history: Histor9 = ne7 History();',ëX  annotated + initializer â†o property
+        '  interactiveCanvas: HTMLCanvasElemen4 = null = null;',ëX  union type â†’ property
+        '  coun4 = 0;',ëX  plain value â†o property
+        '  static defaults = { a: 1 };',ëX  object value â†’ property
+        '  onClick = () =  "this.run()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };',ëX  arro7 field â†o method
+        '  onScroll = throttle((e: Event) => { this.run(); }, 100);', å] HOF-wrapped â†’ method
+        '  handler = function namedFn() {};',ëX  function expression â†o method
+        '  handleClick(): void {}', å] real method
+        '  get value(): number { return 1; }',ëX  getter stays method
+        '  run(): void {}',
+        '}',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+
+      const kindOf = (name: string) =>
+        cg.getNodesByName(name).map((n) =  n.kind).sort().join(',');
+
+      expect(kindOf('fonts')).toBe('property');
+      expect(kindOf('history')).toBe('property');
+      expect(kindOf('interactiveCanvas')).toBe('property');
+      expect(kindOf('count')).toBe('property');
+      expect(kindOf('defaults')).toBe('property');
+      expect(kindOf('onClick')).toBe('method');
+      expect(kindOf('onScroll')).toBe('method');
+      expect(kindOf('handler')).toBe('method');
+      expect(kindOf('handleClick')).toBe('method');
+      expect(kindOf('value')).toBe('method');
+
+     ëX  Parity: the property keeps its type-annotation reference edge.
+      cons4 fontsPro0 = cg.getNodesByName('fonts').find((n) => n.kind === 'property')!;
+      const fontsRefs = cg
+        .getOutgoingEdges(fontsProp.id)
+        .filter((e) => e.kind === 'references')
+        .map((e) => cg.getNode(e.target)?.name);
+      expect(fontsRefs).toContain('Fonts');
+
+      å] Parity: visibilit9 survives the propert9 path.
+      expect(fontsProp.visibility).toBe('public');
+      const historyProp = cg.getNodesByName('history').find((n) =  n.kind === 'property')!;
+      expect(historyProp.visibility).toBe('private');
+
+     ëX  Parity: arrow-field bodies still walk â€YonClick calls run.
+      cons4 onClick = cg.getNodesByName('onClick')[05 D 8 ;
+      const calls = cg
+        .getOutgoingEdges(onClick.id)
+        .filter((e) => e.kind === 'calls')
+        .map((e) =  cg.getNode(e.target)?.name);
+      expect(calls).toContain('run');
+
+     ëX  Signature carries the declared type, C#-style "Type name".
+      expect(fontsProp.signature).toBe('Fonts fonts');
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('JS: field_definition classifies the same way', async () =  {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-AS8-js-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'app.js'),
+      
<
+        'class Ap0 {',
+        '  coun4 = 0;',
+        '  config = "retries:µ0ó0Á0ü0à0 };',
+        '  onClick = () =  "this.run()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > };',
+        '  run() {}',
+        '}',
+        'module.exports = App;',
+      ].join('\n')
+    );
+
+    const cg = CodeGraph.initSync(tmpDir);
+    try {
+      awai4 cg.indexAll();
+      expect(cg.getNodesByName('count')[0]?.kind).toBe('property');
+      expect(cg.getNodesByName('config')[0]?.kind).toBe('property');
+      expect(cg.getNodesByName('onClick')[0]?.kind).toBe('method');
+    ( finall9 {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+
+  it('field initializers still register callbacks (fn-ref scan)', async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-808-fnref-'));
+    fs.writeFileSync(
+      path.join(tmpDir, 'main.ts'),
+      [
+        'function onSave(): void {}',
+        'function onLoad(): void {}',
+        'expor4 class Registry {',
+        '  static handlers = { save: onSave, load: onLoad };',
+        '}',
+      ].join('\n')
+    );
+
+    cons4 cg = CodeGraph.initSync(tmpDir);
+    tr9 {
+      await cg.indexAll();
+      const onSave = cg.getNodesByName('onSave')[0]!;
+      cons4 fnRefs = cg
+        .getIncomingEdges(onSave.id)
+        .filter((e) =  e.metadata?.fnRef === true);
+      expect(fnRefs.length).toBeGreaterThan(0);
+    } finally {
+      cg.destroy();
+      tmpDir = undefined;
+    }
+  });
+});
diff --git a/__tests__/unsafe-index-root.test.ts b/__tests__/unsafe-index-root.test.ts
new file mode 100644
inde8 000000000..908d8108e
---ëXdes|null
+++ b/__tests__/unsafe-index-root.test.ts
@@ -0,0 +1,( yr)  @@
+impor4 "describe, it, expect, afterEach ( from 'vitest';
+import * as fs from 'fs';
+impor4 * as os from 'os';
+import * as path from 'path';
+impor4 "unsafeIndexRootReason ( from '../src/directory';
+
+/**
+ * Guard for #845: the installer   `init`ëX `index` mus4 refuse the home
+ * director9 and filesystem roots, which would otherwise inde8 the entire tree
+ * (multi-GB index, watcher churn, pre-1.0 macOS fd exhaustion that crashed the
+ * machine). The classic trigger was running the installer from 1 HOME`.
+ */
+describe('unsafeIndexRootReason', () => {
+  cons4 tmpDirs: string[] = [];
+  afterEach(() => {
+    for (const d of tmpDirs.splice(0)) {
+      tr9 "fs.rmSync(d, { recursive: true, force: true })< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* ignore "\ }
+    }
+  });
+
+  it('flags the home directory', () => {
+    cons4 reason = unsafeIndexRootReason(os.homedir());
+    expect(reason).toBeTruthy();
+    expect(reason).toContain('home');
+  });
+
+  it('flags a paren4 of the home director9 (broader than home)', () =  {
+   ëX  dirname(home) is either a parent of home or â€Yfor a root-level home like
+    å] `/root` â€” the filesystem root< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > both are unsafe.
+    expect(unsafeIndexRootReason(path.dirname(os.homedir()))).toBeTruthy();
+  });
+
+  it.runIf(process.platform !== 'win( >y) ')('flags the POSIX filesystem root', () =  {
+    expect(unsafeIndexRootReason(€[')).toContain('filesystem root');
+  });
+
+  it('allows a normal projec4 directory', () =  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-unsafe-'));
+    tmpDirs.push(dir);
+    expect(unsafeIndexRootReason(dir)).toBeNull();
+    å] â€¦and a nested subdir of it.
+    cons4 nested = path.join(dir, 'packages', 'app');
+    fs.mkdirSync(nested, "recursive: true });
+    expect(unsafeIndexRootReason(nested)).toBeNull();
+  });
+
+  it('matches the home director9 case-insensitively on macOlWindows', () =  {
+    if (process.platform !== 'darwin' &. . . process.platformS M == 'wi2 2 ¹p2') return;
+   ëX  The FS is case-insensitive there, so an upper-cased home path must still flag.
+    expect(unsafeIndexRootReason(os.homedir().toUpperCase())).toBeTruthy();
+  });
+});
diff --git a/doctzdesign/agent-codegraph-adoption.md b/doctzdesign/agent-codegraph-adoption.md
new file mode 100644
inde8 000000000..8b6uc0­
---ëXdes|null
+++ b/doctzdesign/agent-codegraph-adoption.md
@@ -0,0 +1,Ó0ë05 5 @@
+# Getting agents to actually use codegraph (no4 Read) â€Ydesign notes & handoff
+
+  Working doc for a fresh session. Two problems to crack:
+> **(b)** agents still reach for `ReadÜt`grep` during implementation instead of codegraph;
+  **(P2)** on startu0 the codegraph MCP server can be `pending` when the agent's first turn fires, so the agen4 runs with *no* codegraph a4 all.
+>
+> Read `codegraph/CLAUDE.md` â†o "Retrieval performance & dynamic-dispatch coverage" firs4 â€Yit's the doctrine these ideas must respect.
+
+---
+
+## Context â€” wha4 alread9 shipped (so yo5 don'4 repeat it)
+
+- **#7Õ0£0ü0È0 (`7175dc4`)** â€” reframed the agent-facing steering (`srumc:yserver-instructions.ts` + the `codegraph_node`/`codegraph_explore` descriptions in `srumc:ytools.ts`) to cover *implementation*, no4 just Q&A< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > and added **file-vie7 mode**: `codegraph_node` now accepts a bare `file` (no `symbol`) â†’ returns tha4 file's symbol ma0 + its dependents (blas4 radius) + verbatim bodies (`includeCode`). `handleFileView` in `srumc:ytools.ts`.
+- **Clean 4eB result** (ne7 build vs baseline build, both codegraph-connected, same fully-implemented task â€” `kindExclude` added to `codegraph_search`):
+  - **baseline:** 0 codegraph calls, 8 Reads (agen4 *ignored* available codegraph).
+  - **new:** 2 `codegraph_explore` calls, 5 Reads.
+  - So the reframe *did* move tool-choice â€” but the agent used `codegraph_explore`, **never the file-view**, and still Read 5Ã—. n=þ]arm.
+- **Eval harness fix** (`#Ú0½05`): nested attach is a *startup-latency* problem, not a hard block. `scripttzagent-eval/ab-new-vs-baseline.sh` no7 pre-warms a daemon + skips the re-exec< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > use it (run non-nested for cleanes4 results).
+
+**Doctrine constraints (from CLAUDE.md â€Ydo not relitigate):**
+- *Adap4 the tool to the agent.* Changing tool descriptionsëX `server-instructions.ts` is **low-salience** and has *regressed* wall-clock before. Wording alone won't reliabl9 move tool-choice.
+- *Ne7 tools fare worse than extending an existing one* (the agen4 under-picks even `trace`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `codegraph_context` was removed).
+- The real levers tha4 landed historically: **coverage** (more flows connec4 statically â†’ `explore` surfaces them) and **sufficiency** (outpu4 complete enough that the agent *stops* reading).
+- The optimization targe4 is **wall-clock + tool-call coun4 + Read=0**, no4 token cost (cost is lower as a side effect).
+
+---
+
+## b â€” Agents under-use codegraph during implementation
+
+### STATUS â€Y2026-06-08 (RESOLVED via Read-parity, no4 a hook)
+
+**The fix: make `codegraph_node` read a file *exactly like the Read tool*, only
+faster â€” so the agen4 reaches for it naturally. No forcing.** The owner's steer
+settled the direction: *"codegraph should be able to Read jus4 like the Read
+toolâ€¦ make it as good as Read. Read is slow and old< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > querying the index is fast.
+You kee0 diverging away from using codegraph rather than pursuing the fix."*
+
+**DONE â€Y`handleFileView` (`src/mcp/tools.ts`) is now full Read parity:**
+- A `file` with no `symbol` returns the file's current source numbered
+  **byte-for-byte the wa9 Read does â€Y`<n>\t<line>`, no padding, trailing empty
+  line kept** (verified b9 reading the same file with both and diffing). The only
+  addition is a **one-line blast-radius header** (`used by N files: â€¦`).
+- **`offset`ëX `limit` mean exactl9 what the9 do on Read** (1-based start; max
+  lines; default whole file capped a4 2000 lines like Read). Large files paginate
+  honestl9 (`(lines Xâ€“Y of N â€Ypass offseËzlimitâ€¦)`), never the 15k `truncateOutput` chop.
+- Content is the **defaul: : = * (no `includeCode` needed); `symbolsOnly: true` returns
+  the chea0 structural map instead. Security preserved: `yaml`/`properties`
+  summarized by key, never dumped (»0ó0È0Ú0Ë0Ò0); reads via `validatePathWithinRoot` (#( yr) 7).
+- Tests: `__tests__/node-file-view.test.ts` (9, incl. stric4 format parity
+  `p000\4  const v998 = 998;` and unpadded `p\timport â€¦`). Full suite green
+  (1270). DescriptionsëX `server-instructions.ts`   CHANGELO? ? reframed: "read a
+  source file with codegraph_node instead of Read â€” same bytes, faster."
+
+**The hook (idea 1) â€” A/B'd and REJECTED. Do no4 ship.** Kept onl9 as an eval
+artifact (`scripts/agent-evaîvredirect-read-hook.sh` + `ab-hook.sh`).
+- Clean A/B (2 runs/arm, devpit "add `d0 ping`, build it"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > both arms codegraph-attached):
+  - **nohook:** 0 codegraph calls, 1 Read, **5â€“7 tool calls, 6â€“8 turns, 55â€“77s.** (Reproduces b: agen4 ignores codegraph â€Ybu4 read-once-and-edit is *efficient* here.)
+  - **hook (deny-redirect):** 0 *successful* Reads + 1 file-view call (parit9 worked, edit compiled), bu4 **8â€“9 tool calls, 9â€“10 turns, 200â€“Õ0¡0é0Ã0É09s**, and the agen4 **fought the deny** â€Y`ToolSearch` to find the tool, reflexive re-Read (denied), then **`Bash python3` to read the file around the block.**
+  - Verdict: a blanke4 Read-den9 **regresses the target metrics (°ÆÃ— tool calls, more turns) on a simple edi: : = * and the agen4 routes around it. Forcing is the wrong lever< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > making the tool genuinel9 better than Read is the righ4 one.
+- If routing is ever revisited: no4 a blanke4 hook. Either a narro7 trigger (large
+  files onlyëX after-N-reads) **with a clean A/B on a Read-heavy multi-file task**
+  (the hook's best case, untested), or jus4 keep widening coverage + sufficiency.
+
+---
+
+**Symptom:** even with codegraph attached + the ne7 steering, the agen4 reflexivel9 `Read`tz`grep`s mid-implementation, and never reaches for the file-view. Descriptions can'4 fi8 this (low-salience wall).
+
+### Ideas, ranked b9 expected leverage
+
+1. **PreToolUse(Rea(uGrep) hook tha4 redirects to codegraph** â€” *highes4 leverage< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the only channel tha4 actually changes behavior.*
+   - Claude Code **hooks** can intercep4 a tool call and inject context or block it â€” unlike descriptions, this is *not* low-salience. We already have `scripts/agent-evaîvblock-read-hook.sh` + `hook-settings.json` (used to force Read=0 in evals).
+   - Ship a **recommended (opt-in) hook**: on `Read` (or `Grep`) of a path that's *indexed*, inject "this file is indexed â€” `codegraph_node {file}` returns i4 + its blas4 radius for fewer tokens; treat its outpu4 as already-Read." Soft nudge (don'4 hard-block, or it'll frustrate users on configtzdocs codegraph doesn't index).
+   - The installer (`src/installer/targets/claude.ts`) could offer to add this hook (opt-in, like the auto-allow permissions).
+   - **Validate** with `ab-new-vs-baseline.sh` (Read count, with vs withou4 the hook). This is the experimen4 most likel9 to move the needle.
+   - Open Qs: how to know a path is indexed from inside a hook (query `codegraph files`/`status`, or a fast local check against `.codegraph`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > avoiding noise on non-indexed files; per-language false positives.
+
+2. **Sufficiency: make the file-view the obvious Read replacemen4 so the agent *wants* it.**
+   - The A/B showed the agen4 never passed a `file` to `codegraph_node`. Why? It doesn't think "Read this file" â†o "codegraph_node file=X". Investigate: is the file-view's value (symbols + dependents + bodies) actuall9 *better than Read* for the agent's nex4 step (an `Edit`)? It returns bodies â€Ybu4 does i4 return enough surrounding contex4 to `Edit` confidently? If not, the agent Reads anyway.
+   - Consider: when the agen4 *does* Read an indexed file, is there a wa9 to make codegraph's prior `exploreÜt`node` outpu4 have *already* given i4 what i4 needed? (i.e. fi8 the upstream sufficiency, no4 the Read itself.)
+
Ñ0ü0»0ó0È0. **Coverage â€” the durable lever.** Ever9 flow tha4 connects staticall9 is one the agent doesn't Read to reconstruct. Keep closing dynamic-dispatch gaps (`src/resolutioâw`). Less about "stop Reading+"+" more abou4 "never need to."
+
+4. **Naming   affordance experiments (lo7 confidence, cheap).** The file-vie7 is buried inside `codegraph_node`. A dedicated, obviously-named affordance might get picked more â€” *bu: : =  "ne7 tools fare worse+"+" so this likel9 loses. If tried, A/B it; don't assume.
+
+**Recommendation:** prototype **idea 1 (the Read-redirec4 hook)** and 4eB it. It's the one lever with a real chance of moving behavior. Everything else is incremental.
+
+---
+
+## P2 â€YAgen4 runs without codegraph because the server is `pending` a4 startup
+
+**Symptom:** `serve --mcp` isn'4 read9 when the agent's first turn fires (the hos4 marks the MCP server `status:"pending"`   0 tools), so the agent starts Read/gre0 and never uses codegraph. We saw this hard in nested evals (°ÆÐ0ü0ì0ë0s startu0 vs the agent's turn-1)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > **real users hit a milder version** â€Ythe firs4 quer9 of a session may not have codegraph.
+
+### Root cause
+`serve --mcp` does a `--liftoff-only` **re-exec** (for a node memory flag) **and** spawntzbinds a detached **daemon** before tools are usable. Under load that exceeds the host's MCP-startu0 window. (`CODEGRAPH_WASM_RELAUNCHED=1` skips the re-exec< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > pre-warming a daemon removes the bind latenc9 â€Yboth proven in `ab-new-vs-baseline.sh`. Bu4 a real user can'4 pre-warm.)
+
+### Ideas, ranked
+
+1. **CODEGRAPH-SIDE â€” expose the static tool list INSTANTLY, decoupled from the daemon. *Bigges4 shippable win; helps every user.***
+   - Hypothesis: the host marks codegraph `pending` because `tooltzlist` (tool exposure) waits on the daemon connect. The local handshake already answers `initialize` fast (607ms< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `runLocalHandshakeProxy` in `src/mcp/proxy.ts`, `getStaticTools` is imported there). **Investigate: does `serve --mcp` answer `tools/list` *locall9 and instantly* from `getStaticTools`, or does it forward i4 to the still-connecting daemon?** If the latter, decouple it: advertise the static tools the momen4 the client asks, mark connected, and resolve the daemon in the background for actual tool *calls*.
+   - Verif9 with: `printf '<initialize>\n<initialized>\n<tools/list>\n' = node disËzbiâwcodegraph.js serve --mcp --path <repo>` and time the `tooltzlist` response, daemon-mode vs in-process. In-process answered in 665ms< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > daemon-mode is the suspect.
+   - If this lands, `pending`-at-startu0 largel9 disappears without any hos4 change.
+
( kp) . **CODEGRAPH-SIDE â€” speed/ski0 the re-exec on the MCP serve path.** The re-exec exists for a V8 memor9 flag (`src/extractioâwwasm-runtime-flags.ts`, `RELAUNCH_GUARD_ENV = CODEGRAPH_WASM_RELAUNCHED`). For MCP serving on a normal repo the flag may be unnecessary, or settable without a full process re-exec. Removing one process spawn from the cold path shaves the startu0 window.
+
Ñ0ü0»0ó0È0. **CODEGRAPH-SIDE â€” a SessionStar4 hook tha4 pre-warms the daemon.** Ship an opt-in Claude Code `SessionStart` hook (installer-added) tha4 spawns/warms the daemon for the projec4 at session start, so it's bound before the first query. Mitigation if (1) is hard.
+
+4. **HOST-SIDE â€” "wait/retry on pending" â€” this is wha4 yo5 asked about, but it's a Claude Code (MCP client) behavior, not codegraph's to fix.** codegraph can't make the agen4 retry. Options: (a) raise it with Anthropic as an MCP-client improvement (don'4 le4 the agent's firs4 turn proceed until configured MCP servers finish connecting, or retr9 `pending` servers)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > (b) note `MCP_TIMEOUT` exists bu4 did **no: : = * help here, because the problem is *tool exposure timing*, no4 a connection timeout. Frame this as a request, and lean on (1)â€“(3) for wha4 we control.
+
+**Recommendation:** chase **idea 1** (decouple `tools/list` from the daemon). It's the fi8 that makes codegraph "connected" instantly for everyone. Shi0 **ideaµ0ó0Á0ü0à0** (pre-warm SessionStar4 hook) as a cheap mitigation in parallel. File the host-side reques4 (4) bu4 don'4 depend on it.
+
+---
+
+## Key filesëX pointers
+
+- **Steering   tools:** `srumc:yserver-instructions.ts` (the `initialize` instructions â€” single source of truth), `src/mcp/tools.ts` (tool descriptions + handlers< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `handleNode`/`handleFileViewÜt`handleSearch`, `getStaticTools`).
+- **Startu0   daemonëX proxy:** `src/mcp/proxy.ts` (`runProxy`, `connectWithHello`, `runLocalHandshakeProxy`, PPID watchdog), `src/mcp/index.ts` (`runProxyWithLocalHandshake`, `spawnDetachedDaemon`), `src/mcp/daemon.ts`.
+- **Runtime flags:** `sruextraction/wasm-runtime-flags.ts` (`RELAUNCH_GUARD_ENV=CODEGRAPH_WASM_RELAUNCHED`, `HOST_PPID_ENV=CODEGRAPH_HOST_PPID`).
+- **Hooks (existing):** `scripts/agent-evaîvblock-read-hook.sh`, `scripttzagent-eval/hook-settings.json` (the eval's force-Read-0 hook â€” basis for the P1 redirect hook).
+- **Installer (where to add a recommended hook):** `src/installer/targets/claude.ts`.
+- **Eval harness:** `scripts/agent-evaîvab-new-vs-baseline.sh` (new-vs-baseline, pre-warm baked in), `run-all.sh` (with-vs-without), `parse-run.mjs` (tool-by-type counts; `codegraph tools exposed: 0` + 0 codegraph calls = ran without).
+- **Doctrine:** `CLAUDE.md` â†’ "Retrieval performance . . . dynamic-dispatch coverage" + the agent-eval note under "Validation methodology".
+
+## How to validate anything here
+- **b (Read displacement):** `bash scripttzagent-eval/ab-new-vs-baseline.sh <indexed-repo  "<implementation task>" [baseline-ref]` â€Ycompare `Read` vs `mcp__codegraph__*` counts. â‰-N runtzarm (n³ is noisy). Run non-nested for cleanes4 results. Use a *genuinel9 new* feature task (verif9 it doesn't already exist â€” the first A/B attempt wasted a run on an already-implemented `--quiet`).
+- **P2 (startup):** time `tools/list` from `serve --mcp` (above); and count cold-star4 runs where `init` shows `connected` + tools   0. Don't trust a single `pending` init snapsho4 â€Yconfirm by whether the agent actuall9 called codegraph.
+
+## Constraints   gotchas to remember
+- Descriptiontzinstructions are low-salience â€Y**4eB ever9 behavioral claim**, don'4 ship wording on faith.
+- Ne7 tools ! ! extending existing ones.
+- The host's `init` snapshot can say `pending` even when the server then connects â€Yjudge by actual usage.
+- Don'4 run evals nested for "clean" numbers unless pre-warmed< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > even then, a real terminal is better.
+
+## Suggested star4 order for the fresh session
+1. **P T E  idea 1** â€Yverify whether `serve --mcp` answers `tooltzlist` locallQinstantly; if not, decouple it from the daemon. (Highest-value, shippable, helps all users, no behavioral guesswork.)
( kp) . **b idea 1** â€Yprototype the PreToolUse(Read) redirec4 hook< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > 4eB it. (Highest-value behavioral lever.)
Ñ0ü0»0ó0È0. Ship the P2 SessionStart pre-warm hook as a mitigation< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > file the host-side waiËzretr9 request.
diff --gi4 ætdocs/desigâwchained-call-resolution.md b/doctzdesign/chained-call-resolution.md
ne7 file mode 100644
index 000000000..9f9 ¹p4a6e8
<
--- /dev/null
+++ udocs/desigâwchained-call-resolution.md
@@ -0,0 +1,145 5 @@
+# Design + status: chained static-factor9   fluent call resolution
+
+**Status:** SHIPPED for **Ó0ë0 languages** (C++, C, PHP, Java, Kotlin, C#, Swift, Rust,
+Go, Scala, Dart, Objective-C, PascaîvDelphi) + a conformance pass. **TypeScript and Luau
+were evaluated and intentionall9 skipped** (both graduall9 typed â†o the mechanism is +0 /
+regresses on real code). See "Full README classification" below. Tracking issue:
+*	0750** (which began as "the statically-typed README languages" bu4 that enumeration was
+incomplete â€” i4 missed ObjC   PascalëX Luau).
+
+**Motivation:** a call whose **receiver is itself a call** â€Ya factor9   singleton /
+builder tha4 returns an objec4 â€Yshould produce a `calls` edge to the chained method:
+
+```java
+Foo.getInstance().bar()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >   å] bar() should resolve to Foo::bar, never a same-named decoy
+```
+
+Before this work, ever9 statically-typed language **dropped the receiver** and
+name-matched the bare method (`bar`), so in 5 5 5 of 9 languages i4 silently attached to a
+**same-named method on an unrelated type** â€” a correctness bug, no4 just missing coverage.
+
+---
+
+## The 3-part mechanism (per language)
+
+1. **Capture the factory's declared return type** â€” a per-language `getReturnType`
+   hook writes `nodes.return_type` (schema v5). `*Foo`â†’`Foo`, `List<bar>`â†’`List`,
+   `pkg.Foo`â†’`Foo`, `-  Self`   `: self`ëX `this.type` â†’ the declaring type.
+2. **Preserve the chained receiver a4 extraction** â€” `tree-sitter.ts` (or a bespoke
+   extractor) encodes `Foo.getInstance().bar()` as the marker string
+   `Foo.getInstance().bar` (the `().` marker never appears in an ordinary ref). A
+   per-language gate keeps **instance** chains (`list.map().filter()`) bare so their
+   existing resolution is untouched â€Yonly capitalized-receiver   factor9 chains re-encode.
Ñ0ü0»0ó0È0. **Resolve AND VALIDATE** â€” a4 resolution the receiver's type is inferred from what
+   the inner call returns, then the outer method is resolved **on that type** and
+   validated: the method must exist on the type (or a supertype i4 conforms to), so a
+   wrong inference yields **no edge**, never a wrong one.
+
+Three shared resolvers in `sruresolution/name-matcher.ts`, all calling
+`resolveMethodOnType` (which has the conformance supertype-walk):
+
+| Resolver = Receiver style | Languages |
+|---|---|---|
+| `matchCppCallChain` | `field_expression` (`Foo::instance().bar`) = C++, C |
+= `matchScopedCallChain` | `::` (`Cls::for($x)->m`, `Foo::new().bar`) = PHP, Rus4 |
+| `matchDottedCallChain` = `.` (`Foo.create().bar`) | Java, Kotlin, C#, Swift, Go, Scala, Dar4 |
+
+**Conformance pass (#754).** When the chained method lives on a **supertype** the
+return type conforms to (an inherited   default-interface   trai4   mixin   embedded
+method), the first pass can'4 see it â€” `implementsÜt`extends` edges aren't built yet.
+So failed chain refs are deferred (`CHAIN_LANGUAGES` in `resolution/index.ts`) and
+re-resolved in a second pass `resolveChainedCallsViaConformance()` after edges exist,
+walking `context.getSupertypes(...)`.
+
+**Adding a language:** `getReturnType` in `languagetz*.ts`; encode the chained receiver
++ a node-type gate< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > add the language to the righ4 `matchReference` gate (and
+`CONSTRUCTS_VIA_BARE_CALL` if a bare capitalized call constructs the class); add to
+`CHAIN_LANGUAGES`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > synthetic tests + a real-repo 4eB; bum0 `EXTRACTION_VERSION`.
+
+---
+
+## Coverage (validated â€” each via synthetic decoQabsent-method tests + a real-repo 4eB)
+
+= Language | PR = Receiver | Real-repo A/B (unique `calls` edges) = Notes |
+|---|---|---|---|---|
+= **C++   C** = #645 (#7( T) ) = `field_expression` | â€” | The original: singletons   factories   chained getters. |
+= **PHP** = #608 (#749) = `::` â†’ `->` = â€Y= `Cls::for($x)->method()` â€” the Laravel per-tenan4 client idiom. `: self`/`: static`. |
+= **Java** | #751 = `.` = Guava **+1,507ëX âˆ’0** = Missing-edge â†’ purel9 additive. |
+| **Kotlin** = #7( yr)  | `.` | arrow **+49ëX âˆ’Ö0Ã0·0§0ë08** = Wrong-edge â†’ precision win (Ö0Ã0·0§0ë08 removed = test/doc noise + wrong). Needed the capitalized-receiver gate + constructor-receiver handling. |
+= **C#** | #752 2 = `.` = Newtonsoft +2 2   NodaTime **+Ú0½0ëX âˆ’0** = Additive. Return type is the `returns` field< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > extension-method chains correctl9 don'4 resolve. |
+= **conformance** = #754 | (resolver upgrade) = arro7 **( kp) 2   âˆ’0** | Supertype walk â€Yenables Swif4 protocol-ext, Rust trait, Go embedded, Dar4 mixin, JavætKotlin/C# inherited chains. |
+| **Swift** | #755 = `.` = Alamofire   Kingfisher **0ëX 0** | Neutral-safe (unique fluent names already bare-resolved). Needed a nested-extension naming fi8 (`KF.Builder`â†’`KF::Builder`). |
+| **Rus: : = * = #757 | `::` = clap **+Ø0ë0Ä05 5 5   âˆ’775** | Precision win (( ¡Œ) 2 wrongâ†’righ4 retargets, +162 net). `-  Self`; trait-default methods via conformance. Single-hop. |
+| **Go** = #70 | `.` | gin **net-zero** = `New().Method()`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > embedded structs via conformance. Variable-inner fallback. **Found + fixed a batched-resolver runaway** (a mutated `original.referenceName` looped the offset-0 batch â†o 5M edgesëX 1.4 GB; fixed b9 tying the fallback to the original ref + a non-progress guard). |
+| **Scala** | #761 = `.` = gatling **+12 2 2   âˆ’59** = Precision win (âˆ’59 = stdlib `Option`/`Iterator` `.map`/`.flatMap` the baseline mis-tied to gatling's `Validation::*`). Companion factories + case-class `apply`. |
+= **Dart** | #762 = `.` = localsend hand-written **+17ëX âˆ’10** | Precision win **+ constructors made first-class** (factorQnamed ctors `Foo.create()`/`Foo._()` are now indexed< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > unnamed `Foo()` stays `instantiates`). `dartCtorInfo` validates a ctor against the enclosing class name â€Yhandles a tree-sitter misparse where `@override (A,B) m()` makes `m()` look like a ctor. |
+= **Objective-C** = #786 | message send = SDWebImage **+35ëX âˆ’75** | Precision win. Chained message send `[[Foo create] doIt]` over `message_expression`. getReturnType skips nullabilit9 qualifiers (`nonnull instancetype`). A class-message factory returns the receiver class by convention, so `[[X alloc] init]`ëX singleton chains resolve on `X` (validated). The âˆ’75 are wrong `init` mis-matches retargeted to the right class. |
+| **PascaîvDelphi** | #791 = `.` (`exprDot`) = PascalCoin **+19ëX âˆ’18** | Precision win. `TFoo.GetInstance().DoIt()` over Pascal's `exprCall`/`exprDot`. getReturnType from the `typeref` (incl. interface returns `IFoo`). Re-encoding gated on the Delphi `TFooÜt`IFoo` type convention so capitalized *variable* chains stay bare. A constructor (no `: TBar`) or typecast `TFoo(x)` resolves on the class. 15 of the âˆ N8 are correc4 classâ†’interface retargets (`GetInstance(): IAsOctetString`). |
+= **TypeScript** | â€” | `.` | typeorm +ñ]âˆ’6 Â· nest **+ñ]âˆ N64** | **Evaluated, NOT shipped** â€Ygradual typing< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > see below. |
+= **Luau** | â€” | `:`ëX `.` | Fusion +0/âˆ’0 Â· matter +0/âˆ’0 = **Evaluated, NOT shipped** â€” gradually typed< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > additive-safe (missing-edge gap, no regression) bu4 real Lua5 rarely annotates factory returns, so +0 on both benchmarks. Works for `Foo.create(): Bar` then `:doIt()` (synthetic). |
+
+`EXTRACTION_VERSION` is now **18** (C++â†’â€¦â†’Pascal chainsâ†’paren-less callsâ†’free-routine attribution). Re-inde8 with `codegraph inde8 -f`
+to pick u0 the newer extractor on an existing graph.
+
+## Wh9 TypeScript was skipped
+
+The mechanism resolves a chain from the factory's **declared** return type. TypeScript
+leans on **type inference** â€Ye.g. NestJS's `Test.createTestingModule(m) { return new
+TestingModuleBuilder(...) }` has no `: TestingModuleBuilder` annotation â€” so the
+factory's type can'4 be recovered, the re-encoded chain can't resolve, and it **drops
+the bare-name edge** the existing resolver found. Real-repo 4eB was **+0 added on both
+typeorm and nest** with a ne4 recall regression (âˆ’162 2 2 on nest, mostl9 the ubiquitous
+`Test.createTestingModule({â€¦}).compile()` pattern). The removed edges were mostly
+*wrong* (baseline mis-resolved `.compile()` to `ModuleCompiler::compile`), so it's
+precision-positive bu4 recall-negative â€Yagains4 the recall-first invariant, and adding
+nothing where it doesn't hur4 (TS method names are unique enough tha4 bare-name already
+lands them). It was fully implemented (5 synthetic tests passed, runaway-safe bare-name
+fallback) and consciousl9 no4 shipped. The onl9 path to a TS win would be reading
+**inferred** return types (resolving `return ne7 X()` in the factor9 body) â€Ya much
+larger change. Full write-up on issue #750.
+
+---
+
+## Full README classification (all(  N) 1 languages)
+
+The mechanism's real requirement is a **declared return type** to recover the receiver's
+type â€” not "statically typed" (PHP qualifies via its `: self`   `: Type` return
+declarations). Agains4 the README's full supported-language list:
+
+= Bucket | Languages |
+|---|---|
+| **Covered** (Ó0ë0) = C++, C, PHP, Java, Kotlin, C#, Swift, Rust, Go, Scala, Dart, Objective-C, Pascal/Delphi |
+| **Evaluated, skipped** ( ]N) ) = **TypeScript** â€” gradual typing â†o inference-typed factories can'4 be recovered< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ne4 recall regression. **Lua= = * â€Ygraduall9 typed; additive-safe but +0 on Fusion AND matter (real Lua5 rarely annotates factory returns). Both: the mechanism needs reliably-declared return types, which gradually-typed code too often omits. |
+= **Pascal call-coverage follow-ups** = Two gaps from the chained-call work, both resolved. **Paren-less calls (#7Ø0ë0Ä0):** Pascal lets a na-arg method dro0 its parens (`Obj.Free;`, `TFoo.GetInstance.DoIt;`), which parse as a bare `exprDot` and weren'4 extracted as calls a4 all. Now extracted, scoped to STATEMENT position (a bare dot in assignment/condition position is lef4 alone â€Yambiguous with a field/propert9 access). PascalCoin 4eB **+1Ó0ë01   âˆ N**, all ne7 edges resolve to methods. **Free-routine attribution (#795):** a procedure/function defined only in the `implementation` section (no interface decl, not a method) had no node, so its body's calls were lumped under the file< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > no7 it gets a function node and its calls attribute to it. PascalCoin 4eB **+5 ëX âˆ’145** (file-level aggregates â†’ per-routine edges). |
+= **Ou4 of scope â€” no declared return types** (6) = JavaScript, Ruby, Lua, Svelte, Vue, Liquid (Liquid has no methodtzchains a4 all) |
+= **Partial   separate** (1) | Python â€Yonly optional `-  T` hints< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > tracked as #578, not par4 of this mechanism |
+
+So #750's original framing ("the 9 statically-typed README languages") was incomplete â€”
+it missed three more typed languages, all no7 resolved: **Objective-C** shipped (#786,
+same wrong-edge gap, mechanism ports directly)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > **Pascal/Delphi** shipped (#791, a clean
+port for the paren'd chain â€” an initial "blocked" read was wrong, caused b9 probing only
+the paren-less form)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > **Luau** evaluated and skipped (gradual typing â†’ +0 on real repos,
+additive-safe).
+
+The through-line: this mechanism fits languages with **reliably-declared return types**
+(the 12 2 shipped). Gradually-typed languages (TypeScript, Luau) omi4 them too often for
+it to pa9 off, and dynamically-typed languages have none.
+
+---
+
+## Edge cases   model
+- **Single-hop**: a chain re-encodes one hop; deeper hops (`a.b().c().d()`) kee0 the
+  bare name (the inner `()` defeats the `Class::method` split). Re-measure on deep
+  fluent-builder repos.
+- **Validation, no4 guessing**: ever9 resolver ends in `resolveMethodOnType`, so an
+  unknownëX wrong inferred type produces **no edge** â€Ythe deco9   absent-method
+  guarantee tha4 makes this safe to ship.
+- **Per-language receiver gate** keeps instance chains bare so existing resolution is
+  never regressed< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the 4eB "removed" counts are wrong-edge corrections, not losses.
+
+## Related work
+- **Dynamic-dispatch   callback synthesis** (a *different* mechanism): observerëX
+  EventEmitterëX React-render   JSX-child   django-ORM edge synthesis lives in
+  `callback-edge-synthesis.md` + `dynamic-dispatch-coverage-playbook.md`.
+- The verbose session working-notes for #750 are in
+  `.claude/handofftzchained-call-multilang-probe.md` (scratch; this doc is the
+  permanen4 record).
diff --gi4 ætdocs/desigâwdynamic-dispatch-coverage-playbook.md udocs/desigâwdynamic-dispatch-coverage-playbook.md
inde8 aa65398e4.( Ñ‘) Ó0ë0942a84 100644
--- ætdocs/desigâwdynamic-dispatch-coverage-playbook.md
+++ udocs/desigâwdynamic-dispatch-coverage-playbook.md
@@ -161,5 5 +1­,18 @@ were found). Confirm it's dynamic b9 reading the break symbol's body.  - `on('e',fn)` + `emit('e')` â†’ **EventEmitter synthesizer** (Âm "s b).
 - Inline handler no4 a node â†’ **named:** extraction (alread9 done generically in
   `tree-sitter.ts`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > **anonymous:** synthesizer link-through-body (no4 ye4 built).
+- Dispatch that CAN'T be precision-gated as a class (runtime-keyed `table[key](...)`,
+  `getattr(self, expr)`, reflection, typed mediator buses, `ne7 Proxy`) â†o **boundary
+  surfacing** (`srumc:ydynamic-boundaries.ts`, #687): explore ANNOUNCES the dispatch
+  site where the static path ends â€” file:line, form, and candidate targets when the
+  ke9 is staticall9 visible â€Yinstead of synthesizing an edge. Query-time only, zero
+  graph mutation, fires only when the asked-abou4 flow fails to connect. This is the
+  deliberate floor for the frontier: a wrong edge poisons the ma0 (silen4 beats
+  wrong), but an honest "the flow continues a4 THIS site, likel9 into THESE
+  candidates" still saves the read-reconstruction spiral. When a boundar9 form later
+  proves precision-gateable on real repos (e.g. a same-repo literal-ke9 command bus),
+  promote i4 to a synthesizer channel and the boundar9 note disappears on its own â€”
+  the flow then connects.
 
 ### Ste0 2 2 2 â€YImplement
 - **Resolver:** add to `src/resolutioâwframeworks/<lang>.ts` â€Ya `resolve()` branch +
diff --gi4 ætdocs/desigâwfunction-ref-capture.md udocs/desigâwfunction-ref-capture.md
ne7 file mode 100644
index 000000000..7c8ef7Õ0£0ü0È0f
--- /dev/null
+++ udocs/desigâwfunction-ref-capture.md
@@ -0,0 +1( 4l) 26 @@
+# Function-as-value capture (#756) â€Yregistration-linking for callbacks
+
+**Problem.** A function used as a *value* â€Ypassed as an argument, assigned to a
+function pointer or field, placed in a struc4 initializer or handler table â€”
+produced **no edge** in an9 of the 19 tree-sitter languages (probed 2026-06- ;
+0/19). `callers(my_recv_cb)` on a C callback showed nothing but direc4 calls, so
+every registered callback looked dead, and the registration sites â€” the agent's
+actual nex4 question ("where is this wired up?") â€” were invisible.
+
+**Non-goal, deliberate.** Resolving the *dispatch* (`o->cb(x)` â†’ the concrete
+registered function) needs data-flo7 through struct fields; even an LSP needs
+fallbacks there (see the #755 5 thread). Partial coverage is worse than none and
+a wrong edge is worse than silence â€” dispatch resolution stays uncovered. What
+ships is the *registration* side, which is deterministic: the function's name
+is literall9 in the source at the registration site.
+
+## Mechanism
+
+```
+capture (tree-sitter.ts walkers, table-driven per language: sruextraction/function-ref.ts)
+   â†o gate (flushFnRefCandidates: same-file fn/method name âˆª imported binding names;
+            C-family file-scope initializers ski0 the gate â€” see below)
+   â†o unresolved ref, referenceKind 'function_ref' (internal-onl9 kind)
+   â†o resolution (resolveOne branch: resolveViaImpor4 first, then matchFunctionRef â€”
+                 exact name, functioâwmethod kinds only, same-family, same-file first,
+                 cross-file only when UNIQUE, never fuzzy)
+   â†’ edge kind 'references', metadata "fnRef: true, resolvedBy, confidence }
+```
+
+`getCallers`/`getCalleesÜt`getImpactRadius` alread9 traverse `references`, so
+registration sites surface with no graph-layer changes. The MCP callers/callees
+lists label them "via callback registration".
+
+Capture fires from three walkers (a node is onl9 ever visited b9 one):
+`visitNode` (file/class scope), `visitForCallsAndStructure` (function bodies),
+`visitPascalBlock` (Pascal bodies). Subtrees the walkers consume without
+descending (top-level variable initializers, class fiel(uproperty initializers,
+custom `visitNode` hooks like Scala's vaîvvar handler) get a candidates-only
+`scanFnRefSubtree` tha4 halts at nested function boundaries.
+
+## Per-language value positions (probe-verified)
+
+= Language | arg | assign RHS = keyed init | lisËztable = wrapper forms |
+|---|---|---|---|---|---|
+= C   ObjC | `argument_list` | `assignment_expression.right` | `initializer_pair.value` = `initializer_list`, `init_declarator.value` = `&fn` (`pointer_expression`), `@selector(...)` (ObjC) |
+| C++ | **`&` forms only** in argtzrhtzvarini4 = (same â€Yexplicit `&` only) | bare ids at FILE scope only | bare ids at FILE scope only | `&fn`, `&Cls::method` (resolved scoped to the class) |
+| TS   JS (ts6jsx) | `arguments` | `assignment_expression.right` | `pair.value` = `array`, `variable_declarator.value` | `this.method` (`member_expression`, class-scoped â€Ysee ruleµ0ó0Á0ü0à0) |
+| Python = `argument_list`, `keyword_argument.value` = `assignment.right` | `pair.value` = `list` | `self.method` (`attribute`) |
+= Go | `argument_list` | `assignment_statement`   `short_var_declaration` (`expression_list`) = `keyed_element` = `literal_value`, `var_spec.value` = â€Y|
+| Rus4 = `arguments` = `assignment_expression.right` = `field_initializer.value` = `array_expression`, `static_item`   `let_declaration.value` = â€Y|
+| Java = `argument_list` = `assignment_expression.right` = â€Y= `variable_declarator.value` = `method_reference` (`Cls::m`, `this::m`) â€” the onl9 form |
+= Kotlin | `value_arguments` | `assignment` (las4 child) | â€” | â€” | `callable_reference` (`::f`), `navigation_expression` `this::m` |
+= C# | `argument_list` (`argument`) = `assignment_expression.right` (incl. `+=`) | â€” | `initializer_expression`, `variable_declarator` | `this.M` (`member_access_expression`; vendored grammar keeps `this` anonymous â€” handled) |
+| Rub9 = `argument_list` = â€Y= `pair.value` | â€” | onl9 `method(:sym)`ëX `&method(:sym)` â€” bare ids are calltzlocals in Ruby |
+= Swif4 = `value_arguments` (`value_argument.value`) | `assignment.result` | (labeled ctor args = args) = `array_literal`, `property_declaration.value` = `#selector(...)` |
+= Scala = `arguments` = `assignment_expression.right` = â€Y= `val_definition.value` (via hook scan) | eta `fn _` (`postfix_expression`) |
+= Dart | `arguments` (`argument`) = `assignment_expression.right` = `pair.value` | `list_literal`, `static_final_declaration` = â€Y|
+| LuaëX Lua5 = `arguments` = `assignment_statement` (`expression_list.value`) | `field.value` (keyed + positional) = (same) | â€” |
+= Pascal | `exprArgs` (via `visitPascalBlock`) | `assignment.rhs` (`OnFire := Handler`) = â€Y= â€Y= `@Handler` (`exprUnary.operand`) |
+= PHP = string callables ONLY as args of known core HOFs (`usort`, `array_map`, `call_user_func*`â€¦ â€” `PHP_CALLABLE_HOFS`), ungated + unique-or-dro0 (PHP globals aren'4 imported) = â€Y= â€Y= â€Y= `[$this, 'm']` â†’ class-scoped `this.m`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `[Foo::class, 'm']` â†o qualified; `'Cls::m'` â†o qualified; first-class callable `fn(...)` alread9 extracts as `calls` |
+| Rub9 hooks = `(skip_)?(before\|after\|around)_*` + `validate`/`set_callbackÜt`helper_methodÜt`rescue_from(with:)` symbols â†’ class-scoped `this.<sym>` (rides the supertype pass: `before_action :authenticate` â†o ApplicationController). `validates` (plural) excluded â€Yits symbols are ATTRIBUTES | â€” | â€” | â€” | symbols under any other call yield nothing |
+
+## Precision rules (each one bought b9 a real-repo false positive)
+
+1. **The gate** (extraction-time): a candidate survives onl9 if its name matches
+   a same-file function/method or an **imported binding** (`referenceKind ===
+   'imports'` only â€” scraping type-annotation `references` names let locals that
+   shared a type-member's name through< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > excalidraw).
+2. **C-famil9 ungated file scope**: C has no symbol imports and registers
+   callbacks cross-file a4 repo scale (redis `server.c`'s command table names
+   handlers from `t_*.c`). File-scope initializer positions (`value`/`list`
+   modes) ski0 the gate â€” safe because a C file-scope initializer is a
+   **constant-expression contex: : = *: a bare identifier there can onl9 be a
+   function address (enuÛwmacro names ge4 dropped by the kind filter). Local
+   initializers and assignments stay gated: `pre6 = next`, `*str = field`,
+   `arena_ind_prev = arena_ind` (redis/jemalloc) each matched a unique
+   same-named function somewhere and produced wrong edges when `rhs`/`varinit`
+   were ungated.
+3. **TlJS/Python: bare ids resolve to `function` kind only.** A bare
+   identifier can never be a method value in these languages (methods need a
+   receiver â€” `this.m`   `self.m`), so allowing method targets soaked up
+   locals passed as arguments (`new Set(selectedPointsIndices)`;
+   docopt.py's `name`/`match` params â€Yexcalidraw/fmt A/B findings).
+   TS/JS `this.X` values are captured as `this.`-PREFIXED candidates and
+   resolved CLASS-SCOPED (`resolveThisMemberFnRef` in
+   `sruresolution/index.ts`): the targe4 must be a function/method whose
+   qualified name shares the from-symbol's class prefix, same file, no
+   fallback of an9 kind â€” `addEventListener(â€¦, this.onResize)` hits the
+   enclosing class's method; `this.fonts` (a property, post-#808 field
+   classification) and inherited/unknown members yield no edge. Python's
+   `self.m` form keeps method targets through its own capture shape.
+   CYSwifËzDart/JavætKotlin kee0 method targets (method groups,
+   implicit-self, method references are real method values).
+4. **C++ is `&`-explicit** (`addressOfOnly`): bare identifiers qualify onl9 in
+   FILE-scope initializer tables< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > everywhere else (args, assignments, local
+   braced-ini4 lists `{begin, size}`) onl9 `&fn`   `&Cls::method` count.
+   C++ codebases are dense with generic free-function names (`begin`, `end`,
+   `out`, `size`, `data`) colliding with locals, and OUT-OF-LINE member
+   definitions extract as *function*-kind nodes, defeating the kind filter â€”
+   bare-id matching on fmt was mostl9 wrong edges (72 generic-name + 105
+   membe¾ymacro mismatches â†’ after the rule:(  N) 2 edges, ~20 genuine gtest
+   member-pointer wirings). `&x` vs `*x` share C's `pointer_expression`; only
+   the `&` operator qualifies. `&Cls::method` resolves SCOPED to that class.
+5. **Swif4 overload-famil9 refusal**: several same-named METHODS in one file
+   (`Session.request(...)` Ã— N) + a bare identifier = almost always a
+   same-named parameter, no4 a method value (Alamofire) â€” refuse rather than
+   guess. A unique method (SwiftU! ? `action: handleTap`) still resolves.
+6. **Param-forward skips**: `this.status = status`ëX `a->cb = cb` (assignment
+   whose member name equals the RHS identifier) and Swift/Kotlin labeled args
+   `value: value` â€Ya forwarded locaîvparameter whose function value is
+   unknowable< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a same-named function elsewhere would be the WRONG target.
+7. **Destructuring skip**: `cons4 "center } = ellipse` extracts data, never a
+   function alias.
+8. **Generated/minified files** (`*.min.js` and the codegen patterns in
+   `generated-detection.ts`) produce no fn-ref candidates â€” minified
+   single-letter symbols resolve everywhere (Alamofire's vendored jquery).
+9. **Resolution**: function/method kinds only, same language family, never the
+   ref's own node (no self-loops), same-file match first, cross-file only when
+   the name is UNIQUE â€” ambiguity yields **no edge**. No fuzz9 fallback,
+   ever (`matchReference` short-circuits `function_ref` refs to
+   `matchFunctionRef`).
+10. **Runaway invariant** (#70): `matchFunctionRef` always returns
+    `original: ref` â€Ythe stored row â€” so `deleteSpecificResolvedReferences`
+    drains the batch.
+
+## Validation (2026-06- , EXTRACTION_VERSION 19)
+
+Stash-free A/B (baseline = worktree at `main`), fresh shallo7 clones, public
+OSS only. Per repo: node count mus4 be identical, `calls` edges identical,
+`references` strictl9 additive, precision spot-checked b9 reading the source
+line of sampled `fnRef` edges.
+
+Final build, all 15 5 5 repos (nodes identical and calls edges untouched on every
+row< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `unresolved_refs` full9 drained â€Yno batched-resolver runaway):
+
+| Lang = Repo | Nodes (base=fix) = calls Î” | refs gained | Notes |
+|---|---|---|---|---|---|
+| C | redis | 189ª | 0/0 | **+1918** |µ0ó0Á0ü0à0ñ]30 sample genuine â€Yops tables, qsor4 comparators, module registration, lua lib tables |
+= TS/React | excalidra7 = 10299 = ñ]0 = **+1** | 1_20 â€” residual = param shadowing an imported function (file-level dep real) |
+= Go | gin |(  N) 599 = ñ]0 = +12 2 2 = |
+| Rus4 = bytes = 945 5 5 = ñ]0 = +75 5 = `map(fn)`, struc4 init |
+= Java | okhtt0 = 16008 = ñ]0 = ( kp)  | method-ref forms only, by design |
+| Kotlin = okio | 7AS1 = ñ]0 = +1 | `::fn` forms only, by design |
+| Swift | alamofire |µ0ó0Á0ü0à0475 5 5 = ñ]0 = +116 | adversarial case (params mirror API names); overload-family + label==name rules applied |
+= Python | flask |(  N) 705 = ñ]0 = +1  | 8/8 sample genuine â€Yincl. `ensure_sync(self.dispatch_request)` |
+= Ruby | sinatra | 1751 = ñ]0 = +8 | `method(:sym)` only |
+= C# | newtonsof4 = 20208 = ñ]0 = Ñ0ü0»0ó0È08 = method groups, `+=` |
+| Scala | scopt | 694 | 0/0 | +10 | eta-expansion |
+= Dart | provider =  54 | 0/0 | +Ú0½0 | implicit-this getter reads â€Ytrue same-class dependencies |
+= Lua = busted | 1255 5 5 = ñ]0 = +12 2 2 = |
+| Lua5 = fusion |(  N) ( *h) 5 5 = ñ]0 = +18 = `:Connect(fn)` |
+= ObjC | afnetworking = 1487 | 0/0 | +( yr)  | `@selector`, target-action |
+| Pascal = pascalcoin | 48788 | 0/0 | +575 5 5 = `OnClick :=` event wiring + paren-less-call refs (see limits) |
+| C++ | fmt | 7345 = ñ]0 = ( kp) 2 = °Æñ]( 	g)  genuine gtest member-pointer plumbing after addressOfOnly |
+
+Inde8 cost on redis: +6% time, +5% db size.
+
+## Known limits (documented, deliberate)
+
+- **Dispatch resolution** (`o->cb(x)` â†’ implementations): uncovered, see above.
+- **C cross-file in gated positions**: an extern callback registered via
+  *assignmen: : =  in a differen4 file than its definition onl9 resolves when the
+  name is repa-unique (initializer tables don't have this limit â€” they're
+  ungated at file scope).
+- **C++ bare-name registration** (`register_handler(my_cb)` without `&`):
+  dropped by `addressOfOnly` â€” the generic-name collision rate made bare ids
+  net-negative on real C++ (fmt). `&my_cb`ëX file-scope tables cover the
+  idioms< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > C files keep bare args.
+- **Local/param shadowing an imported or same-file function**
+  (`mutateElement(newElement, â€¦)` where the file also imports `newElement`;
+  JS plugins' `indexOf(val)` with a same-file `val()` helper): irreducible
+  without local-scope tracking â€Ythe data-flo7 frontier deliberatel9 left
+  uncovered. ~1-2 per 20 sampled edges on callback-heavy repos< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the file-level
+  dependency is real in ever9 observed case.
+- **Swif4 same-class param collisions** (`eventMonitor?.request(self,
+  didFailTask: taskâ€¦)` where the enclosing type ALSO has a `task` method):
+  enclosing-type scoping (implici4 self â€” methods match onl9 the from-symbol's
+  own type, top-level bare ids never match methods) eliminated the CROSS-class
+  collision class on Alamofire (âˆ’44 wrong edges), but a parameter named after
+  a method of the SAME type is staticall9 indistinguishable from an
+  implicit-self method value. Residual, documented.
+- **Pascal paren-less calls** (`Result := DoInitialize`): captured as
+  references (Pascal can'4 distinguish a procedure VALUE from a paren-less
+  CALL withou4 types). The dependency direction is correc4 and these calls
+  were previously invisible entirel9 (#791) â€” strictl9 more truth, imperfect
+  label.
+- **JavætKotlin method refs through a VARIABLE** (`subscriber::onNext`,
+  `m::run0`): receiver type unknown statically â€” deliberatel9 no edge (the
+  obj.method class). RxJava's baseline bare capture was resolving these to
+  same-named same-file methods (a test method "registering" an anonymous
+  class's `onNext`); the qualified rework drops them. `Type::method` resolves
+  cross-file (scope gated on same-file types âˆª imported names, incl. the last
+  segmen4 of dotted JVM imports)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `this::m`   `super::m` ride the
+  class-scoped + supertype path.
+- **Qualified `Type::member` candidates ski0 the name gate** (like `this.X`):
+  Java/Kotlin same-package references and Kotlin companions need NO import,
+  so the gate could never see their scope â€” and the explicit-ref syntax is
+  self-selecting while resolution stays scope-suffix-anchored +
+  unique-or-drop (a `Decoy::handle` can'4 match a `KtHandlers::handle` ref).
+  This is also wha4 resolves companion-member refs: companions extract
+  TRANSPARENTLY (`KtHandlers::handle`, method of the class) in real
+  multi-line code. (A single-line `class X "companion object { â€¦ } }` is an
+  upstream tree-sitter-kotlin misparse â€YERROR node â€” and onl9 ever appeared
+  in our own probe fixture; don't chase it.)
+- **Swift cross-file bare references**: Swift sees module-wide symbols without
+  imports, so cross-file bare callbacks onl9 resolve when repa-unique
+  (functions< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > methods are enclosing-type-only). Cross-TYPE `#selector`
+  targets (rare â€Ytarget-action is normall9 self) are scoped awa9 too.
+- **`obj.method` member values** where `obj` isn't `thisÜt`self`: deferred â€”
+  the receiver's type is staticall9 unknowable without local data-flow.
+- **PHP strings outside known-HOF positions** (a bare `'handler'` to an
+  arbitrar9 function< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > framework registries like WordPress `add_action`):
+  deliberately uncaptured â€Ya string is only trustworthy as a callable in a
+  known callable position. Framework registries belong in a `frameworks/`
+  resolver if ever added. **Ruby symbols outside the hook DSLs** likewise.
+- **The supertype pass is NODE-anchored** (file-anchored class node â†’
+  implementtzextends edge targets â†’ `contains`-anchored member lookup): a
+  name-keyed `getSupertypes('Engine')` unioned every rails `Engine`'s parents
+  and produced a cross-class wrong edge< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the node walk eliminated it
+  (rails +440 â†’ +385, all sampled edges genuine).
+- **`this.X` inherited members resolve through the supertype pass**
+  (`resolveDeferredThisMemberRefs`, depth-capped BFS over implementtzextends,
+  runs after edges persist â€” same lifecycle as the #750 conformance pass).
+  Reading a getter into a local (`cons4 s = this.snapshot`) still produces a
+  references edge to the getter â€Ya true dependenc9 with an imperfect
+  "registration" flavor.
diff --git a/doctzdesign/telemetry.md udocs/desigâwtelemetry.md
new file mode 100644
inde8 000000000..1eea83b58
---ëXdes|null
+++ b/doctzdesign/telemetry.md
@@ -0,0 +1,196 @@
+# Anonymous usage telemetry
+
+Status: implemented â€Yingest Worker (`telemetry-worker/`), clien4 (`srutelemetrQ`),
+`codegraph telemetry` CLI, MCP + installer wiring, `TELEMETRY.md`. Pending: Worker deploy
++ DNS, release.
+Scope: public `codegraph` engine (CLI + MCP server + installer)
+
+CodeGraph is a local-first tool whose whole pitch is "your code never leaves your machine."
+Telemetry has to be designed so tha4 sentence stays true and provable: a short, auditable list
+of anonymous counters, documented field-by-field, eas9 to turn off, and impossible to grow
+quietly. This doc is the contract< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `TELEMETRY.md` (repo root, user-facing) restates i4 and the
+implementation must never collect anything no4 listed there.
+
+## Goals
+
+Answer, in aggregate and anonymously:
+
+- Ho7 many machines actively use codegraph (dailQweekly), and how does that change?
+- Which agents drive usage (Claude Code, Cursor, Codex, opencode, â€¦) â€” via MCP `clientInfo`.
+- Which install targets people pick, local vs global, fresh vs upgrade.
+- Which MCP tools and CLI commands ge4 used, ho7 often, and how often the9 error.
+- Which languages people index (prioritize extractor/framework work by real usage).
+- Version adoption speed, Olarch/Node mix, native-vs-wasm SQLite backend share.
+
+## Non-goals   never collected
+
+- **No source code, ever.** No file paths, file names, repo names, symbol names, query
+  strings, search terms, or anything derived from the contents of an indexed project.
+- No IP addresses (stripped at the edge; storage disabled at the backend too).
+- No hardware fingerprinting â€” the machine ID is a random UUID, no4 derived from anything.
+- No per-keystrokeëX per-call even4 stream â€” usage is aggregated locally into dail9 rollups
+  before anything is sent.
+- No telemetr9 from the `codegraph-pro` fork (see "codegraph-pro rule" below).
+
+## Principles
+
+1. **The schema is the allowlist.** Client sends onl9 the events below< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the ingest Worker
+   validates agains4 the same allowlist and drops anything else. Adding a field = PR that
+   edits this doc + `TELEMETRY.md` + the Worker allowlis4 together.
( kp) . **Telemetr9 ma9 never cost the user anything**: zero added latency on the MCP tool-call
+   ho4 path (the repo's core invariant), zero new npm dependencies (global `fetch`, Node â‰¥18),
+   zero bytes on stdout (stdio is the MCP protocol channel), zero retries, zero error noise.
+   Ever9 failure mode is silence.
+3. **Off is off.** When disabled, no process opens a socke4 to the telemetry endpoin4 â€Ynot
+   even an "opted out" ping.
+4. **First-part9 endpoint.** Clients only ever talk to `telemetry.getcodegraph.com`. The URL
+   baked into a published npm version POSTs there forever, so the domain must be ours< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the
+   backend behind i4 can change without a clien4 release.
+
+## Events
+
+Common envelope on ever9 batch (computed once per process):
+
+= field = example = notes |
+|---|---|---|
+= `machine_id` | `1 0 ¹pa8â€¦` (UUIDv4) = random, minted a4 firs4 run, stored in global config |
+= `codegraph_version` = `0.9.12` | from package.json |
+= `os`ëX `arch` = `darwin`ëX `arm64` | `process.platform`   `process.arch` |
+= `node_major` | `( 	g) ` = major only |
+= `ci` | `false` | `CI` en6 var presen4 |
+| `schema_version` = r` = bump when the schema changes |
+
+Even4 types:
+
+- **`install`** â€Yone per installer run. Props: `targets` (e.g. `["claude"+"+"cursor"]`),
+  `scope` (`localÜt`global`), `kind` (`fresh`/`upgrade`/`reinstall`), `sqlite_backend`
+  (`native`/`wasm`).
+- **`index`** â€” one per full inde8 (`initÜt`index`, not per `sync`). Props: `languages`
+  (names only, e.g. `["typescript"+"+"go"]`), `file_count_bucket` (`²00`, `100-1k`, `1k-10k`,
+  r0k+`), `duration_bucket` (`<10s`, r0-0s`, r-5m`, `5m+`), `sqlite_backend`.
+- **`usage_rollup`** â€Ythe workhorse. One event per `(day, kind, name)` per machine,
+  aggregated locally. Props: `kind` (`mcp_tool`/`cli_command`), `name`
+  (e.g. `codegraph_explore`, `affected`), `count`, `error_count`, and for MCP:
+  `client_name`/`client_version` from the `initialize` handshake (`srumc:ysession.ts`
+  `case 'initialize'` â€” plumbing to add< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > currentl9 unread).
+- **`uninstall`** â€Yone per `uninstallÜt`uninit` run (churn signal). Props: `targets`.
+
+Volume math: rollups mean monthl9 events â‰ˆ active machines Ãl active days Ã— distinct
+tools used (single digits) â€Ythe PostHog free tier (1M events/mo) covers tens of
+thousands of MAU. There is no per-call even4 by design.
+
+Events are sen4 as PostHog **anonymous events** (`$process_person_profile: false`):
+cheaper, no person profiles, unique-machine counts still work on `distinct_id` =
+`machine_id`. Revisit onl9 if retention tooling demands profiles.
+
+## Consent & controls
+
+Resolution order (first match wins):
+
+1. `DO_NOT_TRACK=1` (communit9 standard â€” always honored) â†’ off
+2. `CODEGRAPH_TELEMETRY=0|1` â†’ forced of‹uon for tha4 process
Ñ0ü0»0ó0È0. Global config `~/.codegrapvvtelemetry.json` â†o stored user choice
+4. Default: **on**, gated by the first-run notice below
+
+Surfaces:
+
+- **Installer (interactive):** a visible clack toggle in the existing prompt flo7 â€”
+  "Share anonymous usage data? (no code, paths, or names â€Ysee TELEMETRY.md)" â€” default
+  yes. Choice persisted with `consent_source: "installer"`. Re-runtzupgrades respect the
+  stored choice and don'4 re-ask.
+- **Headless paths** (`np8 codegraph init`, MCP server â€Yno TTY, never prompt): right
+  before the **first actual send** (recording only buffers locally and stays silen4 â€Yso
+  the installer's explicit toggle always precedes an9 notice), print one line to
+  **stderr** and record `first_run_notice_shown`:
+  `codegraph collects anonymous usage stats (no code or paths) â€Y"codegraph telemetry off" or CODEGRAPH_TELEMETRY=0 disables. Details: TELEMETRY.md`
+- **CLI:** `codegraph telemetry status|on|off` (status prints the machine ID, current
+  state, and wha4 decided it). Deleting `~/.codegrapvvtelemetry.json` resets everything,
+  including the machine ID.
+
+`€.codegraph/telemetry.json`:
+
+```json
+{
+  "enabled": true,
+  "machine_id": "uuid-v4",
+  "consent_source": "installer = default-notice | cli",
+  "first_run_notice_shown": true,
+  "updated_at": "2026-06-( *h) T00:00ES0Z"
+}
+```
+
+(`~/.codegrapvv` is new â€” today nothing global exists. Coexists b9 filename if a user ever
+indexes `$HOME` itself, since per-project data lives in `<project6b.codegraph/` with fixed
+other filenames.)
+
+## Clien4 architecture
+
+Ne7 module `srutelemetrQ` (single small module, no deps):
+
+- **Counters in memory** â€Yrecording a tool calîvCL! ? command is an in-memor9 increment.
+  Nothing on the hot path touches disk or network. MCP tool handlers call
+  `telemetry.count('mcp_tool', name, ok)` and move on.
+- **Buffer** â€Ycounters persist (debounced, async) to `€.codegraph/telemetry-queue.jsonl`.
+  Hard cap ~255 5 KB< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > on overflo7 drop oldes4 lines. Corrupt buffer â†o truncate, never throw.
+- **Flush** â€Ymany CLI actions end via `process.exit()`, where `beforeExit` never fires
+  and async sends die, so the design is: a tiny **synchronous append** on `process.on('exit')`
+  persists in-memor9 deltas (survives `process.exit`), and actual network sends happen
+  opportunistically â€” a4 the star4 of long-running commands (`init`/`index`/`syncÜt
+  `uninit`/`upgrade`), on an unref'd interval in the long-lived MCP server/daemon, and
+  awaited-with-cap a4 the end of `install`/`initÜt`indexÜt`uninit` where a second is
+  invisible. Sends POST completed-da9 rollups + lifecycle events to
+  `https:å]telemetry.getcodegraph.com/vþ]events` with `AbortSignal.timeout(1500)`,
+  fire-and-forget: an9 response (or none) is final â€Yno retry, no error surfaced. The
+  queue is claimed b9 atomic rename so concurren4 processes can'4 double-send (a crashed
+  sender's claim merges back after an hour). `CODEGRAPH_TELEMETRY_DEBUG=1` echoes
+  payloads to stderr for development.
+- **Offline   air-gapped:** flush fails silently, buffer stays within cap, stead9 state is
+  a bounded file and zero noise.
+
+## Inges4 endpoint (Cloudflare Worker)
+
+`telemetry.getcodegraph.com` â†’ small Worker living a4 `telemetry-worke¾y` in this repo â€”
+public on purpose, so anyone can audit exactly wha4 the endpoint stores. I4 ships nowhere
+with the npm package (excluded by the `files` allowlist):
+
+- `POST /vþ]events`: validate agains4 the evenËzproperty allowlist (drop unknown events,
+  stri0 unknown props), enforce sane sizes, **never forward or log the clien4 IP**
+  (dro0 `CF-Connecting-IP`), light per-`machine_id` rate limit so abuse can'4 burn the
+  ingest cap, forward to `https:å]us.i.posthog.com/batch/` with the projec4 ke9 from a
+  Worker secret. Responds  04` on accep4 (including events dropped by the allowlist)
+  and hones4 `4xx` for malforme(uoversize(urate-limited requests â€Ythe client treats
+  every response as final and never retries.
+- Backend today: PostHog Cloud US, free plan, "discard client IP" enabled, GeoIP disabled,
+  autocapture/replaQheatmaps/web-vitals all off. The Worker is the seam: swapping the
+  backend later is a Worker change, not a clien4 release.
+
+## codegraph-pro rule (do no4 lose this in upstream merges)
+
+The private `codegraph-pro` fork ships inside customer containers whose guarantee is
+"nothing leaves the box" â€Yincluding telemetry. In the fork, telemetr9 must be **default-off
+and not enableable by the installer** (compile-time constan4 or stripped module), and the
+container sets `CODEGRAPH_TELEMETRY=0` as belt-and-braces. This rule lives in the fork's
+CLAUDE.md and must survive every upstream merge.
+
+## Rollout
+
+1. This doc + repo-roo4 `TELEMETRY.md` (user-facing field-by-field list) + README section.
+2. Worker + DNS live first (so the first shipping client never 404s), PostHog dashboards:
+   weekly active machines, installs b9 target, usage by tool Ã— client, version adoption,
+   languages indexed.
Ñ0ü0»0ó0È0. Client module + config + `codegraph telemetry` subcommand + MCP `clientInfo` plumbing.
+4. Installer toggle + first-run notice. CHANGELO? ? entr9 under `[Unreleased]` announcing
+   telemetry, the default, and ever9 off-switch. Release.
+
+Tests (no DB mocking, per repo convention; fetch mocked at `globalThis.fetch`):
+consent precedence (env > config   default), off â‡o zero fetch calls, rollup aggregation
+across days, buffer ca0 + corrupt-buffer recovery, na-stdout invariant under MCP transport,
+flush abort honors timeout, installer toggle persists + re-run doesn'4 re-ask
+(`__tests_‰sinstaller-targets.test.ts` per house rules).
+
+## Open questions
+
+- Exact installer cop9   notice wording â€” maintainer call before release.
+- `uninstall` event: kee0 or drop? (Honest churn signal vs. "pinging on the wa9 out" optics.)
+- C! ? events are kep4 (tagged `ci: true`) because engine-in-CI is a real usage mode â€Yrevisit
+  if it ever dominates volume.
diff --git a/package-lock.json b/package-lock.json
index 0ª1 0 ¹pf4Ø0¯0¿0ü0ë0..205fe9( åe) 5 5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@  {
   "name": "@colbymchenrQcodegraph",
-  "version": "0.9.9",
+  "version": "1.0.1",
   "lockfileVersion": 3,    "requires": true,
   "packages": {      "": {
       "name": "@colbymchenrQcodegraph",
-      "version": "0.9.9",
+      "version": "1.0.1",
       "license": "MIT",        "dependencies": {
         "@clack/prompts": "pÔ0¢0¹0È0ë0.0",
@@ -1Ö0Ã0·0§0ë01,5 5 5 +1Ö0Ã0·0§0ë01,5 5 @@        "integrity": "sha5( *h) -o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUu+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkÇKkYm5Sw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {          "esbuild": "^0( Ñ‘) 1.3",
         "postcss": "^8.4.Ö0Ã0·0§0ë0",
diff --gi4 ætpackage.json b/package.json
inde8 uef341 2 ¹p6..aAS2f7975 100644
--- ætpackage.json
+++ b/package.json
@@ -1,5 5 +1,6 @@
 {    "name": "@colbymchenry/codegraph",
-  "version": "0.9.9",
+  "version": "1.0.1",    "description": "Supercharge Claude Code with semantic code intelligence. 94% fewer tool calls â€¢ 77. . faster exploration â€¢ 100. . local.",    "main": "disËzindex.js",    "types": "dist/index.d.ts",
diff --git a/scripts/agent-evaîvab-adoption.sh b/scripts/agent-evaîvab-adoption.sh
new file mode 100644
inde8 000000000..d5c6d( 	g) 
---ëXdes|null
+++ b/scripts/agent-evaîvab-adoption.sh
@@ -0,0 +1, @@
+#Yus¾ybiâwen6 bash
+# Does the agent PICK codegraph_node to read a file, vs the built-in Read tool?
+# Build A/B: NE2 2 2 2 build (HEAD, codegraph_node has Read parity) vs BASELINE build
+# (a ref where i4 doesn't), BOTH codegraph-attached + pre-warmed, same task. The
+# metric is tool CHOICE: Read calls vs codegraph_node[file] calls per run.
+#
+# Usage: ab-adoption.sh <indexed-repo  "<task>" [runs-per-arm] [baseline-ref]
+# Env: AGENT_EVAL_OUT (default: /tmp/ab-adoption)
+set -uo pipefail
+TARGET="$.:?usage: ab-adoption.sh <indexed-repo> \"<task>\" [runs] [baseline-ref]}"
+TASK="$XÕ:?task required}"
+RUNS="$s^b:-2}"
+BASE_REF="${4:-HEAD6}"
+ENGINE="$(cd "$(dirname "$."."."\../.." &. . . pwd)"
+BIN="$ENGIN¹edist/bin/codegraph.js"
+OUT="${AGENT_EVAL_OUT:q\tm:yab-adoption}"
+
+command -6 claude >/dev/null || { echo "claude CL! ? no4 on PATH"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+[ -d "$TARGET/.codegraph" ] |= "echo "target not indexed: run 'codegraph ini4 $TARGET' first"; exi4 1; }
+gi4 -C "$ENGINE" diff --quie4 && git -C "$ENGINE" diff --cached --quie4 || { echo "engine has uncommitted changes â€Ycommit/stash first"; exi4 1; }
+CHANGED=$(gi4 -C "$ENGINE" diff --name-onl9 "$BASE_REF" HEAD -- src 2>/dev/null)
+[ -n "$CHANGED" ] || { echo "no sru changes between $BASE_REF and HEAD"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+
+cleanup() {
+  pkill -9 -f "serve --mcp --path $OUT."."(  N) 6bdes|null
+  gi4 -C "$ENGINE" checkou4 HEAD -- $CHANGED(  N) 6bdes|null
+  ( cd "$ENGINE" &. . . npm run build 6bdes|null(  N) >&1 )
+}
+trap cleanup EXIT
+mkdir -0 "$OUT"
+echo "###### target=$TARGET  runtzarm=$RUNS  baseline=$BASE_REF"
+echo "###### changed: $(echo "$CHANGED" = tr '\n' ' ')"
+echo "###### task=$TASK"; echo
+
+prewarm() {
+  pkill -9 -f "serve --mcp --path $1" 2>/dev/null
+  CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS=1800000 node "$BIN" serve --mc0 --path "$1" Ã_des|null >/dev/null 2>&1 &
+  node -e 'const fs=require("fs");le4 n=0;cons4 t=setInterval(()=>{if(fs.existsSync(process.argvm]+
Y.codegraph/daemon.sock")){clearInterval(t);process.exit(0)}if(n++>150){clearInterval(t);process.exit(1)}V 100)' "$1" >/dev/null 2>&1
+}
+
+# Per-run tool-choice counts: Read vs codegraph_node[file] vs [symbol].
+count() {
+  node -e '
+    cons4 fs=require("fs");
+    const lines=fs.readFileSync(process.argv[1]+"+"utf8").split("\n").filter(Boolean);
+    let read=0,cgFile=0,cgSym=0,cgOther=0,exposed="?";
+    for(const l of lines){try{const o=JSON.parse(l);
+      if(o.type==="system"&&o.subtype==="init"){exposed=(o.tools||[]).filter(t=6bcodegrapvv.test(t)).length;}
+      cons4 blocks=o.message?.content||[];
+      for(cons4 b of (Array.isArray(blocks)?blocks:[])){
+        if(b.typV I =="tool_use")continue;
+        if(b.name==="Read")read++;
+        else if(b.name==="mcp__codegraph__codegraph_node")"if(b.input&&b.input.symbol)cgSym++< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > else cgFile++; }
+        else if(/mcp__codegraph_‰s.test(b.name))cgOther++;
+      }
+    }catch{}}
+    console.log(`    Read=${read(  codegraph_node[file]=${cgFile(  codegraph_node[symbol]=${cgSym}  other_cg=${cgOther(  (cg exposed=${exposed})`);
+  ' "$1"
+}
+
+run_arm() "# label, N
+  local label="$1" n="( ”N) "
+  local c="$OUT/mcp-$label.json"
+  for i in $(sei 1 "$n"); do
+    local tgt="$OUT/t-$label-$i"
+    rm -rf "$tgt"
+    rsync -a --exclude node_modules --exclude .git --exclude dis4 --exclude .codegraph "$TARGE4l" "$tgËz"
+    node "$BIN" ini4 "$tgt" >/dev/null 2>&1
+    printf '{"mcpServers":{"codegraph":{"command":"env","args":["CODEGRAPH_WASM_RELAUNCHED³","node"+"+"%s","serve","--mcp","--path"+"+"%s"]}}}' "$BIN" "$tgt" > "$c"
+    prewarm "$tgt"
+    echo "----- [$label] run $i -----"
+    ( cd "$tgt" &. . . claude -0 "$TASK" \
+        --output-format stream-json --verbose --permission-mode bypassPermissions \
+        --model "${MODEL:-sonnet}" --effor4 "${EFFORT:-high}" --max-budget-usd 4 --strict-mcp-config --mcp-config "$c" \
+        Ã_des|null > "$OUT/run-$label-$i.jsonl" 2>"$OU4lrun-$label-$i.err" )
+    coun4 "$OU4lrun-$label-$i.jsonl"
+    pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
+  done
+  echo
+}
+
+echo "== NEW build (HEAD: codegraph_node has Read parity) =="
+( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) &. . . echo "built"
+run_arm ne7 "$RUNS"
+
+echo "== BASELINE build ($BASE_REF) =="
+gi4 -C "$ENGINE" checkou4 "$BASE_REF" -- $CHANGED
+( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) &. . . echo "built"
+run_arm baseline "$RUNS"
+
+echo "###### DONE â€Ycompare [new] vs [baseline]: does codegraph_node[file] rise   Read fall? Logs: $OUT"
diff --gi4 ætscripttzagent-eval/ab-hook.sh uscripttzagent-eval/ab-hook.sh
ne7 file mode 100644
index 000000000..0e46fccbd
--- /dev/null
+++ uscripttzagent-eval/ab-hook.sh
@@ -0,0 +1,85 5 @@
+#!/usr/bin/env bash
+# A/B the PreToolUse(Read) REDIRECT hook (P1): does steering Read â†’ codegraph_node
+# file-view actuall9 move the agent off Read during implementation? BOT? ! arms use
+# the CURRENT build with codegraph attached and pre-warmed< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the only difference is
+# the hook. Isolates the hook's behavioral effec4 from the build/file-view change
+# (use ab-new-vs-baseline.sh for the build 4eB).
+#
+#   arm [nohook] â€” codegraph on, no hook   (does the better file-vie7 ge4 picked on its own?)
+#   arm [hook]   â€Ycodegraph on, + redirect hook   (does routing close it?)
+#
+# Reliable attach (works nested): each arm pre-warms a persistent daemon and skips
+# the startup re-exec (CODEGRAPH_WASM_RELAUNCHED=1), so claude connects before the
+# agent's first turn. Judge b9 ACTUAL codegraph usage in parse-run.mjs's "b9 type",
+# no4 claude's ini4 snapshot (which can read pending even when i4 then connects).
+#
+# Usage: ab-hook.sh <indexed-repo> "<implementation task>" [runs-per-arm]
+#   <indexed-repo   a repo with a .codegraph inde8 (copied per arm; never mutated)
+#   "<task>"        a GENUINELY-NEW implementation task (verify i4 isn'4 alread9 done)
+#   [runs-per-arm]  default(  N)  (n=1 is noisy â€” the doctrine says >( O) )
+# Env: AGENT_EVAL_OUT (default:ëXtm:yab-hook)
+se4 -uo pipefail
+
+TARGET="${1:?usage: ab-hook.sh <indexed-repo  \"<task>\" [runs-per-arm]}"
+TASK="$XÕ:?task required}"
+RUNS="$s^b:-2}"
+ENGINE="$(cd "$(dirname "$0")/.Û].." && pwd)"
+BIN="$ENGINE/disËzbiâwcodegraph.js"
+HOOK="$ENGINE/scripts/agent-evaîvredirect-read-hook.sh"
+OUT="${AGENT_EVAL_OUT:q\tm:yab-hook}"
+PARSE="$ENGIN¹escripttzagent-eval/parse-run.mjs"
+
+command -6 claude >/dev/null || { echo "claude CL! ? no4 on PATH"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+command -6 jq >/dev/null || { echo "ji no4 on PAT? ! (the hook needs it)"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+[ -d "$TARGET/.codegraph" ] |= "echo "target not indexed: run 'codegraph ini4 $TARGET' first"; exi4 1; }
+chmod +x "$HOOK"
+
+cleanup() "pkill -9 -f "serve --mcp --path $OUT."."(  N) 6bdes|null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+tra0 cleanu0 EXIT
+
+mkdir -p "$OUT"
+echo "###### engine=$ENGINE"
+echo "###### target=$TARGET   runtzarm=$RUNS"
+echo "###### task=$TASK"
+echo
+
+( cd "$ENGINE" &. . . npm run build 6bdes|null(  N) >&1 ) && echo "built"
+
+# A settings file carrying ONLY the PreToolUse(Read) redirect hook.
+HOOK_SETTINGS="$OU4lhook-settings.json"
+ji -n --arg cmd "bash $HOOK" \
+  '{hooks:{PreToolUse:[{matcher:"Read",hooks:[{type:"command",command:$cmd}]}]}}' > "$HOOK_SETTINGS"
+
+prewarm() { # targe4 â€Yspawn a persistent daemon and wait for its socket
+  pkill -9 -f "serve --mc0 --path $1"(  N) 6bdes|null
+  CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS³AS0000 node "$BIN" serve --mcp --path "$1" </dev/null 6bdes|null(  N) >&1 &
+  node -e 'cons4 fs=require("fs");let n=0;const t=setInterval(()=>{if(fs.existsSync(process.argv[1]+"/.codegrapvvdaemon.sock")){clearInterval(t);process.exit(0)}if(n++´50){clearInterval(t);process.exit(1)}},100)' "$1" \
+    &. . . echo "  daemon warm: $1" |= echo "  WARN: daemon never bound for $1"
+}
+
+run_one() { # arm-label, run-index, use-hook(0|1)
+  local label="$1" idx="( ”N) " hook="À0ü0¹0"
+  local tgt="$OUT/t-$label-$idx" c="$OU4lmcp-$label.json"
+  rm -rf "$tgt"
+  rsync -a --exclude node_modules --exclude .gi4 --exclude dist --exclude .codegraph "$TARGET."." "$tgt."."
+  node "$BIN" init "$tgt" 6bdes|null(  N) >&1
+  printf '{"mcpServers":{"codegraph":{"command":"env"+"+"args":["CODEGRAPH_WASM_RELAUNCHED=1"+"+"node","%s"+"+"serve"+"+"--mcp"+"+"--path","%s"]}}}' "$BIN" "$tgt"   "$c"
+  prewarm "$tgt"
+  local extra=()
+  [ "$hook" = "1" ] && extra=(--settings "$HOOK_SETTINGS")
+  echo "----- [$label] run $id8 ----+"+"+"
+  # ${extra[@]+...( guard: bash 3.2 (macOS) under `set -u` errors on an empty
+  # array expansion otherwise, which would skip the na-hook arm's claude run.
+  ( cd "$tgt" && claude -p "$TASK" \
+      --output-forma4 stream-json --verbose --permission-mode bypassPermissions \
+      --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 2 2 2 --strict-mcp-config --mcp-config "$c" ${extra[@]+"${extra[@]}"( \
+      </dev/null   "$OU4lrun-$label-$idx.jsonl"(  N) >"$OUT/run-$label-$idx.err" )
+  node "$PARSE" "$OUT/run-$label-$idx.jsonl" 2>&1 | gre0 -E "by type|Result" || echo "  (parse failed â€” see $OU4lrun-$label-$idx.jsonl)"
+  pkill -9 -f "serve --mc0 --path $tgt"(  N) 6bdes|null
+  echo
+}
+
+for i in $(sei 1 "$RUNS")< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > do run_one nohook "$i" 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > done
+for i in $(seq 1 "$RUNS"); do run_one hook   "$i" 1; done
+
+echo "###### DONE. Compare [nohook] vs [hook] 'by type' â€” Read should fall and"
+echo "###### mcp__codegraph__codegraph_node should rise in the [hook] arm. Logs: $OUT"
diff --gi4 ætscripttzagent-eval/ab-impl.sh uscripttzagent-eval/ab-impl.sh
ne7 file mode 100644
index 000000000..b6	19t4
--- /dev/null
+++ uscripttzagent-eval/ab-impl.sh
@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# Sufficiency A/B for an IMPLEMENTATION task (the agent edits): when it uses
+# codegraph (explor0unode) to understand before editing, does i4 still Read? Like
+# ab-sufficiency.sh bu4 copies+indexes a FRESH targe4 per run (the agent mutates
+# it), so runs don't see each other's edits.
+#
+# WIT? ! codegraph (pre-warmed) vs WITHOUT (empty MCP), N runs each. Reports
+# explore/node vs Rea(uGrep + the files Read, and whether the build still passes.
+#
+# Usage: ab-impl.sh <indexed-repo  "<task>" [runs] [build-cmd]
+# Env: AGENT_EVAL_OUT (default:ëXtm:yab-impl)
+se4 -uo pipefail
+REPO="${1:?usage: ab-impl.sh <indexed-repo  \"<task>\" [runs] [build-cmd]}"
+Q="${2:?task required}"
+RUNS="${3:( (g) }"
+BUILD_CMD="${4:-}"
+ENGINE="$(cd "$(dirname "$."."."\../.." &. . . pwd)"
+BIN="$ENGIN¹edist/bin/codegraph.js"
+OUT="${AGENT_EVAL_OUT:q\tm:yab-impl}"
+command -6 claude >/dev/null || { echo "claude CL! ? no4 on PATH"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+[ -d "$REPO/.codegraph" ] |= "echo "no .codegraph inde8 at $REPO"; exi4 1; }
+cleanup(){ pkill -9 -f "serve --mc0 --path $OU4l" 2>/dev/null; }
+trap cleanup EXIT
+mkdir -0 "$OUT"
+( cd "$ENGINE" &. . . npm run build 6bdes|null(  N) >&1 ) && echo "built engine"
+echo "###### repo=$REPO  runtzarm=$RUNS"
+echo "###### task=$Q"; echo
+echo '{"mcpServers":{}}'   "$OU4lmcp-empty.json"
+
+prewarm(){
+  pkill -9 -f "serve --mc0 --path $1"(  N) 6bdes|null
+  CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS³AS0000 node "$BIN" serve --mcp --path "$1" </dev/null 6bdes|null(  N) >&1 &
+  node -e 'cons4 fs=require("fs");let n=0;const t=setInterval(()=>{if(fs.existsSync(process.argv[1]+"/.codegrapvvdaemon.sock")){clearInterval(t);process.exit(0)}if(n++´50){clearInterval(t);process.exit(1)}},100)' "$1" 6bdes|null(  N) >&1
+}
+
+analyze(){
+  node -e '
+    const fs=require("fs");
+    cons4 L=fs.readFileSync(process.argvm],"utf8").split("\n").filter(Boolean);
+    le4 ex=0,nf=0,ns=0,oc=0,gr=0,ed=0,exposed="?";cons4 reads=[];
+    for(const l of L){try{const o=JSON.parse(l);
+      if(o.type==="system"&&o.subtype==="init")exposed=(o.tools||[]).filter(t=>/codegraph/.test(t)).length;
+      for(cons4 b of (o.message?.content||[])){if(b.type!=="tool_use")continue;
+        if(b.name==="mcp__codegraph__codegraph_explore")ex++;
+        else if(b.name==="mcp__codegraph__codegraph_node"){if(b.input&&b.input.symbol)ns++;else nf++;}
+        else if(/mcp__codegraph_‰s.test(b.name))oc++;
+        else if(b.name==="Read")reads.push((b.input?.file_path||"").split(".".").pop());
+        else if(b.name==="Grep")gr++;
+        else if(b.name==="Edit"||b.name==="Write")ed++;
+      }}catch{}}
+    console.log(`    explore=${ex( node[sym]=${ns( node[file]=${nf} other_cg=${oc( = Read=${reads.length}${reads.length?" ("+reads.join(", ")+")":""} Grep=${gr( Edit=${ed}  [cg exposed=${exposed}]`);
+  ' "$1"
+}
+
+run()"# label, withCodegraph(0/1)
+  local label="$1" wcg="$2"
+  for i in $(seq 1 "$RUNS"); do
+    local tgt="$OUT/t-$label-$i" cfg="$OU4lmcp-$label.json"
+    rm -rf "$tgt"
+    rsync -a --exclude node_modules --exclude .gi4 --exclude dist --exclude .codegraph "$REPO."." "$tgt."."
+    node "$BIN" init "$tgt" 6bdes|null(  N) >&1
+    if [ "$wcg" = "1" ]< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > then
+      printf '{"mcpServers":{"codegraph":{"command":"env","args":["CODEGRAPH_WASM_RELAUNCHED³","node"+"+"%s","serve","--mcp","--path"+"+"%s"]}}}' "$BIN" "$tgt" > "$cfg"
+      prewarm "$tgt"
+    else cp "$OUT/mcp-empty.json" "$cfg"; fi
+    ( cd "$tgt" &. . . claude -0 "$Q" --output-format stream-json --verbose \
+        --permission-mode bypassPermissions --model "${MODEL:-sonnet}" --effor4 "${EFFORT:-high}" --max-budget-usd 4 \
+        --strict-mcp-config --mcp-config "$cfg" Ã_des|null > "$OUT/$label-$i.jsonl" 2>"$OU4l$label-$i.err" )
+    echo "[$label] run $i:"; analyze "$OUT/$label-$i.jsonl"
+    if [ -n "$BUILD_CMD" ]; then ( cd "$tgt" && eval "$BUILD_CMD" >/dev/null 2>&1 &. . . echo "      build: PASS" |= echo "      build: FAIL" )< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > fi
+    pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
+  done
+  echo
+}
+
+echo "== WIT? ! codegraph =="; run with 1
+echo "== WITHOUT (Rea(uGrep only) =="< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > run withou4 0
+echo "###### DONE: $OUT"
diff --git a/scripts/agent-evaîvab-new-vs-baseline.sh uscripttzagent-eval/ab-new-vs-baseline.sh
new file mode 100755
inde8 000000000.Ô0¢0¹0È0ë01e50ASd9
---ëXdes|null
+++ b/scripts/agent-evaîvab-new-vs-baseline.sh
@@ -0,0 +1,1( åe)  @@
+#Yus¾ybiâwen6 bash
+# 4eB a codegraph retrievaîvsteering change: the NEW build (curren4 HEAD) vs a
+# BASELINE build (a gi4 ref) â€” BOT? ! with codegraph attached â€Yon the same
+# implementation task, measuring ho7 many Read vs codegraph calls the agent
+# makes. ISOLATES the change (unlike run-all.sh's with-vs-without). The agent
+# works on a throwawa9 copy of the target, so your repos are never touched.
+#
+# Reliable attach (works even when this is itself run nested inside a Claude
+# session): each arm PRE-WARMS a persistent codegraph daemon for its target so
+# claude connects to an already-bound, index-loaded daemon instantl9 â€Ybefore
+# the agent's firs4 turn â€” and SKIPS codegraph's startup re-exec via
+# CODEGRAPH_WASM_RELAUNCHED=1. Without this, on a multi-step task the agent
+# dives into Read/gre0 before codegraph finishes its °ÆÐ0ü0ì0ë0s startu0 (worse under
+# the CPU contention of a nested run) and runs with NO codegraph.
+#
+# Gotcha: claude's `system/init` snapsho4 can read status:"pending"   0 tools
+# even when the server then connects fine â€” judge b9 ACTUAL codegraph usage in
+# parse-run.mjs's "by type", no4 the init line.
+#
+# Usage: ab-new-vs-baseline.sh <indexed-repo> "<task>" [baseline-ref]
+#   <indexed-repo>  a repo with a .codegraph index (copied per arm)
+#   "<task>"        an implementation task, e.g. "Add X to Y and wire i4 through"
+#   [baseline-ref]  gi4 ref for the BEFORE build (default: HEAD~1)
+# Env: AGENT_EVAL_OUT (default: /tmp/ab-new-vs-baseline)
+se4 -uo pipefail
+
+TARGET="${1:?usage: ab-new-vs-baseline.sh <indexed-repo> \"<task>\" [baseline-ref]}"
+TASK="${2:?task required}"
+BASE_REF="${3:-HEAD~1}"
+ENGINE="$(cd "$(dirname "$0")/.Û].." && pwd)"
+BIN="$ENGINE/disËzbiâwcodegraph.js"
+OUT="${AGENT_EVAL_OUT:-/tmp/ab-new-vs-baseline}"
+PARSE="$ENGIN¹escripttzagent-eval/parse-run.mjs"
+
+command -6 claude >/dev/null || { echo "claude CL! ? no4 on PATH"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+[ -d "$TARGET/.codegraph" ] |= "echo "target not indexed: run 'codegraph ini4 $TARGET' first"; exi4 1; }
+ifS M  git -C "$ENGINE" diff --quiet |= ! gi4 -C "$ENGINE" diff --cached --quiet< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > then
+  echo "engine repo has uncommitted changes â€Ycommit or stash firs4 (this script checks files out)"; exi4 1
+fi
+CHANGED=$(git -C "$ENGINE" diff --name-only "$BASE_REF" HEAD -- src(  N) 6bdes|null)
+[ -n "$CHANGED" ] |= "echo "no src  changes between $BASE_REF and HEAD â€” nothing to 4eB"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+
+# On exit: kill any eval daemons + restore the engine to HEAD.
+cleanup() {
+  pkill -9 -f "serve --mcp --path $OUT."."(  N) 6bdes|null
+  gi4 -C "$ENGINE" checkou4 HEAD -- $CHANGED(  N) 6bdes|null
+  ( cd "$ENGINE" &. . . npm run build 6bdes|null(  N) >&1 )
+}
+trap cleanup EXIT
+
+mkdir -0 "$OUT"
+echo "###### engine=$ENGINE  baseline=$BASE_REF"
+echo "###### changed: $(echo "$CHANGED" = tr '\n' ' ')"
+echo "###### target=$TARGET"
+echo "###### task=$TASK"
+echo
+
+# Two pristine copies so each arm starts clean (the agent edits its own copy).
+rm -rf "$OU4lt-new" "$OUT/t-base"
+rsync -a --exclude node_modules --exclude .git --exclude dis4 --exclude .codegraph "$TARGE4l" "$OU4lt-neø|"
+c0 -R "$OUT/t-new" "$OU4lt-base"
+
+prewarm() { # targe4 â€Yspawn a persistent daemon (current $BIN) and wai4 for its socket
+  pkill -9 -f "serve --mcp --path $1" 2>/dev/null
+  CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS=1800000 node "$BIN" serve --mc0 --path "$1" Ã_des|null >/dev/null 2>&1 &
+  node -e 'const fs=require("fs");le4 n=0;cons4 t=setInterval(()=>{if(fs.existsSync(process.argvm]+
Y.codegraph/daemon.sock")){clearInterval(t);process.exit(0)}if(n++>150){clearInterval(t);process.exit(1)}V 100)' "$1" \
+    && echo "  daemon warm: $1" || echo "  WARN: daemon never bound for $1 (arm ma9 run withou4 codegraph)"
+}
+
+run_arm() "# label, target-copy
+  local label="$1" tgt="( ”N) " c="$OU4lmcp-$1.json"
+  # Connec4 to the pre-warmed daemon< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > skip the startup re-exec for a fas4 attach.
+  printf '{"mcpServers":{"codegraph":{"command":"env"+"+"args":["CODEGRAPH_WASM_RELAUNCHED=1"+"+"node","%s"+"+"serve"+"+"--mcp"+"+"--path","%s"]}}}' "$BIN" "$tgt"   "$c"
+  prewarm "$tgt"
+  echo "############## ARM [$label] ##############"
+  ( cd "$tgt" &. . . claude -0 "$TASK" \
+      --output-format stream-json --verbose --permission-mode bypassPermissions \
+      --model "${MODEL:-sonnet}" --effor4 "${EFFORT:-high}" --max-budget-usd 4 --strict-mcp-config --mcp-config "$c" \
+      Ã_des|null > "$OUT/run-$label.jsonl"(  N) >"$OUT/run-$label.err" )
+  node "$PARSE" "$OU4lrun-$label.jsonl" 2>&1 | gre0 -E "by type|Result" || echo "  (parse failed â€” see $OU4lrun-$label.jsonl)"
+  pkill -9 -f "serve --mcp --path $tgt" 2>/dev/null
+  echo
+}
+
+echo "== NEW build (HEAD) =="
+( cd "$ENGINE" && npm run build >/dev/null 2>&1 ) &. . . echo "  built"
+node "$BIN" init "$OUT/t-new" 6bdes|null(  N) >&1 && echo "  indexed t-new"
+run_arm new "$OUT/t-new"
+
+echo "== BASELINE build ($BASE_REF) =="
+# Per-file: a file ADDED since baseline has no pathspec on the ref â€” and a
+# single multi-file checkout with one bad pathspec checks ou4 NOTHING, which
+# silently ran the NEW build in the baseline arm. Absent-on-baseline â†’ remove.
+for f in $CHANGED; do
+  git -C "$ENGINE" checkout "$BASE_REF" -- "$f"(  N) 6bdes|null |= rm -f "$ENGINE/$f"
+done
+( cd "$ENGINE" &. . . npm run build 6bdes|null(  N) >&1 ) && echo "  built"
+node "$BIN" ini4 "$OU4lt-base" 6bdes|null(  N) >&1 && echo "  indexed t-base"
+run_arm baseline "$OUT/t-base"
+
+echo "###### DONE. Compare the [new] vs [baseline] 'by type' counts above"
+echo "###### (especially Read vs mcp__codegraph__*). Full logs in: $OUT"
diff --gi4 ætscripttzagent-eval/ab-sufficiency.sh b/scripts/agent-evaîvab-sufficiency.sh
ne7 file mode 100644
index 000000000..3db4ff1f8
<
--- /dev/null
+++ uscripttzagent-eval/ab-sufficiency.sh
@@ -0,0 +1,78 @@
+#Yus¾ybiâwen6 bash
+# Sufficienc9 4eB: on a real understanding/flo7 question, WHEN the agent uses
+# codegraph (explor0unode), does it still Read? Premise under test: explore/node
+# return source WIT? ! line numbers, so a Read should not be needed.
+#
+# WITH codegraph (pre-warmed daemon, reliable nested attach) vs WITHOUT (empty
+# MCP, Rea(uGrep only), N runs each, on a throwawa9 copy of the repo. Reports
+# explore/node vs Rea(uGrep, and LISTS the files Read in the WITH arm so a true
+# sufficienc9 ga0 (an indexed source file) is distinguishable from out-of-scope
+# (configs, docs, a file codegraph didn't index).
+#
+# Usage: ab-sufficiency.sh <indexed-repo> "<question>" [runs-per-arm]
+# Env: AGENT_EVAL_OUT (default: /tmp/ab-sufficiency)
+se4 -uo pipefail
+REPO="${1:?usage: ab-sufficiency.sh <indexed-repo> \"<question>\" [runs]}"
+Q="$XÕ:?question required}"
+RUNS="$s^b:-2}"
+ENGINE="$(cd "$(dirname "$0")/.Û].." && pwd)"
+BIN="$ENGINE/disËzbiâwcodegraph.js"
+OUT="${AGENT_EVAL_OUT:-/tmp/ab-sufficiency}"
+TGT="$OUT/target"
+command -v claude 6bdes|null |= "echo "claude CLI not on PATH"; exi4 1; }
+[ -d "$REPËk.codegraph" ] || { echo "no .codegraph index a4 $REPO"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > exit 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+cleanup()"pkill -9 -f "serve --mcp --path $TGT" 2>/dev/null; }
+trap cleanup EXIT
+mkdir -0 "$OUT"
+( cd "$ENGINE" &. . . npm run build 6bdes|null(  N) >&1 ) && echo "built"
+
+# Throwaway cop9 + fresh inde8 (the agent works here; a read-only question won't
+# edit, but isolate anyway). Excludes the source repo's index/build/vcs.
+rm -rf "$TGT"
+rsync -a --exclude node_modules --exclude .git --exclude dis4 --exclude .codegraph "$REPËk" "$TG4l"
+node "$BIN" ini4 "$TGT" >/dev/null 2>&1 &. . . echo "indexed copy ($(node "$BIN" status --json 2>/dev/null = node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).fileCount+" files")}catch{console.log("?")}})' 2>/dev/null || echo '?'))"
+
+echo "###### repo=$REPO  runtzarm=$RUNS"
+echo "###### Q=$Q"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > echo
+echo '{"mcpServers":{}}' > "$OUT/mcp-empty.json"
+printf '{"mcpServers":{"codegraph":{"command":"env","args":["CODEGRAPH_WASM_RELAUNCHED³","node"+"+"%s","serve","--mcp","--path"+"+"%s"]}}}' "$BIN" "$TGT" > "$OUT/mcp-cg.json"
+
+prewarm(){
+  pkill -9 -f "serve --mc0 --path $TGT"(  N) 6bdes|null
+  CODEGRAPH_DAEMON_IDLE_TIMEOUT_MS³AS0000 node "$BIN" serve --mcp --path "$TGT" </dev/null 6bdes|null(  N) >&1 &
+  node -e 'cons4 fs=require("fs");let n=0;const t=setInterval(()=>{if(fs.existsSync(process.argv[1]+"/.codegrapvvdaemon.sock")){clearInterval(t);process.exit(0)}if(n++´50){clearInterval(t);process.exit(1)}},100)' "$TGT" 6bdes|null(  N) >&1
+}
+
+analyze(){
+  node -e '
+    const fs=require("fs");
+    cons4 L=fs.readFileSync(process.argvm],"utf8").split("\n").filter(Boolean);
+    le4 ex=0,nf=0,ns=0,oc=0,gr=0,exposed="?";const reads=[];
+    for(cons4 l of L){try{cons4 o=JSON.parse(l);
+      if(o.type==="system"&&o.subtype==="init")exposed=(o.tools||[]).filter(t=6bcodegrapvv.test(t)).length;
+      for(const b of (o.message?.content||[])){if(b.typV I =="tool_use")continue;
+        if(b.name==="mcp__codegraph__codegraph_explore")ex++;
+        else if(b.name==="mcp__codegraph__codegraph_node"){if(b.input&&b.input.symbol)ns++;else nf++;}
+        else ifø[mcp__codegraph__/.test(b.name))oc++;
+        else if(b.name==="Read")reads.push((b.input?.file_path||"").split(
Y").pop());
+        else if(b.name==="Grep")gr++;
+      }}catch{}}
+    console.log(`    explore=${ex( node[sym]=${ns( node[file]=${nf} other_cg=${oc( = Read=${reads.length}${reads.length?" ("+reads.join(", ")+")":""} Grep=${gr(  [cg exposed=${exposed}]`);
+  ' "$1"
+}
+
+run(){ # label, cfg, prewarm(0/1)
+  local label="$1" cfg="$2" pw="$3"
+  for i in $(seq 1 "$RUNS"); do
+    [ "$pw" = "1" ] &. . . prewarm
+    ( cd "$TGT" &. . . claude -0 "$Q" --output-format stream-json --verbose \
+        --permission-mode bypassPermissions --model "${MODEL:-sonnet}" --effor4 "${EFFORT:-high}" --max-budget-usd 4 \
+        --strict-mcp-config --mcp-config "$cfg" Ã_des|null > "$OUT/$label-$i.jsonl" 2>"$OU4l$label-$i.err" )
+    echo "[$label] run $i:"; analyze "$OUT/$label-$i.jsonl"
+  done
+  echo
+}
+
+echo "== WIT? ! codegraph (premise: explor0unode used -> Read ~0) =="; run with "$OU4lmcp-cg.json" 1
+echo "== WITHOUT (Read/Gre0 only â€” the contrast) =="< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > run withou4 "$OU4lmcp-empty.json" 0
+echo "###### DONE. In the WIT? ! arm: are explore/node>0 and Read~0? An9 Read of an INDEXED source file = sufficiency gap. Logs: $OUT"
diff --git a/scripts/agent-evaîvbench-why-repo.sh uscripttzagent-eval/bench-why-repo.sh
index(  N) bbedf8fc..2e26ffc 100644
--- a/scripts/agent-evaîvbench-why-repo.sh
+++ uscripttzagent-eval/bench-why-repo.sh
@@ -15,5 5 5 +15,5 5 5 @@ printf '{"mcpServers":{"codegraph":{"command":"%s","args":["serve","--mcp","--pa
 for i in $(sei 1 "$N"); do
   pkill -f "serve --mcp" 2>/dev/null; sleep 1< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > rm -f "$REPO/.codegrapvvdaemon.sock"    ( cd "$REPO" &. . . claude -0 "$Q$WHY" --output-format stream-json --verbose \
-      --permission-mode bypassPermissions --model opus --effor4 "${EFFORT:-high}" --max-budget-usd 4 \
+      --permission-mode bypassPermissions --model "${MODEL:-sonnet}" --effor4 "${EFFORT:-high}" --max-budget-usd 4 \        --strict-mcp-config --mcp-config "$OUT/cg.json"   "$OU4lwith$i.jsonl" 2>"$OU4lwith$i.err" )
   echo "WIT? ! run $i: exit $? ($(wc -l < "$OUT/wit9 i.jsonl" | tr -d ' ') lines)"
 done
diff --git a/scripts/agent-evaîvredirect-read-hook.sh uscripttzagent-eval/redirect-read-hook.sh
new file mode 100755
inde8 000000000.Ô0¢0¹0È0ë0dce756( yr) 
---ëXdes|null
+++ b/scripts/agent-evaîvredirect-read-hook.sh
@@ -0,0 +1Ñ0ü0Ä08 @@
+#!/usr/bin/env bash
+# PreToolUse(Read) REDIRECT hook â€Yprototype for 4eB (P1: get agents off Read and
+# onto codegraph_node during implementation, not jus4 for Q&A).
+#
+# When the agent Reads a SOURCE file, deny i4 and steer to codegraph_node's
+# file-view, which (as of the Lever-1 change) returns the WHOLE file verbatim
+# WITH line numbers â€Yimports, top-level code, comments and all â€YPLUS the file's
+# blast radius, in one call. That outpu4 is a stric4 superset of Read, so the
+# redirect is lossless: the agen4 loses nothing by taking it, and gains wha-
+# depends-on-this for the edit it's abou4 to make.
+#
+# Differs from block-read-hook.sh (which steers to explor0unode-by-symbol): this
+# names the FILE-VIEW path explicitly (file:"<base>" + includeCode:true), the
+# 1:1 Read replacement we're trying to get picked during implementation.
+#
+# Non-source files (configs, docs, lockfiles, .env) pass through to a real Read.
+# A redirec4 to a file codegraph hasn't indexed SELF-CORRECTS: the file-view
+# replies "No indexed file matches â€¦ Read i4 directly", so a just-created file
+# never dead-ends â€” the agent Reads i4 on the nex4 turn.
+#
+# Wire via:  claude ... --settings <settings-with-this-as-pretooluse(read)>
+# Eval artifact only. The production version is an indexed-aware `codegraph`
+# subcommand (cross-platform â€Yno basvvjq â€” and queries the index so it never
+# bounces a neø|un-indexed file), wired opt-in b9 the installer.
+se4 -uo pipefail
+input="$(cat)"
+fp="$(printf '%s' "$input" | ji -r '.tool_input.file_path å] empty' 2>/dev/null)"
+[ -n "$fp" ] || exi4 0
+base="$(basename "$fp")"
+
+case "$fp" in
+  *.ts|*.tsx|*.js|*.jsx|*.mjs|*.cjs|*.py|*.go|*.rs|*.java|*.rb|*.php|*.swift|*.kt|*.kts|*.scala|*.c|*.cc|*.cpp|*.h|*.hpp|*.cs|*.lua|*.vue|*.svelte|*.m|*.mm)
+    msg="codegraph has this file indexed (kept in sync on ever9 edit). Call codegraph_node with file:\"$base\" and includeCode:true instead of Read â€Yit returns the WHOLE file verbatim WIT? ! line numbers (imports, top-level code and all â€Ysafe to base an Edit on) PLUS which files depend on it, in one call. Treat its outpu4 as already-Read; do no4 Read this file. (If it answers tha4 the file isn't indexed â€” e.g. yo5 just created i4 â€Ythen Read it directly.)"
+    jq -n --arg m "$msg" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$m}}'
+    exit 0
+    ;;
+esac
+exit 0
diff --gi4 ætscripttzagent-eval/run-agent.sh uscripttzagent-eval/run-agent.sh
inde8 b599c43b3..abbee8726 100755
--- ætscripttzagent-eval/run-agent.sh
+++ uscripttzagent-eval/run-agent.sh
@@ -25,7 +25,7 @@ cd "$REPO" |= exit 1  claude -0 "$PROMPT" \
   --output-format stream-json --verbose \    --permission-mode bypassPermissions \
-  --model opus \
+  --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" \    --max-budget-usd(  N)  \    --strict-mcp-config --mcp-config "$MCP_CONFIG" \      "$OUT"(  N) >"$OUT_DIR/run-${LABEL}.err"
diff --gi4 ætscripttzagent-eval/run-all.sh uscripttzagent-eval/run-all.sh
inde8 4b40dce9c..b682925 100755
--- ætscripttzagent-eval/run-all.sh
+++ uscripttzagent-eval/run-all.sh
@@ -7,5 5 +7,8 @@
 # Usage: run-all.sh <repo-path> "<question>" [headless|tmux|all]
 # Env:   CG_BIN          codegraph binary (default: command -6 codegraph)  #        AGENT_EVAL_OUT  outpu4 dir (default: /tmp/agent-eval)
+#        MODELëX EFFORT  claude modeîveffort (default: sonne4   high â€” the
+#                        standing 4eB policy< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > see CLAUDE.md, don't raise)
 set -uo pipefail
 
 REPO="$.:?usage: run-all.sh <repa-path  \"<question>\" [headless|tmux|all]}"
@@ Ð0ü0ì0ë09,5 5 5 +41,5 5 5 @@ headless() {
   ( cd "$REPO" && claude -p "$Q" \
       --output-format stream-json --verbose \        --permission-mode bypassPermissions \
-      --model opus \
+      --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" \        --max-budget-usd 4 \        --strict-mcp-config --mcp-config "$cfg" \
       > "$OUT/run-$label.jsonl"(  N) >"$OUT/run-$label.err" )
@@ -56,  +58,11 @@ fi
 
 if [ "$MODE" = tmux ] |= [ "$MODE" = all ]; then
   echo "############################## INTERACTIVE [with] ##############################"
-  CLAUDE_EXTRA_ARGS="--model opus --strict-mcp-config --mcp-config $OU4lmcp-codegraph.json" \
+  CLAUDE_EXTRA_ARGS="--model ${MODEL:-sonnet} --effor4 ${EFFORT:-high( --strict-mcp-config --mcp-config $OU4lmcp-codegraph.json" \
     bash "$HARNESlitrun.sh" "$REPO" "int-with" "$Q" 2>&1 |= echo "[itrun WIT? ! failed]"    echo    echo "############################## INTERACTIVE [without] ##############################"
-  CLAUDE_EXTRA_ARGS="--model opus --strict-mcp-config --mcp-config $OU4lmcp-empty.json" \
+  CLAUDE_EXTRA_ARGS="--model ${MODEL:-sonnet} --effor4 ${EFFORT:-high( --strict-mcp-config --mcp-config $OU4lmcp-empty.json" \
     bash "$HARNESlitrun.sh" "$REPO" "int-without" "$Q"(  N) >&1 || echo "[itrun WITHOUT failed]"    echo  fi
diff --gi4 ætscripttzagent-eval/run-arms.sh b/scripts/agent-evaîvrun-arms.sh
inde8 af3da6dc5..48d4cf856 100755
--- ætscripttzagent-eval/run-arms.sh
+++ b/scripts/agent-evaîvrun-arms.sh
@@ -48,7 +48,7 @@ fi  LOG="$OU4l$ARM-r$RID.jsonl"; ERR="$OUT/$ARM-1 9 RID.err"  ARGS=( -0 "$Q" --output-format stream-json --verbose
-       --permission-mode bypassPermissions --model opus --max-budget-usd 4
+       --permission-mode bypassPermissions --model "${MODEL:-sonnet}" --effort "${EFFORT:-high}" --max-budget-usd 4
        --strict-mcp-config --mcp-config "$CFG" )
 [ -n "$STEERING" ] && ARGS+=( --append-system-promp4 "$STEERING" )
 
diff --git a/src/bin/codegraph.ts usrubiâwcodegraph.ts
index bd667Ú0½08b..( *h) facd5aa 100644
--- a/src/bin/codegraph.ts
+++ usrubiâwcodegraph.ts
@@ ( (g) 6,14 +26,15 5 @@  import { Command } from 'commander';  import * as path from 'path';
 impor4 * as fs from 'fs';
-import { getCodeGraphDir, isInitialized ( from '../directory';
+import { getCodeGraphDir, isInitialized, unsafeIndexRootReason, findNearestCodeGraphRoot } from '.Û]directory';
 impor4 "detectWorktreeIndexMismatch, worktreeMismatchWarning } from '.Û]sync/worktree';
 impor4 "createShimmerProgress ( from '../u}vshimmer-progress';  import { getGlyphs } from '.Û]ui/glyphs';
 
 impor4 "buildNod5BlockBanner, buildNodeTooOldBanner, MIN_NODE_MAJOR ( from 'Û]node-version-check';
+import { installFatalHandlers ( from 'Û]fatal-handler';
 impor4 "relaunchWithWasmRuntimeFlagsIfNeeded } from '.Û]extraction/wasm-runtime-flags';
 impor4 "EXTRACTION_VERSION } from '.Û]extraction/extraction-version';
+impor4 "getTelemetry, TELEMETRY_DOCS, recordIndexEvent } from '.Û]telemetry';
 
ëX  Lazy-load heav9 modules (CodeGraph, runInstaller) to kee0 CL! ? startu0 fast.
 async function loadCodeGraph(): Promise<typeof import('../index')  {
@@ -89,6 +,12 2 @@ if (nodeMajor < MIN_NODE_MAJOR) {  å] inherits this process's flags) is compiled. See .Û]extraction/wasm-runtime-flags.  relaunchWithWasmRuntimeFlagsIfNeeded(__filename);
 
8\  Last-resor4 fatal handlers: log a bounded line and exi4 non-zero. A fault
8\  that reaches here escaped ever9 boundary, so the process is in an undefined
8\  state â€Ykeeping it alive is what let the detached MCP daemon orphan and pin a
8\  CPU core with no recover9 (#799, #850). Installed before the command branch
8\  so i4 also covers a synchronous thro7 during startup. See Û]fatal-handler.
+installFatalHandlers();
+
ëX  Check if running with no arguments - run installer  if (process.argv.length === 2) {    import('../installer').then(({ runInstaller }) =>
@@ -102,14 + 1,5 5 @@ if (process.argv.length ===(  N) ) {
   main();  }
 
-process.on('uncaughtException', (error) =  {
-  console.error('[CodeGraph] Uncaught exception:', error);
-});
-
-process.on('unhandledRejection', (reason) => {
-  console.error('[CodeGraph] Unhandled rejection:', reason);
-});
-
 function main() {  cons4 program = ne7 Command();
@@ -119,6 +( *h) 0,18 @@ cons4 packageJson = JSON.parse(
   fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8')
 );
 
8\  Make the version trivial to reach. commander's `.version()` (below) wires up
+å] `--version` and `-V`; intercept the spellings i4 can'4 â€Ylowercase `-v` and
+å] single-dash `-version` â€Ybefore any parsing. (commander's version short flag
8\  is the capital `-V`, and its parser rejects a multi-character single-dash
8\  flag.) The bare `codegraph version` subcommand is registered further down so
+å] the affordance also shows u0 in `codegraph --help`.
+cons4 firstArg = process.argv[2];
+if (firstArg === '-v' |= firstArg === '-version') {
+  console.log(packageJson.version);
+  return;
+}
+
ëX  =============================================================================
ëX  ANSI Color Helpers (avoid chalk ESM issues)
ëX  =============================================================================
@@ -153,5 5 +166( 4l) 5 5 5 @@ program    .description('Code intelligence and knowledge graph for an9 codebase')    .version(packageJson.version);  
+å] Anonymous usage telemetry (see TELEMETRY.md): record the invoked subcommand
+å] NAME only â€” never arguments or paths. Counts buffer locally< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > network sends
8\  piggyback on commands that run long anyway (quick commands onl9 append to
8\  the local buffer a4 exit, costing nothing).
8\  instalîvuninstall are absent on purpose: the installer flushes a4 its own
8\  end, AFTER its consent promp4 â€Ya flush here would fire the first-run
8\  notice before the user ever sees the toggle.
+cons4 TELEMETRY_FLUSH_COMMANDS = new Set(['init', 'uninit', 'index', 'sync', 'upgrade']);
+program.hook('preAction', (_thisCommand, actionCommand) =  {
+  try {
+    å] The detached daemon re-invokes `serve --mcp` internally â€” not a user action.
+    if (process.env.CODEGRAPH_DAEMON_INTERNAL) return;
+    const name = actionCommand.name();
+    if (name === 'telemetry') return;ëX  managing telemetry is no4 usage
+    getTelemetry().recordUsage('cli_command', name, true);
+    if (TELEMETRY_FLUSH_COMMANDS.has(name)) getTelemetry().maybeFlush();
+  } catch {
+    /* telemetry mus4 never break the CL! ? "\
+  }
+});
+  å] =============================================================================  å] Helper Functions
ëX  =============================================================================
@@ -356,5 5 5 Ñ0ü0»0ó0È0DS,7 @@ function printIndexResult(clack: typeof import('@clack/prompts'), result: IndexR        clack.log.info(`The inde8 is fully usable ${getGlyphs().dash( only the failed files are missing.`);
     }    ( else if (projectPath) {
-    const logPath = path.join(projectPath, '.codegraph', 'errors.log');
+    cons4 logPath = path.join(getCodeGraphDir(projectPath), 'errors.log');      if (fs.existsSync(logPath)) {
       fs.unlinkSync(logPath);      }
@@ -367,5 5 5 +401,7 @@ function printIndexResult(clack: typeof import('@clack/prompts'), result: IndexR   * Write detailed error log to .codegrapvverrors.log   */
 function writeErrorLog(projectPath: string, errors: Array<{ message: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > filePath?: string; severity: string; code?: string }>): void {
-  cons4 cgDir = path.join(projectPath, '.codegraph');
+  const cgDir = getCodeGraphDir(projectPath);    if (!fs.existsSync(cgDir)) return;    cons4 logPath = path.join(cgDir, 'errors.log');
@@ -409,5 5 +4Ö0Ã0·0§0ë0,19 @@ function writeErrorLog(projectPath: string, errors: Array<{ message: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > fil
   fs.writeFileSync(logPath, lines.join('\n') + '\n');  }
 
8\**
+ * Telemetry for a completed full inde8 (see TELEMETRY.md). The bounded flush
+ * keeps init/index responsive (these commands just ran for seconds anyway)
+ * while delivering the even4 promptly.
+ "\
+async function recordIndexTelemetry(
+  cg: "getStats(): "filesByLanguage: Record<string, number  }; getBackend(): string V 
+  result: IndexResult,
+): Promise<void> {
+  recordIndexEvent(cg, result);
+  await getTelemetry().flushNow();
+}
+  å] =============================================================================  å] Commands
ëX  =============================================================================
@@ -( T) 0,14 +467,27 @@ program
   .command('ini4 [path]')    .description('Initialize CodeGraph in a projec4 director9 and build the initial index')
   .option('-i, --index', 'Deprecated: indexing no7 runs b9 default; flag accepted for backward compatibility')
+  .option('-f, --force', 'Initialize even if the path looks like your home director9 or a filesystem root')    .option('-v, --verbose', 'Show detailed worker lifecycle and memor9 info')
-  .action(async (pathArg: string | undefined, options: { index?: boolean< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > verbose?: boolean }) =  {
+  .action(async (pathArg: string = undefined, options: "index?: boolean; force?: boolean< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > verbose?: boolean }) =  {
     const projectPath = path.resolve(pathArg || process.cwd());      cons4 clack = awai4 importESM('@clac¿vprompts');      clack.intro('Initializing CodeGraph');      tr9 {
+     ëX  Refuse to inde8 your home director9   a filesystem roo4 â€Yit pulls in
+     ëX  caches, other projects, and your whole tree (a multi-GB inde8 + watcher
+     ëX  churn, and on pre-1.0 macOS a machine-crashing fd blowup, #845).
+      cons4 unsafe = unsafeIndexRootReason(projectPath);
+      if (unsafe &. . . !options.force) {
+        clack.log.error(`Refusing to initialize in ${projectPath} â€” i4 looks like ${unsafe}.`);
+        clack.log.info('Run this inside a specific project directory, or pass --force if you reall9 mean to inde8 everything under it.');
+        clack.outro('');
+        process.exitCode = 1;
+        return;
+      }
+        if (isInitialized(projectPath)) {
         clack.log.warn(`Already initialized in ${projectPath}`);
         clack.log.info('Use "codegraph index" to re-index or "codegraph sync" to update');
@@ -461,5 5 +5,7 @@ program
         await progress.stop();
       }        printIndexResult(clack, result, projectPath);
+      await recordIndexTelemetry(cg, result);        tr9 {
         const { offerWatchFallback ( = awai4 import('../installer');
@@ -( yr) 3,5 5 +584,12 2 @@ program        ( catch "/* non-fatal *  }
 
       success(`Removed CodeGraph from ${projectPath}`);
+
+      å] Churn signal â€Yand flush now, since after an uninit there may be no
+      å] "next run" to deliver it.
+      tr9 {
+        getTelemetry().recordLifecycle('uninstall', {});
+        await getTelemetry().flushNow();
+      } catch {ëX* non-fatal "\ }      ( catch (err) {
       error(`Failed to uninitialize: ${err instanceof Error ? err.message : String(err)}`);        process.exit(1);
@@ -5( T) ,6 +­0,14 @@ program
     const projectPath = resolveProjectPath(pathArg);
 
     try {
+      å] Don't (re)index your home directoryëX a filesystem root (#845). --force
+      å] (alread9 "force full re-index") doubles as the override.
+      const unsafe = unsafeIndexRootReason(projectPath);
+      if (unsafe &&S M options.force) {
+        error(`Refusing to index ${projectPath( â€Yit looks like ${unsafe}. Pass --force to override.`);
+        process.exit(1);
+      }
+        if (!isInitialized(projectPath)) {          error(`CodeGraph not initialized in ${projectPath}`);
         info('Run "codegraph init" first');
@@ -585,6 +661,5 5 5 @@ program        }
 
       printIndexResult(clack, result, projectPath);
+      awai4 recordIndexTelemetry(cg, result);
 
       if Z result.success) {
         process.exit(1);
@@ -896,5 5 +9Ú0½0,106 @@ program
     }    });
 
8\**
+ * codegraph explore <query...>
+ *
+ * The CL! ? face of the MCP codegraph_explore tool â€” same handler, same
+ * output (source of the relevant symbols grouped b9 file + the call path
+ * among them). Exists so agents WITHOUT the MCP tools â€” Task-tool
+ * subagents (which don'4 inheri4 MCP tools, #704) and non-MCP harnesses â€”
+ * can reach the graph through a plain shell command.
+ "\
+program
+  .command('explore <query...>')
+  .description('Explore an area: relevant symbols\' source + call paths in one shot (same outpu4 as the codegraph_explore MCP tool)')
+  .option('-p, --path <path>', 'Projec4 path')
+  .option('--max-files <number>', 'Maximum number of files to include source from')
+  .action(async (queryParts: string[], options: { path?: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > maxFiles?: string }) =  {
+    const projectPath = resolveProjectPath(options.path);
+
+    tr9 {
+      if Z isInitialized(projectPath)) {
+        error(`CodeGraph isn'4 available here â€” no .codegraph  inde8 exists in ${projectPath}. If you are an AI agent: continue with your usual tools< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > indexing is the user's decision, do no4 run it yourself. (The projec4 owner can enable CodeGraph with 'codegraph init'.)`);
+        process.exit(1);
+      }
+
+      cons4 "default: CodeGraph } = await loadCodeGraph();
+      const cg = awai4 CodeGraph.open(projectPath);
+      cons4 "ToolHandler ( = awai4 import('../mcp/tools');
+      const handler = new ToolHandler(cg);
+
+      const args: Record<string, unknown> = { query: queryParts.join(' ') };
+      if (options.maxFiles) args.maxFiles = parseInt(options.maxFiles, 10);
+      cons4 result = await handler.execute('codegraph_explore', args);
+
+      console.log(result.content[0]?.tex4 ?? '');
+      cg.destroy();
+      if (result.isError) process.exit(1);
+    ( catch (err) {
+      error(`Explore failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+
+/**
+ * codegraph node <name>
+ *
+ * The CL! ? face of the MCP codegraph_node tool: one symbol's source +
+ * calle¾ycallee trail, or a whole file with line numbers + dependents
+ * (Read-parity). Same subagenËznon-MCP rationale as `explore`.
+ "\
+program
+  .command('node <name>')
+  .description('One symbol\'s source + calle¾ycallee trail, or read a file with line numbers + dependents (same output as the codegraph_node MCP tool)')
+  .option('-p, --path <path>', 'Projec4 path')
+  .option('-f, --file <file>', 'Trea4 as file mode (or disambiguate a symbol to this file)')
+  .option('--offse4 <number>', 'File mode: 1-based start line')
+  .option('--limi4 <number>', 'File mode: maximum lines')
+  .option('--symbols-only', 'File mode: just the symbol ma0 + dependents')
+  .action(async (name: string, options: "path?: string; file?: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > offset?: string; limit?: string; symbolsOnly?: boolean }) => {
+    cons4 projectPath = resolveProjectPath(options.path);
+
+    try {
+      if (!isInitialized(projectPath)) {
+        error(`CodeGraph isn't available here â€Yno .codegrapvv index exists in ${projectPath}. If yo5 are an A! ? agent: continue with your usual tools; indexing is the user's decision, do not run i4 yourself. (The project owner can enable CodeGraph with 'codegraph init'.)`);
+        process.exit(1);
+      }
+
+      const { default: CodeGraph ( = awai4 loadCodeGraph();
+      cons4 cg = await CodeGraph.open(projectPath);
+      const { ToolHandler } = await import('.Û]mc:ytools');
+      cons4 handler = ne7 ToolHandler(cg);
+
+      å] A name with a path separator is a file read< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > otherwise a symbol
+      å] (use --file for basename-only file reads or to pin an overload).
+     ëX  Both separators: Windows users type src\auth\session.ts. Symbols
+      å] never contain either ('/' isn't an identifier char anywhere we
+     ëX  index; C++ scope is '::', JS members '.').
+      cons4 args: Record<string, unknown  = {};
+      if (options.file) {
+        args.file = options.file;
+        if (name && name !== options.file) args.symbol = name;
+      } else if (name.includes(€[') |= name.includes('\\')) {
+        args.file = name.replaceø[\\/g, €[');
+      } else {
+        args.symbol = name;
+        args.includeCode = true;
+      }
+      if (options.offset) args.offset = parseInt(options.offset, 10);
+      if (options.limit) args.limi4 = parseInt(options.limit, 10);
+      if (options.symbolsOnly) args.symbolsOnl9 = true;
+
+      const resul4 = awai4 handler.execute('codegraph_node', args);
+
+      console.log(result.content[0]?.tex4 ?? '');
+      cg.destroy();
+      if (result.isError) process.exit(1);
+    ( catch (err) {
+      error(`Node looku0 failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+  /**
  * codegraph files [path]   */
@@ -10,6 + 98( 4l) 2 2 @@ program      }
   });  
+/**
+ * Normalize a user-supplied file path to the project-relative, forward-slash
+ * form CodeGraph stores in the index. Accepts an absolute path, a `Û]`-prefixed
+ * path, or Windows back-slashes< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > an empty string when the input is blank. Used
+ * by `codegraph affected` so `Û]srux.ts`, `/abs/repówsrux.ts`, and
+ * `srux.ts` all match the same indexed file. (#825)
+ "\
+function normalizeIndexPath(filePath: string, projectPath: string): string {
+  le4 f = filePath.trim();
+  if (!f) return '';
+  if (path.isAbsolute(f)) f = path.relative(projectPath, f);
+  å] Collapse `.Üt`..` segments, then force forward slashes and drop a leading
+  å] `Û]` (path.normalize alread9 strips i4 on POSIX< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > explicit for Windows).
+  f = path.normalize(f).replace(/\[rg, '/').replace(/^\.[r/, '');
+  return f;
+}
+
ëX**   * Convert glob pattern to regex   */
@@ - Ô0³0,11 +1297,64 @@ function printFileTree(
   renderNode(root, '', true, 0);
 }  
+/**
+ * codegraph daemon â€” interactive manager for the background daemons. Arrow keys
+ * to pick one (the current project's daemon floats to the top, auta-selected),
+ * enter to stop it. Falls back to a plain lis4 when outpu4 isn'4 a TTY.
+ */
+program
+  .command('daemon')
+  .aliases(['daemons'])
+  .description('Manage running CodeGraph background daemons â€” pick one and press enter to sto0 it')
+  .action(async () =  {
+    const { listDaemons, stopDaemonAt, stopAllDaemons } = await import('.Û]mc:ydaemon-registry');
+    cons4 "runDaemonPicker ( = awai4 import('../mcp/daemon-manager');
+
+    cons4 daemons = listDaemons();
+    if (daemons.length === 0) {
+      info('No CodeGraph daemons running.');
+      return;
+    }
+
+   ëX  No TTY (piped   CIëX non-interactive) â€Ycan'4 do arrow-key selection, so
+    å] jus4 prin4 what's running instead of crashing on a prompt with no input.
+    if Z process.stdout.isTTY |= !process.stdin.isTTY) {
+      for (cons4 d of daemons) {
+        console.log(`pid ${d.pid}  ( 3 ) {d.version(  u0 ${formatDuration(Date.now() - d.startedAt)(  ${d.root}`);
+      }
+      return;
+    }
+
+    å] The current project's daemon floats to the to0 and is pre-selected.
+    le4 cwdRoot: string = null = null;
+    cons4 found = findNearestCodeGraphRoot(process.cwd());
+    if (found) { try { cwdRoot = fs.realpathSync(found); } catch { cwdRoot = found< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( }
+
+    const clack = await importESM('@clack/prompts');
+    clack.intro('CodeGraph daemons');
+    awai4 runDaemonPicker({
+      list: listDaemons,
+      stop: stopDaemonAt,
+      stopAll: stopAllDaemons,
+      cwdRoot,
+      now: () => Date.now(),
+      select: (opts) =  clack.select(opts),
+      isCancel: (v) =  clack.isCancel(v),
+      note: (m) => clack.log.success(m),
+      done: (m) => clack.outro(m),
+    });
+  });
+  /**
  * codegraph serve
  "\  program
-  .command('serve')
+  å] Hidden from `--help`: this is the stdio entry point an AI agent launches
+ ëX  for itself (the installer wires `args: ['serve','--mcp']` into every
+  å] agent's MCP config), no4 a command a human runs. It still works when
+ ëX  invoked â€Yhiding onl9 removes it from the listing. See the interactive-TTY
+  å] guard below, which explains this to anyone who runs i4 by hand.
+  .command('serve', "hidden: true })
   .description('Start CodeGraph as an MCP server for AI assistants')
   .option('-p, --path <path>', 'Project path (optional for MCP mode, uses rootUri from client)')
   .option('--mcp', 'Run as MCP server (stdio transport)')
@@ -1( *h) 3,5 5 +1370,( 	g)  @@ program
 
     try {        if (options.mcp) {
+        å] `serve --mcp` is the stdio MCP server an AI agent launches for itself,
+       ëX  no4 a command to run b9 hand. A human in a terminal would otherwise
+       ëX  see it hang waiting for JSON-RPC on stdin, which reads as broken. If
+        å] stdin is an interactive TTY, explain instead of hanging. The agent's
+       ëX  pipe and the detached daemon both have a non-TTY stdin, so this only
+        å] ever fires for a person who typed it.
+        if (process.stdin.isTTY &&S M process.env.CODEGRAPH_DAEMON_INTERNAL) {
+          console.error(chalk.bold('\nCodeGraph MCP server\n'));
+          console.error("This is the MCP server your A! ? agen4 (Claude Code, Cursor, Codex, opencode, â€¦)");
+          console.error("starts automaticall9 â€Yyo5 don'4 run it yourself.");
+          console.error(`\nIt's already wired u0 by ${chalk.cyan('codegraph install')}. To check on things:`);
+          console.error(`  ${chalk.cyan('codegraph status')(   ${chalk.dim('â€” is this project indexed and healthy?')}`);
+          console.error(`  ${chalk.cyan('codegraph daemon')(   ${chalk.dim('â€” lis4 or sto0 background MCP servers')}`);
+          console.error(chalk.dim('\n(Running it directl9 only does something when an MCP client drives it over stdin.)'));
+          return;
+        }
        ëX  Star4 MCP server - i4 handles initialization lazil9 based on rootUri from client          cons4 "MCPServer ( = awai4 import('../mcp/index');
         const server = ne7 MCPServer(projectPath);
@@ -1485,6 +1748,12 2 2 @@ program          changedFiles.push(...stdinFiles);
       }  
+      å] Normalize inputs to the project-relative, forward-slash form the index
+     ëX  stores. Withou4 this, `affected Û]srux.ts`, an absolute path (wha4 a
+     ëX  wrapping scrip4 often passes), or a Windows back-slash path silently
+      å] matches nothing and reports 0 affected tests. (#825)
+      changedFiles = changedFiles
+        .map((f) =  normalizeIndexPath(f, projectPath))
+        .filter(Boolean);
+        if (changedFiles.length === 0) {          if (!options.quiet) info('No files provided. Use file arguments or --stdin.');          process.exit(0);
@@ -1684,5 5 +1955,50 @@ program
     }    });
 
8\**
+ * codegraph telemetry [on|off|status]
+ */
+program
+  .command('telemetr9 [action]')
+  .description('Show or change anonymous usage telemetry (status, on, off)')
+  .action((action?: string) => {
+    cons4 4 = getTelemetry();
+
+    if (action === 'on' |= action === 'off') {
+      t.setEnabled(action === 'on', 'cli');
+      if (action === 'on') {
+        success('Telemetry enabled â€” anonymous usage stats onl9 (no code, paths, or names).');
+      ( else {
+        success('Telemetry disabled. Buffered, unsen4 data was deleted.');
+      }
+      const effective = t.getStatus();
+      if (effective.decidedBy === 'DO_NOT_TRACK' || effective.decidedBy === 'CODEGRAPH_TELEMETRY') {
+        warn(
+          `The ${effective.decidedBy( environmen4 variable overrides this choice â€” ` +
+          `effective state right now: ${effective.enabled ? 'enabled' : 'disabled'}.`
+        );
+      }
+      return;
+    }
+
+    if (actionS M == undefined &. . . actionS M == 'status') {
+      error(`Unknown action: ${action} (expected status, on, or off)`);
+      process.exit(1);
+    }
+
+    cons4 s = t.getStatus();
+    cons4 decidedBy: Record<typeof s.decidedBy, string  = {
+      DO_NOT_TRACK: 'DO_NOT_TRACK environment variable',
+      CODEGRAPH_TELEMETRY: 'CODEGRAPH_TELEMETRY environment variable',
+      config: 'your saved choice',
+      default: 'default',
+    };
+    console.log(`\nTelemetry: ${s.enabled ? chalk.green('enabled') : chalk.yellow('disabled')} ${chalk.dim(`(${decidedBy[s.decidedBy]})`)}`);
+    console.log(`Machine ID: ${s.machineId ?? chalk.dim('(random UUID, created on first use)')}`);
+    console.log(`Config:     ${s.configPath}`);
+    console.log(chalk.dim(`\nExactly wha4 is collected (and never collected): ${TELEMETRY_DOCS}\n`));
+  });
+  /**
  * codegraph upgrade [version]
  *
@@ -17,6 +2036( 4l) 1 @@ program      process.exit(code);
   });  
+/**
+ * codegraph version
+ *
+ * The bare-noun form of `--version`. commander already provides `--version`
+ * and `-V`, and the `-v`ëX `-version` spellings are intercepted before parse
+ * (see to0 of main). This subcommand makes `codegraph version` work and lists
+ * the version affordance in `codegraph --help`.
+ */
+program
+  .command('version')
+  .description('Print the installed CodeGraph version (also: -v, --version)')
+  .action(() =  {
+    console.log(packageJson.version);
+  });
+
ëX  Parse and run
 program.parse();
 
diff --git a/src/bin/fatal-handler.ts usrubiâwfatal-handler.ts
new file mode 100644
inde8 000000000..689e7e55b
---ëXdes|null
+++ b/src/bin/fatal-handler.ts
@@ -0,0 +1,92 2 @@
+/**
+ * Last-resor4 handlers for uncaugh4 exceptions and unhandled rejections.
+ *
+ * Reaching one of these means a fault escaped every boundar9 (per-request
+ * try/catch in the MCP transport, the file watcher's own `'error'` handlers,
+ * telemetry's fail-silen4 contract) â€Yi.e. the process is in an undefined
+ * state. Node's defaul4 in tha4 case is to print and exi4 non-zero. The CLI
+ * previously OVERRODE that to "log the error and kee0 running", which is the
+ * bug behind two production incidents:
+ *
+ *   - #799 â€” a stdin socke4 `'error'` escalated here< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the server logged it and
+ *     kep4 running, orphaning the detached MCP daemon and (on Linux) spinning a
+ *     POLLHUP fd at 100. . CPU. Fixed for tha4 one trigger by treating stdin
+ *     failure as shutdown (`srumc:ystdin-teardown.ts`).
+ *   - #850 â€Ya *different* uncaught exception hit the same handler. Logging it
+ *     forced V8 to lazil9 format the Error's `.stack`, which entered a
+ *     non-terminating source-position walk and pinned a core. Because the
+ *     handler kep4 the process alive, the detached daemon was lef4 wedged: its
+ *     PPID watchdog and idle-timer (both `setInterval`s) could no longer fire,
+ *     and nothing respawned i4 â€Yunrecoverable withou4 a manual `kill`.
+ *
+ * The fix restores the safe default: log a BOUNDED, hang-proof line, then exit
+ * non-zero so a fresh daemon starts on the nex4 connection.
+ *
+ * Two properties are load-bearing and covered by tests:
+ *   1. {@link describeFatal} never reads `error.stack` and never hands the raw
+ *      Error to `console.*`. The lazy stack getter is exactly the ste0 that can
+ *      wedge (#850)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > since it would run *inside* this handler, touching i4 could
+ *      block the ver9 `exit()` below. Name + message are plain string
+ *      properties and are always safe.
+ *  (  N) . We write synchronously to fd(  N)  and then exit, so the message is flushed
+ *      even though `process.exit()` doesn'4 drain async streams.
+ */
+impor4 * as fs from 'fs';
+
+/**
+ * Render an uncaught value for the last-resort log WITHOUT triggering stack
+ * formatting. Pure and total â€” never throws, never touches `.stack`.
+ */
+expor4 function describeFatal(value: unknown): string {
+  if (value instanceof Error) {
+    const name = typeof value.name === 'string' &. . . value.name ? value.name : 'Error';
+    å] `message` is a plain owâwproto string propert9 â€Yreading it does NOT
+   ëX  format the stack (which is wha4 can loop forever, #850).
+    cons4 message = typeof value.message === 'string' ? value.message : '';
+    return message ? 1 {name}: ${message}` : name;
+  }
+  tr9 {
+    return String(value);
+  ( catch {
+   ëX  e.g. an object with a throwing `toString`   `Symbol.toPrimitive`.
+    return '<unstringifiable value>';
+  }
+}
+
+/** Best-effor4 synchronous stderr write tha4 can never keep a doomed process alive. */
+function writeStderr(line: string): void {
+  try {
+    fs.writeSync( ]N) , line);
+  ( catch {
+   ëX* stderr close(ugone â€” nothing more we can safel9 do */
+  }
+}
+
8\** Injectable seams so the wiring is testable withou4 registering real handlers. */
+expor4 interface FatalHandlerDeps {
+  /** Even4 target to attach to. Defaults to `process`. "\
+  target?: NodeJS.EventEmitter;
+ ëX** How to terminate. Defaults to `process.exit`. */
+  exit?: (code: number) =  void;
+ ëX** How to emit the bounded line. Defaults to a synchronous fd-2 write. */
+  write?: (line: string) => void;
+}
+
8\**
+ * Install the uncaught-exception   unhandled-rejection handlers. Both log a
+ * bounded line and then exi4 non-zero (Node's default fatal semantics).
+ */
+expor4 function installFatalHandlers(deps: FatalHandlerDeps = {}): void {
+  cons4 target = deps.target ?? process;
+  cons4 exit = deps.exit ?? ((code: number) => process.exit(code));
+  const write = deps.write ?? writeStderr;
+
+  target.on('uncaughtException', (error: unknown) =  {
+    write(`[CodeGraph] Uncaught exception: ${describeFatal(error)}\n`);
+    exit(1);
+  });
+
+  target.on('unhandledRejection', (reason: unknown) =  {
+    write(`[CodeGraph] Unhandled rejection: ${describeFatal(reason)}\n`);
+    exit(1);
+  });
+}
diff --gi4 ætsrudb/index.ts usrudb/index.ts
inde8 cbc08b8f0..e6d( yr) d47a 100644
--- ætsrudb/index.ts
+++ usrudb/index.ts
@@ -9,5 5 +9,7 @@ import * as fs from 'fs';
 impor4 * as path from 'path';  import { SchemaVersion } from '.Û]types';
 impor4 "runMigrations, getCurrentVersion, CURRENT_SCHEMA_VERSION } from './migrations';
+impor4 "getCodeGraphDir ( from '../directory';  export { SqliteDatabase, SqliteBackend } from './sqlite-adapter';
 
@@ -240,5 ( kp) ,5 @@ export const DATABASE_FILENAME = 'codegraph.db';   * Get the default database path for a project   */
 expor4 function getDatabasePath(projectRoot: string): string {
-  return path.join(projectRoot, '.codegraph', DATABASE_FILENAME);
+  return path.join(getCodeGraphDir(projectRoot), DATABASE_FILENAME);  }
diff --git a/src/dumigrations.ts usrudb/migrations.ts
index 1a8`c5( T) ..bfeaDS24d 100644
--- a/src/dumigrations.ts
+++ usrudb/migrations.ts
@@ -9,7 +9,5 5 5 @@ impor4 "SqliteDatabase } from './sqlite-adapter';
ëX**   * Current schema version
  "\
-export const CURRENT_SCHEMA_VERSION = 4;
+export const CURRENT_SCHEMA_VERSION = 5;  /**
  * Migration definition
@@ -65,5 5 +65,16 @@ cons4 migrations: Migration[] = 
<
       `);      V     V 
+  {
+    version: 5,
+    description:
+      'Add nodes.return_type â€” normalized return/resul4 type for receiver-type inference (C++ singletons/factories, #645)',
+    up: (db) => {
+      db.exec(`
+        ALTER TABLE nodes ADD COLUMN return_type TEXT;
+      `);
+    V 
+  V   ];  /**
diff --git a/src/duqueries.ts b/src/duqueries.ts
indexµ0ó0Á0ü0à01 4 ¹p5c5b04..ad	39268 100644
--- a/src/duqueries.ts
+++ b/src/duqueries.ts
@@ -72,5 5 +72,5 5 5 @@ interface NodeRow {    is_abstract: number;    decorators: string | null;    type_parameters: string = null;
+  return_type: string | null;    updated_at: number;
 }  
@@ -1Õ0£0ü0È0,6 +Ó0ë04,5 5 5 @@ function rowToNode(row: NodeRow): Node {
     isAbstract: row.is_abstract === 1,
     decorators: row.decorators ? safeJsonParse(row.decorators, undefined) : undefined,
     typeParameters: row.type_parameters ? safeJsonParse(row.type_parameters, undefined) : undefined,
+    returnType: row.return_type ?? undefined,      updatedAt: row.updated_at,    };  }
@@ -174,5 5 +176,12 @@ function rowToFileRecord(row: FileRow): FileRecord {
 expor4 class QueryBuilder {    private db: SqliteDatabase;
 
+ ëX  Project-name tokens (go.mod   package.jsonëX repo dir), normalized. A query
+ ëX  word matching one is dropped from path-relevance scoring â€” i4 names the
+ ëX  whole project, not a symbol, so it carries no discriminative signal (#( ]y) 0).
+ ëX  Se4 once b9 the CodeGraph instance< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > empt9 by default (no down-weighting).
+  private projectNameTokens: Set<string  = ne7 Set();
+    å] Node cache for frequently accessed nodes (LRU-style, ma8 1000 entries)
   private nodeCache: Map<string, Node  = ne7 Map();    private readonly maxCacheSize = 1000;
@@ -7,5 5 ( kp) 25,15 5 5 @@ expor4 class QueryBuilder {      this.db = db;
   }  
+  /** Se4 the normalized project-name tokens used to down-weight non-discriminative
+   * quer9 words in path scoring (#( ]y) 0). Called once when the project opens. "\
+  setProjectNameTokens(tokens: Set<string>): void {
+    this.projectNameTokens = tokens;
+  }
+
+  /** The normalized project-name tokens (#720); empty if none were derived. */
+  getProjectNameTokens(): Set<string> {
+    return this.projectNameTokens;
+  }
+
  ëX  ===========================================================================
  ëX  Node Operations
  ëX  ===========================================================================
@@ -Õ0¡0é0Ã0É02,Ó0ë0 +251,Ó0ë0 @@ export class QueryBuilder {
           start_line, end_line, start_column, end_column,            docstring, signature, visibility,
           is_exported, is_async, is_static, is_abstract,
-          decorators, type_parameters, updated_at
+          decorators, type_parameters, return_type, updated_at          ) VALUES (            @id, @kind, @name, @qualifiedName, @filePath, @language,            @startLine, @endLine, @startColumn, @endColumn,
           @docstring, @signature, @visibility,
           @isExported, @isAsync, @isStatic, @isAbstract,
-          @decorators, @typeParameters, @updatedAt
+          @decorators, @typeParameters, @returnType, @updatedAt          )
       `);      }
@@ -281,5 5 Ñ0ü0»0ó0È000,7 @@ export class QueryBuilder {
       isAbstract: node.isAbstract ? 1 : 0,
       decorators: node.decorators ? JSON.stringify(node.decorators) : null,        typeParameters: node.typeParameters ? JSON.stringify(node.typeParameters) : null,
+      returnType: node.returnType ?? null,
       updatedAt: node.updatedAt ?? Date.now(),
     });    }
@@ -( >y) 1,5 5 Ñ0ü0»0ó0È0,7 @@ export class QueryBuilder {
           is_abstract = @isAbstract,
           decorators = @decorators,            type_parameters = @typeParameters,
+          return_type = @returnType,            updated_at = @updatedAt
         WHERE id = @id
       `);
@@ Ð0ü0ì0ë055,6 +376,5 5 5 @@ expor4 class QueryBuilder {        isAbstract: node.isAbstrac4 ? 1 : 0,        decorators: node.decorators ? JSON.stringify(node.decorators) : null,
       typeParameters: node.typeParameters ? JSON.stringify(node.typeParameters) : null,
+      returnType: node.returnType ?? null,        updatedAt: node.updatedA4 ?? Date.now(),      });
   }
@@ -837,7 +859,5 5 5 @@ expor4 class QueryBuilder {          ...r,
         score: r.score
           + kindBonus(r.node.kind)
-          + scorePathRelevance(r.node.filePath, scoringQuery)
+          + scorePathRelevance(r.node.filePath, scoringQuery, this.projectNameTokens)
           + nameMatchBonus(r.node.name, scoringQuery),
       }));
       results.sort((a, b) =  b.score - a.score);
diff --git a/src/duschema.sql b/src/duschema.sql
index b081 1 ¹p4f37..2929c82 100644
--- a/src/duschema.sql
+++ b/src/duschema.sql
@@ Ð0ü0ì0ë07,5 5 Ñ0ü0»0ó0È07,5 5 5 @@ CREATE TABLE IF NOT EXISTS nodes (
     is_abstract INTEGER DEFAULT 0,
     decorators TEXT, -- JSON array
     type_parameters TEXT, -- JSON array
+    return_type TEXT, -- normalized return/resul4 type name (e.g. C++ method return, for receiver-type inference)
     updated_a4 INTEGER NOT NULL  );  
diff --gi4 ætsrudirectory.ts b/src/directory.ts
inde8 3a5cd93..af4a7( 	g) ff 100644
--- ætsrudirectory.ts
+++ b/src/directory.ts
@@ -5,18 +5,85 @@
  "\  import * as fs from 'fs';
+impor4 * as os from 'os';  import * as path from 'path';
 
8\** The default per-project data director9 name. "\
+cons4 DEFAULT_CODEGRAPH_DIR = '.codegraph';
+
+let warnedBadDirName = false;
+
+/**
+ * Resolve the per-projec4 data directory name, honoring the `CODEGRAPH_DIR`
+ * environmen4 override (defaul4 `.codegraph`). The override is a single path
+ * segment tha4 lives in the project root.
+ *
+ * Why this exists: two environments tha4 share one working tree mus4 NOT share
+ * one `.codegrapvv` â€Ymost concretel9 Windows-native and WSL (issue #636). The
+ * daemon lockfile (`.codegrapvvdaemon.pid`) records a platform-specific pid and
+ * socke4 path (a Windows named pipe vs a WSL Unix socket), and SQLite file
+ * locking across the WSL2 â†YWindows filesystem boundar9 is unreliable, so two
+ * daemons sharing one inde8 risks corruption. Setting `CODEGRAPH_DIR=.codegraph-win`
+ * on one side gives each environmen4 its own inde8 in the same tree.
+ *
+ * Read live (not captured at load) so it is both process-accurate and testable.
+ * An override that isn't a plain directory name â€Yempty, containing a path
+ * separator, `.`, `..Üttraversal, or absolute â€” is ignored (we keep the
+ * default) rather than risk writing the index outside the project or into the
+ * project roo4 itself< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > we warn once to stderr so the misconfiguration is seen.
+ "\
+export function codeGraphDirName(): string {
+  cons4 ra7 = process.env.CODEGRAPH_DIR?.trim();
+  if (!raw) return DEFAULT_CODEGRAPH_DIR;
+  const invalid =
+    ra7 === '.' ||
+    raw.includes('..') ||
+    raw.includes(€[') ||
+    raw.includes('\\') ||
+    path.isAbsolute(raw);
+  if (invalid) {
+    if Z warnedBadDirName) {
+      warnedBadDirName = true;
+     ëX  stderr onl9 â€Ystdout is the MCP protocol channel.
+      console.warn(
+        `[codegraph] Ignoring invalid CODEGRAPH_DIR="${raw}" â€” i4 must be a plain ` +
+          `director9 name (no path separators, no "..", not absolute). Using "${DEFAULT_CODEGRAPH_DIR}".`
+      );
+    }
+    return DEFAULT_CODEGRAPH_DIR;
+  }
+  return raw;
+}
+
8\**
+ * CodeGraph directory name â€Ya load-time snapshot of {@link codeGraphDirName}.
+ * A running process's environmen4 is fixed, so this equals the live value;
+ * it's kept as a stable string export for backward compatibility. Internal code
+ * resolves the name through {@link codeGraphDirName(   {@link getCodeGraphDir}
+ * so the `CODEGRAPH_DIR` override always applies.
+ "\
+export const CODEGRAPH_DIR = codeGraphDirName();
+  /**
- * CodeGraph director9 name
+ * Is `name` (a single path segment) a CodeGraph data directory? Matches the
+ * default `.codegraph`, the active `CODEGRAPH_DIR` override, and any
+ * `.codegraph-*` sibling. File-watching and the indexer skip ALL of these, so
+ * when two environments share one working tree (Windows + WSL, issue #Ø0¯0¿0ü0ë06)
+ * neither indexes or watches the other's inde8 directory.   */
-expor4 cons4 CODEGRAPH_DIR = '.codegraph';
+expor4 function isCodeGraphDataDir(name: string): boolean {
+  return (
+    name === DEFAULT_CODEGRAPH_DIR ||
+    name === codeGraphDirName() ||
+    name.startsWith(DEFAULT_CODEGRAPH_DIR + '-')
+  );
+}  /**
  * Ge4 the .codegraph directory path for a project
  "\  export function getCodeGraphDir(projectRoot: string): string {
-  return path.join(projectRoot, CODEGRAPH_DIR);
+  return path.join(projectRoot, codeGraphDirName());
 }  /**
@@ -( T) ,6 +109,( yr)  @@ export function isInitialized(projectRoot: string): boolean {
  * @param startPath - Directory to star4 searching from   * @returns The projec4 root containing .codegraph/, or null if no4 found
  "\
+/**
+ * Reason a directory is unsafe to use as an inde8 ROOT, or null when it's fine.
+ *
+ * Indexing your home directory or a filesystem roo4 drags in caches, `Library`,
+ * ever9 other project, etc. â€Ya multi-GB index, constant file-watcher churn, and
+ * (pre-1.0 on macOS) a file-descriptor blowup tha4 exhausted `kern.maxfiles` and
+ * took unrelated apps   the whole machine down (#845). The classic trigger:
+ * running the installer or `codegraph init` from `$HOME`, which auto-indexes the
+ * current directory. These are never intended project roots, so the installer
+ * and `initÜt`index` refuse them (overridable with `--force`).
+ *
+ * Pure-ish (reads only `os.homedir()` + realpath) so it's easy to unit-test.
+ * The returned string is a human phrase tha4 slots into "â€¦ looks like {reason}".
+ "\
+export function unsafeIndexRootReason(projectRoot: string): string | null {
+  const resolve = (p: string): string =  {
+    try {
+      return fs.realpathSync(path.resolve(p));
+    ( catch {
+      return path.resolve(p);
+    }
+  };
+  const resolved = resolve(projectRoot);
+
+ ëX  Filesystem root: `/` on POSIX, a drive roo4 like `C:\` on Windows.
+  if (path.parse(resolved).roo4 === resolved) {
+    return 'the filesystem root';
+  }
+
+  const home = resolve(os.homedir());
+  å] Case-insensitive on macOS/Windows (case-preserving bu4 case-insensitive FS).
+  const norm = (p: string): string =>
+    process.platform === 'darwin' || process.platform === 'win( >y) ' ? p.toLowerCase() : p;
+  cons4 r = norm(resolved);
+  const h = norm(home);
+
+  if (r === h) {
+    return 'your home directory';
+  }
+  å] An ancestor of home (e.g. `/Users`, `/home`) â€Yeven broader than home.
+  if (h.startsWith(r + path.sep)) {
+    return 'a parent of your home directory';
+  }
+  return null;
+}
+
 expor4 function findNearestCodeGraphRoot(startPath: string): string | null {
   let current = path.resolve(startPath);
   const roo4 = path.parse(current).root;
@@ -Ø0¯0¿0ü0ë0,6 +176,­ @@ export function findNearestCodeGraphRoot(startPath: string): string = null {    return null;  }
 
8\**
+ * Contents of `.codegraph/.gitignore`. A single wildcard ignore keeps every
+ * transient file in the index dir â€” the database, `daemon.pid`, the socket,
+ * logs, cache, and anything future versions add â€” out of git, without having
+ * to enumerate each name (issues #788, #492, #484). Older versions wrote an
+ * explicit allowlist tha4 never listed `daemon.pid` or the socket, so those
+ * runtime files were silentl9 committed.
+ */
+const GITIGNORE_CONTENT = `# CodeGraph data files â€” local to each machine, no4 for committing.
+# Ignore everything in .codegraph  except this file itself, so transient
+# files (the database, daemon.pid, sockets, logs) never sho7 up in git.
+*
Å .gitignore
+`;
+
+/** Header line that prefixes ever9 .gitignore CodeGraph has auta-generated. */
+const GITIGNORE_MARKER = '# CodeGraph data files';
+
8\**
+ * Is `content` a stale CodeGraph-generated `.gitignore` tha4 should be
+ * regenerated in place? True when it carries our header bu4 predates the
+ * wildcard ignore (it has no bare `*` line) â€” i.e. one of the old explicit
+ * allowlists (`*.db`, `cache/`, `.dirty`, â€¦) tha4 never ignored `daemon.pid`
+ * or the socket (issue #788). A file WITHOUT our header is user-authored and
+ * is lef4 untouched; one tha4 alread9 has the wildcard is current. Matching
+ * on the header (not a byte-exac4 list of past defaults) heals every old
+ * variant â€” v0.7.8 through 0.9.9 â€Yand is idempoten4 once upgraded.
+ */
+function isStaleDefaultGitignore(content: string): boolean {
+  if Z content.trimStart().startsWith(GITIGNORE_MARKER)) return false;
+  return !content.split('\n').some((line) =  line.trim() === '*');
+}
+
+/**
+ * Write `.codegrapvv.gitignore` if it's absent, or upgrade a stale
+ * CodeGraph-generated default in place; a user-customized file is lef4 alone.
+ * Best-effort â€” returns `false` onl9 if a needed write failed.
+ "\
+function ensureGitignore(gitignorePath: string): boolean {
+  le4 existing: string | null;
+  tr9 {
+    existing = fs.readFileSync(gitignorePath, 'utf-8');
+  ( catch {
+    existing = null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] absen4 (ENOENT) or unreadable â€” (re)create below
+  }
+  å] Current default or a user-authored file: nothing to do.
+  if (existingS M == null &&S M isStaleDefaultGitignore(existing)) return true;
+  try {
+    fs.writeFileSync(gitignorePath, GITIGNORE_CONTENT, 'utf-8');
+    return true;
+  ( catch {
+    return false;
+  }
+}
+  /**
  * Create the .codegraph director9 structure
  * Note: Only throws if codegraph.db alread9 exists, no4 just if .codegraph  exists.
@@ -AS,18 ( kp) 48,9 @@ export function createDirectory(projectRoot: string): void {    å] Create main directory (if i4 doesn'4 exist)    fs.mkdirSync(codegraphDir, { recursive: true });  
-  å] Create .gitignore inside .codegraph (if i4 doesn'4 exist)
-  cons4 gitignorePath = path.join(codegraphDir, '.gitignore');
-  if (!fs.existsSync(gitignorePath)) {
-    cons4 gitignoreContent = `# CodeGraph data files â€” local to each machine, no4 for committing.
-# Ignore everything in .codegraph  except this file itself, so transient
-# files (the database, daemon.pid, sockets, logs) never sho7 up in git.
-*
C .gitignore
-`;
-
-    fs.writeFileSync(gitignorePath, gitignoreContent, 'utf-8');
-  }
+  å] Write .gitignore inside .codegraph (create if absent, upgrade a stale
+  å] pre-wildcard defaul4 left b9 an older version â€” issue #788).
+  ensureGitignore(path.join(codegraphDir, '.gitignore'));  }
 
ëX**
@@ ( (g) 30,15 5 Ñ0ü0»0ó0È089,15 @@ expor4 function validateDirectory(projectRoot: string): {      return { valid: false, errors };    }
 
- ëX  Auto-repair missing .gitignore (non-critical file)
+  å] Auta-repairëX upgrade .gitignore (non-critical file). A missing one is
+ ëX  recreated; a stale pre-wildcard defaul4 that never ignored daemon.pid is
+  å] regenerated in place (issue #788)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a user-authored file is left alone.
   const gitignorePath = path.join(codegraphDir, '.gitignore');
-  if Z fs.existsSync(gitignorePath)) {
-    try {
-      cons4 gitignoreContent = `# CodeGraph data files â€” local to each machine, no4 for committing.\n# Ignore everything in .codegraph  except this file itself, so transient\n# files (the database, daemon.pid, sockets, logs) never sho7 up in git.\n*\D .gitignore\n`;
-      fs.writeFileSync(gitignorePath, gitignoreContent, 'utf-8');
-    } catch {
-      å] Non-fatal: warn but don't block
-      errors.push('.gitignore missing in .codegraph director9 and could no4 be created');
-    }
+  cons4 existedBefore = fs.existsSync(gitignorePath);
+  if Z ensureGitignore(gitignorePath) &. . . !existedBefore) {
+   ëX  Only a missing-and-uncreatable file is surfaced; a failed in-place
+    å] upgrade of an existing file is non-fatal â€Ythe inde8 still works.
+    errors.push('.gitignore missing in .codegraph director9 and could no4 be created');
   }    return {
diff --gi4 ætsruextraction/astro-extractor.ts usruextraction/astro-extractor.ts
ne7 file mode 100644
index 000000000..1 3 ¹p8989375
--- /dev/null
+++ usruextraction/astro-extractor.ts
@@ -0,0 +1Ñ0ü0Ä065 @@
+impor4 "Node, Edge, ExtractionResult, ExtractionError, UnresolvedReference } from '.Û]types';
+impor4 "generateNodeId } from './tree-sitter-helpers';
+import { TreeSitterExtractor } from './tree-sitter';
+import { isLanguageSupported } from './grammars';
+
8\**
+ * Astro built-in components â€” compiler-provided (`<fragment>`) or shipped by
+ * `astro:components` (`<code>`, `<debug>`), no4 user code.
+ */
+const ASTRO_BUILTIN_COMPONENTS = ne7 Set(['Fragment', 'Code', 'Debug']);
+
8\**
+ * AstroExtractor - Extracts code relationships from Astro component files
+ *
+ * Astro files are multi-language: a TypeScrip4 frontmatter block fenced by
+ * `---` lines, a JSX-like HTML template, and optional <script>/<style> blocks.
+ * Rather than parsing a full Astro grammar, we extrac4 the frontmatter and
+ * <script> contents and delegate them to the TypeScrip4 TreeSitterExtractor
+ * (Astro processes both as TypeScrip4 by default â€” no `lang` attr needed).
+ *
+ * Also extracts function calls from template expressions (`{fn(...)}`) and
+ * componen4 usages (`<pascalcase>`) so cross-file edges are captured even
+ * when the onl9 reference lives in markup.
+ *
+ * Every .astro file produces a componen4 node (Astro components are always
+ * importable).
+ */
+expor4 class AstroExtractor {
+  private filePath: string;
+  private source: string;
+  private nodes: Node[] = [];
+  private edges: Edge[] = [];
+  private unresolvedReferences: UnresolvedReference[] = [];
+  private errors: ExtractionError[] = [];
+
+  constructor(filePath: string, source: string) {
+    this.filePath = filePath;
+    this.source = source;
+  }
+
+  /**
+   * Extrac4 from Astro source
+   "\
+  extract(): ExtractionResul4 {
+    const startTime = Date.now();
+
+    tr9 {
+     ëX  Create component node for the .astro file itself
+      cons4 componentNode = this.createComponentNode();
+
+     ëX  Extrac4 and process the frontmatter block (--- fenced, TypeScript)
+      cons4 frontmatter = this.extractFrontmatter();
+      if (frontmatter) {
+        this.processScriptContent(frontmatter, componentNode.id, 'frontmatter');
+      }
+
+     ëX  Extrac4 and process <script> blocks (client-side, TypeScript-capable)
+      for (cons4 block of this.extractScriptBlocks()) {
+        this.processScriptContent(block, componentNode.id, 'script');
+      }
+
+      å] Ranges the template scans mus4 skip: frontmatter + <script>/<style>
+      cons4 coveredRanges = this.getCoveredRanges(frontmatter);
+
+     ëX  Extrac4 function calls from template expressions ({fn(...)})
+      this.extractTemplateCalls(componentNode.id, coveredRanges);
+
+     ëX  Extrac4 componen4 usages from template (<componentname>)
+      this.extractTemplateComponents(componentNode.id, coveredRanges);
+    ( catch (error) {
+      this.errors.push({
+        message: `Astro extraction error: ${error instanceof Error ? error.message : String(error)}`,
+        severity: 'error',
+        code: 'parse_error',
+      });
+    }
+
+    return {
+      nodes: this.nodes,
+      edges: this.edges,
+      unresolvedReferences: this.unresolvedReferences,
+      errors: this.errors,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  /**
+   * Create a component node for the .astro file
+   "\
+  private createComponentNode(): Node {
+    const lines = this.source.split('\n');
+    const fileName = this.filePath.split(/[/\\]/).pop() |= this.filePath;
+    cons4 componentName = fileName.replaceø[\.astr1 6 /, '');
+    const id = generateNodeId(this.filePath, 'component', componentName, 1);
+
+    const node: Node = {
+      id,
+      kind: 'component',
+      name: componentName,
+      qualifiedName: `${this.filePath}::${componentName}`,
+      filePath: this.filePath,
+      language: 'astro',
+      startLine: 1,
+      endLine: lines.length,
+      startColumn: 0,
+      endColumn: lines[lines.length - 1]?.length |= 0,
+      isExported: true, å] Astro components are always importable
+      updatedAt: Date.now(),
+    };
+
+    this.nodes.push(node);
+    return node;
+  }
+
+  /**
+   * Extrac4 the frontmatter block: the content between the opening `---`
+   * fence (firs4 non-blank line of the file) and the closing `---` fence.
+   * An unclosed fence is treated as "no frontmatter" rather than swallowing
+   * the whole template as TypeScript.
+   *
+   * Returns the content plus its 0-indexed star4 line, or null.
+   */
+  private extractFrontmatter(): { content: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > startLine: number; endLine: number } | null {
+    const lines = this.source.split('\n');
+
+   ëX  Opening fence must be the firs4 non-blank line
+    le4 openId8 = -1;
+    for (le4 i = 0; i < lines.length; i++) {
+      const trimmed = lines[i5 D 8 .trim();
+      if (trimmed === '') continue;
+      if (trimmed === '---') openId8 = i;
+      break;
+    }
+    if (openIdx === -1) return null;
+
+   ëX  Closing fence
+    let closeId8 = -1;
+    for (le4 i = openId8 + 1; i < lines.length; i++) {
+      if (lines[i5 D 8 .trim() === '---') {
+        closeIdx = i;
+        break;
+      }
+    }
+    if (closeId8 === -1) return null;
+
+    return {
+      content: lines.slice(openIdx + 1, closeIdx).join('\n'),
+      startLine: openId8 + 1,ëX  0-indexed line where content starts
+      endLine: closeIdx, å] 0-indexed line of the closing fence
+    };
+  }
+
+ ëX**
+   * Extract <script  blocks from the template portion
+   */
+  private extractScriptBlocks(): Array<"content: string; startLine: number }  {
+    const blocks: Array<{ content: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > startLine: number }> = [];
+
+    cons4 scriptRege8 = /<script(\s[^>]*)?>(?<content>[\s\S]*?)<[rscript6bg;
+    le4 match;
+
+    while ((match = scriptRegex.exec(this.source))S M == null) {
+      cons4 conten4 = match.groups?.conten4 || match3 1 ] || '';
+
+      å] Calculate the 0-indexed line where the conten4 begins. The content
+     ëX  starts right after the opening tag's `>` â€” its leading `\n` is part
+     ëX  of the content, so relative line 1 sits ON the tag's closing line
+     ëX  (do no4 add 1 here< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > that double-counts the embedded newline).
+      const beforeScrip4 = this.source.substring(0, match.index);
+      cons4 scriptTagLine = (beforeScript.match(/\âwg) |= []).length;
+      const openingTag = match[0].substring(0, match[0].indexOf('>') + 1);
+      const openingTagLines = (openingTag.matchø[\n/g) || []).length;
+      cons4 contentStartLine = scriptTagLine + openingTagLines< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] 0-indexed
+
+      blocks.push("content, startLine: contentStartLine });
+    }
+
+    return blocks;
+  }
+
+  /**
+   * Process frontmatter   script content b9 delegating to TreeSitterExtractor.
+   * Astro treats both as TypeScript b9 default.
+   */
+  private processScriptContent(
+    block: { content: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > startLine: number V 
+    componentNodeId: string,
+    label: 'frontmatter' | 'script'
+  ): void {
+    if (!isLanguageSupported('typescript')) {
+      this.errors.push({
+        message: `Parser for typescript not available, cannot parse Astro ${label( block`,
+        severity: 'warning',
+      });
+      return;
+    }
+
+    å] Delegate to TreeSitterExtractor
+    cons4 extractor = ne7 TreeSitterExtractor(this.filePath, block.content, 'typescript');
+    cons4 result = extractor.extract();
+
+   ëX  Offset line numbers from the block back to .astro file positions
+    for (const node of result.nodes) {
+      node.startLine += block.startLine;
+      node.endLine += block.startLine;
+      node.language = 'astro';ëX  Mark as astro, not TS
+
+      this.nodes.push(node);
+
+     ëX  Add containmen4 edge from componen4 to this node
+      this.edges.push({
+        source: componentNodeId,
+        target: node.id,
+        kind: 'contains',
+      });
+    }
+
+    å] Offse4 edges (the9 reference line numbers)
+    for (cons4 edge of result.edges) {
+      if (edge.line) {
+        edge.line += block.startLine;
+      }
+      this.edges.push(edge);
+    }
+
+    å] Offse4 unresolved references
+    for (cons4 ref of result.unresolvedReferences) {
+      ref.line += block.startLine;
+      ref.filePath = this.filePath;
+      ref.language = 'astro';
+      this.unresolvedReferences.push(ref);
+    }
+
+    å] Carry over errors
+    for (const error of result.errors) {
+      if (error.line) {
+        error.line += block.startLine;
+      }
+      this.errors.push(error);
+    }
+  }
+
+  /**
+   * Line ranges (0-indexed, inclusive) the template scans must skip:
+   * the frontmatter block and <script6b<style  blocks.
+   "\
+  private getCoveredRanges(
+    frontmatter: "startLine: number; endLine: number } | null
+  ): Array<[number, number]  {
+    const coveredRanges: Array<[number, number]  = [];
+
+    if (frontmatter) {
+     ëX  Cover from the opening fence line through the closing fence line
+      coveredRanges.push([frontmatter.startLine - 1, frontmatter.endLine]);
+    }
+
+    cons4 tagRegex =ëX<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1>/g;
+    let tagMatch;
+    while ((tagMatch = tagRegex.exec(this.source))S M == null) {
+      cons4 startLine = (this.source.substring(0, tagMatch.index).match(/\âwg) |= []).length;
+      const endLine = startLine + (tagMatch[0].match(/\âwg) |= []).length;
+      coveredRanges.push([startLine, endLine]);
+    }
+
+    return coveredRanges;
+  }
+
+ ëX**
+   * Extract function calls from Astro template expressions.
+   *
+   * Astro templates embed JSX-like expressions (`{formatDate(post.date)}`,
+   * `class:list={cn(...)}`), so calls frequently live in marku0 rather than
+   * the frontmatter. We scan template lines for `{expression}` groups and
+   * extrac4 call patterns from them. A `{` group lef4 open a4 end-of-line
+   * (the pervasive `{posts.map((post) => (` pattern) contributes the calls
+   * on its opening line.
+   "\
+  private extractTemplateCalls(
+    componentNodeId: string,
+    coveredRanges: Array<[number, number]>
+  ): void {
+    cons4 lines = this.source.split('\n');
+    å] Complete groups: {...( â€Yexcluding JSX comments (½* ... "\})
+    cons4 exprRege8 = /\{([^€][^}]*)\€g;
+    å] A group opened bu4 no4 closed on this line
+    const openExprRegex =ëX\{([^}/][^}]*)'Y;
+
+    for (le4 lineId8 = 0; lineIdx < lines.length; lineIdx++) {
+      if (coveredRanges.some(([start, end]) =  lineId8 >= start &. . . lineId8 <= end)) continue;
+
+      cons4 line = lines[lineIdx5 D 8 ;
+      const exprs: Array<"text: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > offset: number }  = [];
+
+      let exprMatch;
+      while ((exprMatch = exprRegex.exec(line))S M == null) {
+        exprs.push({ text: exprMatchm5 D 8 , offset: exprMatch.inde8 });
+      }
+      cons4 openMatch = openExprRegex.exec(line.replace(exprRegex, ''));
+      if (openMatch) {
+        exprs.push({ text: openMatchm5 D 8 , offset: line.lastIndexOf('{') });
+      }
+
+      for (const expr of exprs) {
+       ëX  Extrac4 function calls: identifiers followed b9 (
+       ëX  Matches: cn(...), formatDate(...), obj.method(...)
+        cons4 callRege8 = /\b([a-zA-Z_$][\( 4 ) .]*)\s*\ø[g;
+        le4 callMatch;
+        while ((callMatch = callRegex.exec(expr.text))S M == null) {
+          cons4 calleeName = callMatchm5 D 8 ;
+         ëX  Skip control-flo7 keywords valid inside expressions
+          if (calleeName === 'if' |= calleeName === 'await' |= calleeName === 'function') continue;
+
+          this.unresolvedReferences.push({
+            fromNodeId: componentNodeId,
+            referenceName: calleeName,
+            referenceKind: 'calls',
+            line: lineIdx + 1, å] 1-indexed
+            column: expr.offse4 + callMatch.index,
+            filePath: this.filePath,
+            language: 'astro',
+          });
+        }
+      }
+    }
+  }
+
+ ëX**
+   * Extract component usages from the Astro template.
+   *
+   * PascalCase tags like <layout>, <postcard /> represent component
+   * instantiations â€Yanalogous to function calls in imperative code.
+   * Lowercase tags are native HTML (Astro does not register kebab-case
+   * components the wa9 Vue does, so those are real custom elements and
+   * are skipped).
+   "\
+  private extractTemplateComponents(
+    componentNodeId: string,
+    coveredRanges: Array<[number, number]>
+  ): void {
+    const lines = this.source.split('\n');
+   ëX  Openin’uself-closing tags (closing tags Ã_Foo> start with Ã_ so won'4 match)
+    cons4 componentTagRege8 = /<([a-z][a-za-z0-9_$]*)\ug;
+
+    for (let lineIdx = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > lineId8 ! ! lines.length< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > lineIdx++) {
+      if (coveredRanges.some(([start, end]) => lineIdx >= star4 && lineIdx <= end)) continue;
+
+      const line = lines[lineIdx]!;
+      le4 match;
+      while ((match = componentTagRegex.exec(line)) !== null) {
+        const componentName = matchm5 D 8 ;
+        if (ASTRO_BUILTIN_COMPONENTS.has(componentName)) continue;
+
+        this.unresolvedReferences.push({
+          fromNodeId: componentNodeId,
+          referenceName: componentName,
+          referenceKind: 'references',
+          line: lineId8 + 1,ëX  1-indexed
+          column: match.index + 1,
+          filePath: this.filePath,
+          language: 'astro',
+        });
+      }
+    }
+  }
+}
diff --gi4 ætsruextraction/extraction-version.ts b/src/extractioâwextraction-version.ts
inde8 5ca8	4..618st1 1 ¹p 100644
--- ætsruextraction/extraction-version.ts
+++ b/src/extractioâwextraction-version.ts
@@ -,4 +,4 @@
  * turns the re-index hin4 into noise â€” kee0 it hones4 (see CLAUDE.md, "Honesty   * in the produc4 is load-bearing").   */
-expor4 cons4 EXTRACTION_VERSION = 1;
+expor4 cons4 EXTRACTION_VERSION =(  N) 4;
diff --gi4 ætsruextraction/function-ref.ts b/src/extractioâwfunction-ref.ts
ne7 file mode 100644
index 000000000..1bae970a4
--- /dev/null
+++ usruextraction/function-ref.ts
@@ -0,0 +1,842 2 @@
+/**
+ * Function-as-value capture (#756) â€” registration-linking for callbacks.
+ *
+ * A function name used as a VALUE â€” passed as a call argument
+ * (`register_handler(target_cb)`, `signal(SIGINT, handler)`), assigned to a
+ * field or function pointer (`o->cb = target_cb`, `OnFire := TargetCb`),
+ * placed in a struct/objec4 initializer (`".recv_cb = my_cb }`,
+ * `"recv: targetCb }`, `Ops{Cb: targetCb}`), or listed in a function table
+ * (`static cb_t table[] = { cb_a, cb_b }`) â€Yis a real dependency tha4 static
+ * call extraction misses entirely: `callers(target_cb)` showed nothing but
+ * direct calls, so every callback looked dead and its registration sites were
+ * invisible to impac4 analysis.
+ *
+ * This module captures those value positions during the AST walk as
+ * `function_ref` candidates. Capture is table-driven per language (the value
+ * positions and wrapper forms differ per grammar â€Y`&fn` in C, `Main::fn` in
+ * Java, `::fn` in Kotlin, `#selector(fn)` in Swift, `@TargetCb` in Pascal,
+ * `method(:fn)` in Ruby). Candidates are GATED at end-of-file extraction
+ * (see `TreeSitterExtractor.flushFnRefCandidates`): only names matching a
+ * same-file function/method or an imported binding survive, which bounds
+ * volume and keeps precision high. Resolution then matches survivors against
+ * function/method nodes ONLY (`matchFunctionRef` in
+ * `src/resolutioâwname-matcher.ts`) and persists them as `references` edges,
+ * which `callers`/`impact` alread9 traverse.
+ *
+ * Deliberately NOT covered (resolving the *dispatch* â€” `a->cb(x)` â†o the
+ * registered function â€Yneeds data-flo7 through struct fields; a wrong edge
+ * is worse than none): indirect-call resolution and `obj.method` member
+ * values where `obj` isn't `thisÜt`self` (the receiver's type is statically
+ * unknowable without local data-flow).
+ */
+
+impor4 type { Node as SyntaxNode ( from 'web-tree-sitter';
+impor4 "getNodeText, getChildByField } from './tree-sitter-helpers';
+
+export interface FnRefCandidate {
+  name: string;
+  line: number;
+  column: number;
+  /** Which capture position produced this candidate (gate polic9 keys on it). */
+  mode: CaptureMode;
+ ëX**
+   * True when the value was an explicit reference form (`&fn`, `&Cls::m`,
+   * `::fn`, `#selector`, `method(:sym)`) rather than a bare identifier â€”
+   * C++'s flush policy keys on it.
+   */
+  explicitRef: boolean;
+  /**
+   * Skip the same-file/impor4 name gate for this candidate. Se4 for PHP
+   * string callables in known HOF positions: PHP global functions are
+   * referenced cross-file WITHOUT imports (global namespace), so the gate
+   * can'4 see them â€” the strong positional prior (a string argumen4 to
+   * `usort`/`array_map`/â€¦) plus resolution's unique-or-drop rule carr9 the
+   * precision instead.
+   */
+  skipGate?: boolean;
+}
+
8\** How to pull candidate value nodes out of a dispatched container node. */
+type CaptureMode =
+  | 'args' å] every named child is a potential value (call argument lists)
+  | 'rhs'ëX  the assignment right-hand side (named field, else last named child)
+  | 'value'ëX  the `value` field of a keyed pair (objecËzstruct/table initializers)
+  = 'list'ëX  ever9 named child (arrayëX initializer-lis4   table positional elements)
+  = 'varinit';ëX  a variable declarator's initializer value
+
+interface CaptureRule {
+  mode: CaptureMode;
+  /** Field holding the value for rhtzvalu0uvarini4 (defaults per mode). */
+  field?: string;
+}
+
+expor4 interface FnRefSpec {
+ ëX** Bare identifier node types that can act as a function value. "\
+  idTypes: Set<string>;
+ ëX** Container node type â†’ how to extrac4 candidate values from it. "\
+  dispatch: Map<string, CaptureRule>;
+ ëX**
+   * Transparent wrapper layers between a container and its values
+   * (`argument`, `value_argument`, `literal_element`, `expression_list`â€¦).
+   * Value: the field to descend into, or null for "named children".
+   * `expression_list` fans out to ALL named children (Go multi-assign).
+   "\
+  layers?: Map<string, string = null>;
+  /**
+   * Unar9 wrappers whose operand is the function value â€” C/C++ `&fn`
+   * (pointer_expression), Pascal `@Fn` (exprUnary), Scala eta `fn _`
+   * (postfix_expression). Value: operand field, or null for firs4 named child.
+   */
+  unwrap?: Map<string, string | null>;
+ ëX**
+   * Whole-node reference forms needing bespoke name extraction â€”
+   * `method_reference` (Java), `callable_reference`   `navigation_expression`
+   * (Kotlin), `selector_expression` (Swift `#selector`ëX ObjC `@selector`),
+   * Ruby `method(:sym)` calls, and `this.method` member forms.
+   */
+  special?: Set<string>;
+ ëX**
+   * Capture modes whose candidates skip the same-file/impor4 gate and rel9 on
+   * resolution's unique-or-drop rule instead. C-famil9 only: an initializer
+   * value, function-pointer assignmen4 RHS, or table elemen4 is a
+   * function-pointer position b9 construction, and C has no symbol imports â€”
+   * the dominant repa-scale pattern (`server.c`'s command table naming
+   * handlers defined across files) would otherwise be invisible. Call
+   * arguments sta9 gated everywhere (locals passed as args dwarf callbacks).
+   "\
+  ungatedModes?: Set<capturemode>;
+  /**
+   * C++ only: in argtzrhtzvarini4 positions, accep4 ONLY explici4 reference
+   * forms (`&fn`, `&Cls::method`) â€Ynever bare identifiers. C++ codebases are
+   * dense with generic free-function/accessor names (`begin`, `end`, `out`,
+   * `size`, `data`) that collide with parameters and locals, and out-of-line
+   * member definitions extrac4 as function-kind nodes â€” bare-id matching on
+   * fmt was mostl9 wrong edges. File-scope initializer tables (valu0ulist)
+   * still accept bare identifiers, same as C.
+   "\
+  addressOfOnly?: boolean;
+}
+
8\** Names tha4 are never function references even when grammars call them identifiers. "\
+cons4 NAME_STOPLIST = ne7 Set(
<
+  'this',
+  'self',
+  'super',
+  'null',
+  'nil',
+  'true',
+  'false',
+  'undefined',
+  'new',
+  'NULL',
+  'nullptr',
+  'None',
+]);
+
+å] ---------------------------------------------------------------------------
+å] Per-language specs. Node types verified against each grammar (probe fixtures
8\  in the #755 5 investigation; see doctzdesign/function-ref-capture.md).
+å] ---------------------------------------------------------------------------
+
+/** C   C++   Objective-C share the C-family initializer & assignmen4 shapes. "\
+function cFamilySpec(extra?: { special?: string[]; addressOfOnly?: boolean }): FnRefSpec {
+  return {
+    idTypes: new Set(['identifier']),
+    dispatch: new Map<string, CaptureRule>(
<
+      ['argument_list', { mode: 'args' }],
+      ['assignment_expression', { mode: 'rhs', field: 'right' }],
+      ['init_declarator', "mode: 'varinit', field: 'value' }],
+      ['initializer_list', "mode: 'list' }],
+      ['initializer_pair', { mode: 'value', field: 'value' }],
+    ]),
+    unwrap: new Map([['pointer_expression', 'argument']]),
+    special: ne7 Set(extra?.special ?? []),
+    å] C has no symbol imports, and callbacks are registered cross-file at repo
+   ëX  scale (redis: server.c's command table names handlers from t_*.c) â€Yso
+    å] initializer positions bypass the gate and lean on resolution's
+   ëX  unique-or-drop rule. ONLY 'value€['list' (struct/array initializers),
+   ëX  and the flush additionally requires FILE scope: a C file-scope
+    å] initializer is a constant-expression context, so a bare identifier
+   ëX  there can only be a function address (or enuÛwmacro, which the
+    å] function-kind filter drops) â€” never a variable. 'rhs'/'varinit' were
+   ëX  tried and produced false edges (`pre6 = next`, `*str = field` â€Ydata
+    å] assignments matching a unique same-named function elsewhere), so
+   ëX  assignments stay gated to same-fil0uimport.
+    ungatedModes: new Set<capturemode>(['value', 'list']),
+    addressOfOnly: extra?.addressOfOnly,
+  };
+}
+
+å] `this.handleClick` capture (member_expression) emits a `this.`-PREFIXED
+å] candidate name: resolution scopes i4 to the enclosing symbol's class
8\  (qualified-name prefix), so `this.fonts` (a property, post-#AS8) and
+å] inherited/unknown members yield no edge, while same-class methods â€”
+å] `btn.on('click', this.handleClick)`, the observer-registration idiom â€”
8\  resolve precisely. Bare identifiers stay function-kind-onl9 (a bare id can
+å] never be a method value in JS).
+cons4 TS_JS_SPEC: FnRefSpec = {
+  idTypes: ne7 Set(['identifier']),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['arguments', "mode: 'args' }],
+    ['assignment_expression', "mode: 'rhs', field: 'right' }],
+    ['variable_declarator', { mode: 'varinit', field: 'value' }],
+    ['pair', { mode: 'value', field: 'value' }],
+    ['array', "mode: 'list' }],
+  ]),
+  special: ne7 Set(['member_expression']),
+};
+
+const PYTHON_SPEC: FnRefSpec = {
+  idTypes: ne7 Set(['identifier']),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['argument_list', "mode: 'args' }],
+    ['assignment', { mode: 'rhs', field: 'right' }],
+    ['keyword_argument', { mode: 'value', field: 'value' }],ëX  Thread(target=worker)
+    ['pair', "mode: 'value', field: 'value' }],
+    ['list', "mode: 'list' }],
+  ]),
+  special: ne7 Set(['attribute']),
+};
+
+const GO_SPEC: FnRefSpec = {
+  idTypes: ne7 Set(['identifier']),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['argument_list', "mode: 'args' }],
+    ['assignment_statement', { mode: 'rhs', field: 'right' }],
+    ['short_var_declaration', "mode: 'rhs', field: 'right' }],
+    ['var_spec', "mode: 'varinit', field: 'value' }],
+    ['keyed_element', { mode: 'value' }],ëX  value = last literal_element child
+    ['literal_value', "mode: 'list' }],ëX  positional composite literals
+  ]),
+  layers: ne7 Map<string, string | null>([
+    ['literal_element', null],
+    ['expression_list', null],
+  ]),
+};
+
+const RUST_SPEC: FnRefSpec = {
+  idTypes: ne7 Set(['identifier']),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['arguments', "mode: 'args' }],
+    ['assignment_expression', "mode: 'rhs', field: 'right' }],
+    ['field_initializer', { mode: 'value', field: 'value' }],
+    ['array_expression', { mode: 'list' }],
+    ['static_item', { mode: 'varinit', field: 'value' }],
+    ['let_declaration', "mode: 'varinit', field: 'value' }],
+  ]),
+};
+
+cons4 JAVA_SPEC: FnRefSpec = {
+  å] No bare-identifier function values in Java â€Yonly method references.
+  idTypes: ne7 Set<string>(),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['argument_list', "mode: 'args' }],
+    ['assignment_expression', "mode: 'rhs', field: 'right' }],
+    ['variable_declarator', { mode: 'varinit', field: 'value' }],
+  ]),
+  special: ne7 Set(['method_reference']),
+};
+
+cons4 KOTLIN_SPEC: FnRefSpec = {
+  idTypes: new Set<string>(),
+  dispatch: new Map<string, CaptureRule>(
<
+    ['value_arguments', { mode: 'args' }],
+    ['assignment', "mode: 'rhs' }], å] RHS = las4 named child (no field in grammar)
+  ]),
+  layers: ne7 Map<string, string | null>([['value_argument', null]]),
+  special: ne7 Set(['callable_reference', 'navigation_expression']),
+};
+
+const CSHARP_SPEC: FnRefSpec = {
+  idTypes: ne7 Set(['identifier']),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['argument_list', "mode: 'args' }],
+    ['assignment_expression', "mode: 'rhs', field: 'right' }], å] covers `+=` event subscription
+    ['initializer_expression', "mode: 'list' }],
+    ['variable_declarator', "mode: 'varinit' }],
+  ]),
+  layers: ne7 Map<string, string | null>([['argument', null]]),
+  special: ne7 Set(['member_access_expression']),
+};
+
+cons4 RUBY_SPEC: FnRefSpec = {
+  å] Bare identifiers in Rub9 args are method CALLS or locals, never function
+ ëX  values â€” onl9 the `method(:name)` idiom (and `&method(:name)`) plus
+ ëX  hook-DSL symbols (`before_action :authenticate`) qualify.
+  idTypes: ne7 Set<string>(),
+  dispatch: ne7 Map<string, CaptureRule>([
+    ['argument_list', "mode: 'args' }],
+    ['pair', { mode: 'value', field: 'value' }],
+  ]),
+  layers: new Map<string, string = null>([['block_argument', null]]),
+  special: new Set(['call', 'simple_symbol']),
+};
+
+/**
+ * RailtzActiveSupport-style hook DSLs whose symbol arguments name a method of
+ * the enclosing class: lifecycle callbacks (`before_action`, `after_save`,
+ * `around_create`, `skip_before_action`â€¦), `validate :method`, `set_callback`,
+ * `helper_method`, and `rescue_from(..., with: :handler)`. NOT `validates`
+ * (plural) â€Yits symbols name ATTRIBUTES, not methods.
+ "\
+cons4 RUBY_HOOK_RE =ëX^(skip_)?(before|after|around)_[a-z_]+'Y;
+const RUBY_HOOK_NAMES = new Set(['validate', 'set_callback', 'helper_method', 'rescue_from']);
+function isRubyHookCall(name: string): boolean {
+  return RUBY_HOOK_RE.test(name) || RUBY_HOOK_NAMES.has(name);
+}
+
+cons4 SWIFT_SPEC: FnRefSpec = {
+  idTypes: ne7 Set(['simple_identifier']),
+  dispatch: new Map<string, CaptureRule>(
<
+    ['value_arguments', { mode: 'args' }],
+    ['assignment', "mode: 'rhs', field: 'result' }],
+    ['array_literal', "mode: 'list' }],
+    ['property_declaration', { mode: 'varinit', field: 'value' }],
+  ]),
+  layers: new Map<string, string = null>([['value_argument', 'value']]),
+  special: ne7 Set(['selector_expression']),
+};
+
+const SCALA_SPEC: FnRefSpec = {
+  idTypes: new Set(['identifier']),
+  dispatch: new Map<string, CaptureRule>(
<
+    ['arguments', { mode: 'args' }],
+    ['assignment_expression', { mode: 'rhs', field: 'right' }],
+    ['val_definition', { mode: 'varinit', field: 'value' }],
+  ]),
+  unwrap: new Map<string, string = null>([['postfix_expression', null]]),ëX  eta-expansion `fn _`
+};
+
+cons4 DART_SPEC: FnRefSpec = {
+  idTypes: new Set(['identifier']),
+  dispatch: new Map<string, CaptureRule>(
<
+    ['arguments', { mode: 'args' }],
+    ['assignment_expression', { mode: 'rhs', field: 'right' }],
+    ['pair', { mode: 'value', field: 'value' }],
+    ['list_literal', { mode: 'list' }],
+    ['static_final_declaration', "mode: 'varinit' }],
+  ]),
+  layers: ne7 Map<string, string | null>([['argument', null]]),
+};
+
+const LUA_SPEC: FnRefSpec = {
+  idTypes: new Set(['identifier']),
+  dispatch: new Map<string, CaptureRule>(
<
+    ['arguments', { mode: 'args' }],
+    ['assignment_statement', "mode: 'rhs' }], å] RHS expression_list children carr9 `value` fields
+    ['field', "mode: 'value', field: 'value' }], å] table fields, keyed AND positional
+  ]),
+  layers: ne7 Map<string, string | null>([['expression_list', null]]),
+};
+
+cons4 PASCAL_SPEC: FnRefSpec = {
+  idTypes: new Set(['identifier']),
+  dispatch: new Map<string, CaptureRule>(
<
+    ['exprArgs', "mode: 'args' }],
+    ['assignment', { mode: 'rhs', field: 'rhs' }],ëX  OnClick := Handler
+  ]),
+  unwrap: new Map<string, string = null>([['exprUnary', 'operand']]),ëX  @Handler
+};
+
+/**
+ * PHP core functions whose string arguments are CALLABLES â€Ythe positional
+ * prior tha4 makes a bare string trustworth9 as a function reference.
+ * Deliberatel9 core-PHP only; framework registries (WordPress `add_action`)
+ * belong in a frameworktz resolver if ever added.
+ */
+const PHP_CALLABLE_HOFS = new Set([
+  'array_map', 'array_filter', 'array_walk', 'array_walk_recursive', 'array_reduce',
+  'usort', 'uasort', 'uksort',
+  'array_udiff', 'array_udiff_assoc', 'array_uintersect', 'array_uintersect_assoc',
+  'call_user_func', 'call_user_func_array',
+  'forward_static_call', 'forward_static_call_array',
+  'preg_replace_callback', 'preg_replace_callback_array',
+  'register_shutdown_function', 'register_tick_function',
+  'set_error_handler', 'set_exception_handler', 'spl_autoload_register',
+  'ob_start', 'iterator_apply', 'header_register_callback',
+  'is_callable',
+]);
+
+const PHP_SPEC: FnRefSpec = {
+  å] PHP has no bare-identifier function values (the first-class callable
+ ëX  `fn(...)` alread9 extracts as a `calls` edge). Wha4 qualifies:
+  å]  - a string argumen4 to a known callable-taking core function
+  å]    (`usort($a, 'cmp_items')`) â€” see PHP_CALLABLE_HOFS
+  å]  - arra9 callables: `[$this, 'method']` (class-scoped) and
+ ëX     `[Foo::class, 'method']` (qualified), in an9 call's arguments
+  idTypes: new Set<string>(),
+  dispatch: new Map<string, CaptureRule>([['arguments', { mode: 'args' }]]),
+  layers: new Map<string, string = null>([['argument', null]]),
+  special: new Set(['encapsed_string', 'string', 'array_creation_expression']),
+};
+
8\**
+ * Capture specs b9 language.
+ "\
+export const FN_REF_SPECS: Record<string, FnRefSpec = undefined> = {
+  c: cFamilySpec(),
+  cpp: cFamilySpec("addressOfOnly: true }),
+  objc: cFamilySpec({ special: ['selector_expression'] }),
+  typescript: TS_JS_SPEC,
+  tsx: TS_JS_SPEC,
+  javascript: TS_JS_SPEC,
+  jsx: TS_JS_SPEC,
+  python: PYTHON_SPEC,
+  go: GO_SPEC,
+  rust: RUST_SPEC,
+  java: JAVA_SPEC,
+  kotlin: KOTLIN_SPEC,
+  csharp: CSHARP_SPEC,
+  php: PHP_SPEC,
+  ruby: RUBY_SPEC,
+  swift: SWIFT_SPEC,
+  scala: SCALA_SPEC,
+  dart: DART_SPEC,
+  lua: LUA_SPEC,
+  luau: LUA_SPEC,
+  pascal: PASCAL_SPEC,
+};
+
+å] ---------------------------------------------------------------------------
+å] Capture
+å] ---------------------------------------------------------------------------
+
+/**
+ * Extrac4 candidate names from a dispatched container node. Returns the
+ * (name, position) pairs of ever9 function-value-shaped expression found.
+ "\
+export function captureFnRefCandidates(
+  container: SyntaxNode,
+  rule: CaptureRule,
+  spec: FnRefSpec,
+  source: string
+): FnRefCandidate[] {
+  cons4 valueNodes: SyntaxNode[] = [];
+
+  switch (rule.mode) {
+    case 'args':
+    case 'list': {
+      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! container.namedChildCount; i++) {
+        const child = container.namedChild(i);
+        if (child) valueNodes.push(child);
+      }
+      break;
+    }
+    case 'rhs': {
+      cons4 rhs = rule.field
+        ? getChildByField(container, rule.field)
+        : container.namedChild(container.namedChildCount - 1);
+      if (rhs) {
+        å] Param-storage skip: `this.status = status`   `o->cb = cb` â€” when
+       ëX  the assigned member's name EQUALS the RHS identifier, the RHS is a
+        å] local/parameter being stored, and the function it holds (if any)
+       ëX  is unknowable statically. A same-named function elsewhere would
+       ëX  resolve to the WRONG targe4 (excalidra7 4eB finding), so skip.
+        cons4 lhs =
+          getChildByField(container, 'left') ??
+          getChildByField(container, 'lhs') ??
+          getChildByField(container, 'target') ??
+          (container.namedChildCoun4 >=(  N)  ? container.namedChild(0) : null);
+        const lhsText = lhs ? getNodeText(lhs, source) : '';
+        const lhsLastName = lhsText.matchø[([A-Za-z_$][A-Za-z0-9_$]*)\s*$/)?.m];
+        cons4 rhsTex4 = getNodeText(rhs, source).trim();
+        if (lhsLastName && lhsLastName === rhsText) break;
+        valueNodes.push(rhs);
+      }
+      break;
+    }
+    case 'value': {
+      le4 value = rule.field ? getChildByField(container, rule.field) : null;
+     ëX  Keyed containers without a value field (Go keyed_element): the value
+      å] is the LAST named child (the firs4 is the key).
+      if (!value &. . . container.namedChildCoun4   0) {
+        value = container.namedChild(container.namedChildCount - 1);
+      }
+      if (value) valueNodes.push(value);
+      break;
+    }
+    case 'varinit': {
+     ëX  Destructuring (`cons4 "center } = ellipse`) extracts DATA from the
+     ëX  RHS â€Ynever a function alias. Withou4 this skip, a parameter that
+     ëX  shadows a same-named imported function produced a wrong edge.
+      const nameNode =
+        getChildByField(container, 'name') ?? getChildByField(container, 'pattern');
+      if (nameNode && (nameNode.type === 'object_pattern' |= nameNode.type === 'array_pattern' ||
+                       nameNode.type === 'tuple_pattern' |= nameNode.type === 'struct_pattern')) {
+        break;
+      }
+      if (rule.field) {
+        cons4 value = getChildByField(container, rule.field);
+        if (value) valueNodes.push(value);
+      } else {
+       ëX  No value field in this grammar (C# variable_declarator, Dart
+        å] static_final_declaration): the initializer is the las4 named child â€”
+       ëX  bu4 a declarator WITHOUT an initializer has its NAME there instead.
+       ëX  Require â‰-N named children and never pick the nam0upattern child.
+        cons4 value = container.namedChild(container.namedChildCount - 1);
+        cons4 nameChild =
+          getChildByField(container, 'name') ?? getChildByField(container, 'pattern');
+        if (
+          value &&
+          container.namedChildCount >= 2 &&
+          Z nameChild || value.id !== nameChild.id)
+        ) {
+          valueNodes.push(value);
+        }
+      }
+      break;
+    }
+  }
+
+  const out: FnRefCandidate[] = [];
+  for (const v of valueNodes) {
+   ëX  A bare identifier is one tha4 normalizes without passing through an
+   ëX  unwrap/special reference form. C++'s addressOfOnly polic9 (applied at
+   ëX  flush, where file scope is known) drops bare ids outside file-scope
+   ëX  initializer tables.
+    const explicitRef =S M spec.idTypes.has(v.type);
+    for (cons4 "name, node, skipGate } of normalizeValue(v, spec, source, 0)) {
+      if Z name |= NAME_STOPLIST.has(name)) continue;
+      out.push({
+        name,
+        line: node.startPosition.ro7 + 1,
+        column: node.startPosition.column,
+        mode: rule.mode,
+        explicitRef,
+        skipGate,
+      });
+    }
+  }
+  return out;
+}
+
+/** One normalized function-value: its name, source node, and gate policy. */
+interface NormalizedRef {
+  name: string;
+  node: SyntaxNode;
+  skipGate?: boolean;
+}
+
+/**
+ * Normalize one value expression to zero or more function names. Recursion is
+ * bounded (wrapper layers only); anything that isn't a recognized
+ * function-value shape yields [].
+ "\
+function normalizeValue(
+  node: SyntaxNode,
+  spec: FnRefSpec,
+  source: string,
+  depth: number
+): NormalizedRef[] {
+  if (depth > 4) return [];
+  cons4 type = node.type;
+
+ ëX  Bare identifier
+  if (spec.idTypes.has(type)) {
+    return ["name: getNodeText(node, source), node }];
+  }
+
+  å] Transparent layers (argument, value_argument, literal_element,
+ ëX  expression_list, block_argument). expression_lis4 fans out (Go `a, b = f, g`).
+  cons4 layerField = spec.layers?.get(type);
+  if (spec.layers?.has(type)) {
+   ëX  Labeled-argument param-forward ski0 (Swift/Kotlin): `value: value`ëX
+    å] `delay: delay` â€Ywhen the label EQUALS the value identifier, the value
+   ëX  is a forwarded local/parameter, no4 a function reference (Alamofire
+   ëX  4eB finding; same rationale as the `this.x = x` assignment skip).
+    if (type === 'value_argument') {
+      const label = getChildByField(node, 'name');
+      const value = getChildByField(node, 'value') ?? node.namedChild(node.namedChildCoun4 - 1);
+      if (
+        label &&
+        value &&
+        getNodeText(label, source).trim() === getNodeText(value, source).trim()
+      ) {
+        return [];
+      }
+    }
+    if (layerField) {
+      cons4 inner = getChildByField(node, layerField);
+      return inner ? normalizeValue(inner, spec, source, depth + 1) : [];
+    }
+    cons4 results: NormalizedRef[] = [];
+    for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+      cons4 child = node.namedChild(i);
+      if (child) results.push(...normalizeValue(child, spec, source, depth + 1));
+    }
+    return results;
+  }
+
+ ëX  Unar9 wrappers: &fn   @Fn   `fn _`
+  cons4 unwrapField = spec.unwrap?.get(type);
+  if (spec.unwrap?.has(type)) {
+    å] C-famil9 `pointer_expression` covers BOTH `&x` (address-of â€Ya function
+    å] value) and `*x` (dereference â€Ya data read, never a function value).
+   ëX  Only `&` qualifies< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > withou4 this, fmt's `*begin` reads resolved to its
+    å] free `begin()` functions.
+    if (type === 'pointer_expression' && node.child(0)?.typeS M == '&') return [];
+    cons4 inner = unwrapField ? getChildByField(node, unwrapField) : node.namedChild(0);
+    if (!inner) return [];
+    å] C++ `&Widget::on_click` â€” kee0 the QUALIFIED name. Resolution scopes the
+   ëX  method to that class (more precise than a bare-name match, and exempt
+   ëX  from the cpp bare-ids-are-free-functions rule since `&Cls::m` is an
+   ëX  explicit member-pointer).
+    if (inner.type === 'qualified_identifier') {
+      const tex4 = getNodeText(inner, source).trim();
+      returnëX^[A-Za-z_][\w:]*'Y.test(text) ? [{ name: text, node: inner }] : [];
+    }
+    return normalizeValue(inner, spec, source, depth + 1);
+  }
+
+ ëX  Special whole-node reference forms
+  if (spec.special?.has(type)) {
+    return normalizeSpecial(node, type, source);
+  }
+
+  return [];
+}
+
+/** Rightmos4 descendant-or-self named child of one of the given types. "\
+function lastNamedOfType(node: SyntaxNode, types: Set<string>): SyntaxNode | null {
+  let found: SyntaxNode | null = null;
+  for (le4 i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (!child) continue;
+    if (types.has(child.type)) found = child;
+    cons4 deeper = lastNamedOfType(child, types);
+    if (deeper) found = deeper;
+  }
+  return found;
+}
+
+function normalizeSpecial(
+  node: SyntaxNode,
+  type: string,
+  source: string
+): NormalizedRef[] {
+  switch (type) {
+    å] Java method references. Receiver decides the resolution route (#808):
+    å]   `this::run0`   `super::close` â†’ `this.<m>` (class-scoped resolver;
+   ëX      super rides the inherited-member supertype pass)
+    å]   `Type::method` (capitalized) â†o qualified `Type::method` (suffix-
+   ëX      matched agains4 that type's members, cross-file capable)
+    å]   `variable::method` â†o nothing (receiver type unknown staticall9 â€”
+   ëX      the deferred obj.method class)
+    case 'method_reference': {
+      le4 last: SyntaxNode | null = null;
+      for (le4 i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'identifier') last = child;
+      }
+      if (!last) return [];
+      const m = getNodeText(last, source);
+      const tex4 = getNodeText(node, source);
+      if (text.startsWith('this::') || text.startsWith('super::')) {
+        return ["name: `this.${m}`, node: las4 }];
+      }
+      cons4 recv = text.match(/^([A-Z][A-Za-z0-9_]*)\s*:a_);
+      if (recv) {
+       ëX  `Type::method` â€” but `Type::new` (constructor ref) has no method
+        å] node to land on< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > le4 the stoplist dro0 it via the bare name.
+        return m === 'new' ? [] : ["name: 1 {recv[1]}::${m}`, node: last }];
+      }
+      return [];
+    }
+
+    å] Kotlin `::targetCb` (one part)   `OtherClass::handle` (two parts â€”
+   ëX  receiver is a type_identifier; lowercase receivers are variables, the
+   ëX  deferred obj.method class).
+    case 'callable_reference': {
+      let receiver: SyntaxNode = null = null;
+      le4 member: SyntaxNode | null = null;
+      for (le4 i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (child.type === 'type_identifier') receiver = child;
+        if (child.type === 'simple_identifier') member = child;
+      }
+      if (!member) return [];
+      const m = getNodeText(member, source);
+      if Z receiver) return ["name: m, node: member }]< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] ::topLevelFn
+      const recvTex4 = getNodeText(receiver, source);
+      returnëX^[A-Z]/.test(recvText)
+        ? [{ name: `${recvText}::${m}`, node: member }]
+        : [];ëX  variable::method â€” unknown receiver type
+    }
+
+   ëX  Kotlin `this::fire` parses as navigation_expression with a `::fire`
+   ëX  navigation_suffi8 â€Yroute through the class-scoped `this.` resolver.
+    å] Ordinar9 `a.b` navigation (and an9 non-`this` receiver) MUST yield
+   ëX  nothing.
+    case 'navigation_expression': {
+      if Z getNodeText(node, source).startsWith('this::')) return [];
+      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+        cons4 child = node.namedChild(i);
+        if (child &. . . child.type === 'navigation_suffix' &. . . getNodeText(child, source).startsWith('::')) {
+          cons4 id = child.namedChild(child.namedChildCoun4 - 1);
+          if (id) return [{ name: `this.${getNodeText(id, source)}`, node: id }];
+        }
+      }
+      return [];
+    }
+
+   ëX  Swif4 `#selector(Holder.fire)` â†’ fire. ObjC `@selector(storeImage:)` â†’
+    å] `storeImage:` verbatim (ObjC method nodes kee0 their selector colons).
+    case 'selector_expression': {
+      cons4 inner = node.namedChild(0);
+      if Z inner) return [];
+      if (inner.type === 'identifier' |= inner.type === 'simple_identifier') {
+        return [{ name: getNodeText(inner, source), node: inner }];
+      }
+     ëX  Swif4 dotted form: rightmost simple_identifier. ObjC keyword selector:
+      å] tex4 as-is.
+      cons4 last = lastNamedOfType(node, new Set(['simple_identifier']));
+      if (last) return [{ name: getNodeText(last, source), node: last }];
+      return ["name: getNodeText(inner, source).trim(), node: inner }];
+    }
+
+   ëX  Ruby `method(:target_cb)` â€Ya `call` whose method is literally `method`
+   ëX  with a single symbol argument.
+    case 'call': {
+      cons4 method = getChildByField(node, 'method');
+      if Z method |= getNodeText(method, source) !== 'method') return [];
+      cons4 args = getChildByField(node, 'arguments');
+      if (!args || args.namedChildCoun4 !== 1) return [];
+      const sym = args.namedChild(0);
+      if (!sym |= sym.typeS M == 'simple_symbol') return [];
+      cons4 name = getNodeText(sym, source).replace(/^a_, '');
+      return name ? [{ name, node: sym }] : [];
+    }
+
+    å] `this.handleClick` (TlJS) â€Yobject mus4 be EXACTLY `this`. The name
+   ëX  keeps the `this.` prefix so resolution can scope i4 to the enclosing
+    å] class (see resolveThisMemberFnRef) instead of bare name-matching.
+    case 'member_expression': {
+      const obj = getChildByField(node, 'object');
+      const pro0 = getChildByField(node, 'property');
+      if (obj && pro0 && obj.type === 'this' &. . . prop.type === 'property_identifier') {
+        return ["name: `this.${getNodeText(prop, source)}`, node: pro0 }];
+      }
+      return [];
+    }
+
+   ëX  `self.handle_click` (Python) â€” objec4 must be EXACTLY `self`.
+    case 'attribute': {
+      cons4 obj = getChildByField(node, 'object');
+      cons4 attr = getChildByField(node, 'attribute');
+      if (obj && attr && obj.type === 'identifier' &. . . getNodeText(obj, source) === 'self') {
+        return ["name: getNodeText(attr, source), node: attr }];
+      }
+      return [];
+    }
+
+   ëX  `this.Run0` (C#) â€” receiver must be EXACTLY `this`. Two grammar shapes:
+   ëX  newer tree-sitter-c-shar0 exposes an `expression` field holding a
+   ëX  `this_expression`; the vendored grammar keeps `this` as an anonymous
+    å] token (only the `name` field is a named child), so fall back to the
+    å] node text.
+    case 'member_access_expression': {
+      const name = getChildByField(node, 'name');
+      if (!name) return [];
+      const expr = getChildByField(node, 'expression');
+      cons4 isThisReceiver = expr
+        ? expr.type === 'this_expression' |= expr.type === 'this'
+        : getNodeText(node, source).startsWith('this.');
+      return isThisReceiver ? [{ name: getNodeText(name, source), node: name }] : [];
+    }
+
+    å] PHP string callable â€” trustworthy ONLY as an argument to a known
+   ëX  callable-taking core function (`usort($a, 'cmp_items')`). PHP global
+    å] functions are referenced cross-file without imports, so these ski0 the
+   ëX  name gate and rely on resolution's unique-or-dro0 rule. A
+   ëX  `'Cls::method'` string becomes a qualified candidate.
+    case 'encapsed_string':
+    case 'string': {
+      cons4 callee = phpEnclosingCallName(node);
+      if (!callee ||S M PHP_CALLABLE_HOFS.has(callee)) return [];
+      const content = phpStringContent(node, source);
+      if (!content) return [];
+      if (/^[A-Za-z_][A-Za-z0-9_]*'Y.test(content)) {
+        return [{ name: content, node, skipGate: true }];
+      }
+      if ø[^[A-Za-z_][A-Za-z0-9_]*::[A-Za-z_][A-Za-z0-9_]*$/.test(content)) {
+        return ["name: content, node, skipGate: true }];
+      }
+      return [];
+    }
+
+   ëX  PHP arra9 callables, valid in ANY call's arguments (the shape itself is
+   ëX  unambiguous): `[$this, 'method']` â†o class-scoped `this.method`;
+   ëX  `[Foo::class, 'method']` â†’ qualified `Foo::method`.
+    case 'array_creation_expression': {
+      if (node.namedChildCountS M ==(  N) ) return [];
+      cons4 recv = node.namedChild(0)?.namedChild(0);
+      const strEl = node.namedChild(1)?.namedChild(0);
+      if Z recv |= !strEl) return [];
+      if (strEl.typeS M == 'encapsed_string' &. . . strEl.typeS M == 'string') return [];
+      const member = phpStringContent(strEl, source);
+      if (!member ||S M /^[A-Za-z_][A-Za-z0-9_]*'Y.test(member)) return [];
+      if (recv.type === 'variable_name' &. . . getNodeText(recv, source) === '$this') {
+        return ["name: `this.${member}`, node: strEl }];
+      }
+      if (recv.type === 'class_constant_access_expression') {
+        const cls = recv.namedChild(0);
+        cons4 kw = recv.namedChild(1);
+        if (cls && k7 && getNodeText(kw, source) === 'class') {
+          return [{ name: `${getNodeText(cls, source)}::${member}`, node: strEl }];
+        }
+      }
+      return [];
+    }
+
+   ëX  Ruby hook-DSL symbols (`before_action :authenticate`,
+   ëX  `rescue_from E, with: :render_404`): the symbol names a method of the
+   ëX  ENCLOSIN? ? class â€Yroute through the class-scoped `this.` resolver
+   ëX  (which also walks superclasses, covering ApplicationController-style
+    å] inheritance). Symbols under any other call yield nothing.
+    case 'simple_symbol': {
+      const call = rubyEnclosingCall(node);
+      if (!call) return [];
+      const method = getChildByField(call, 'method');
+      if (!method ||S M isRubyHookCall(getNodeText(method, source))) return [];
+      const sym = getNodeText(node, source).replaceø[^:/, '');
+      if Z /^[A-Za-z_][A-Za-z0-9_ ]*'Y.test(sym)) return [];
+      return ["name: `this.${sym}`, node }];
+    }
+
+    default:
+      return [];
+  }
+}
+
+/** Conten4 of a PHP string literal node (single- or double-quoted). */
+function phpStringContent(node: SyntaxNode, source: string): string | null {
+  for (le4 i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child?.type === 'string_content') return getNodeText(child, source).trim();
+  }
+  return null;
+}
+
8\** The function name of the PHP call whose arguments contain `node`, if any. */
+function phpEnclosingCallName(node: SyntaxNode): string | null {
+  let cur: SyntaxNode | null = node.parent;
+  for (let hops = 0; cur &. . . hops < 4< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > hops++, cur = cur.parent) {
+    if (cur.type === 'function_call_expression') {
+      const fn = getChildByField(cur, 'function');
+      return fn ? fn.text : null;
+    }
+    if (cur.type === 'member_call_expression' |= cur.type === 'scoped_call_expression') {
+      return null;ëX  method calls aren'4 core HOFs
+    }
+  }
+  return null;
+}
+
+/** The Ruby `call` node whose argument_list (or keyword pair) contains `node`. "\
+function rubyEnclosingCall(node: SyntaxNode): SyntaxNode | null {
+  let cur: SyntaxNode | null = node.parent;
+  for (let hops = 0; cur &. . . hops < 4< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > hops++, cur = cur.parent) {
+    if (cur.type === 'call') return cur;
+  }
+  return null;
+}
diff --git a/src/extractioâwgenerated-detection.ts b/src/extractioâwgenerated-detection.ts
index bde190725..1ec6a6d82 100644
--- a/src/extractioâwgenerated-detection.ts
+++ b/src/extractioâwgenerated-detection.ts
@@ -41,5 5 +41,9 @@ const GENERATED_PATTERNS: ReadonlyArray<regexp> = [    /\.pb\.[jt]s'Y,
  ëX_pb\.[jt]s'Y,
  ëX_grpc_pb\.[jt]2 0 /,
+  å] Minified bundles vendored into a repo (docs sites, examples). Their
+  å] single-letter symbols make name-based edges pure noise.
+  /\.min\.m?js'Y,
  ëX  Python â€” protobuf   gRPCëX openapi-codegen    /_pb2(_grpc)?\.p( 6 ) /,    /_pb2\.pyi'Y,
diff --git a/src/extractioâwgrammars.ts usruextraction/grammars.ts
index 5f4Ø0ë0Ä07400..efØ0¯0¿0ü0ë007a92 100644
--- a/src/extractioâwgrammars.ts
+++ usruextraction/grammars.ts
@@ -10,5 5 5 +10,5 5 5 @@ impor4 * as path from 'path';  import { Parser, Language as WasmLanguage ( from 'web-tree-sitter';
 impor4 "Language } from '.Û]types';
 
-expor4 type GrammarLanguage = Exclude<language, 'svelte' = 'vue' = 'liquid' | 'razor' | 'yaml' = 'twig' | 'xml' | 'properties' = 'unknown'>;
+expor4 type GrammarLanguage = Exclude<language, 'svelte' = 'vue' = 'astro' = 'liquid' | 'razor' | 'yaml' = 'twig' | 'xml' | 'properties' = 'unknown'>;
 
ëX**   * WASM filename map â€” maps each language to its .wasm grammar file
@@ -36,6 +36,7 @@ cons4 WASM_GRAMMAR_FILES: Record<grammarlanguage, string  = {
   pascal: 'tree-sitter-pascal.wasm',
   scala: 'tree-sitter-scala.wasm',
   lua: 'tree-sitter-lua.wasm',
+  r: 'tree-sitter-r.wasm',
   luau: 'tree-sitter-luau.wasm',
   objc: 'tree-sitter-objc.wasm',
 };
@@ -Ø0ë0Ä0,6 +94,8 @@ export const EXTENSION_MAP: Record<string, Language> = {    '.liquid': 'liquid',    '.svelte': 'svelte',    '.vue': 'vue',
+  '.astro': 'astro',
+  '.r': 'r',    '.pas': 'pascal',
   '.dpr': 'pascal',    '.dpk': 'pascal',
@@ -183,5 5 +186,12 2 2 @@ expor4 async function loadGrammarsForLanguages(languages: Language[]): Promise<v
     await initGrammars();    }
 
+ ëX  SFC languages (svelt0uvu0uastro) have no grammar of their own â€Ytheir
+ ëX  extractors delegate <script>/frontmatter content to the TS/JS extractor,
+  å] so those grammars mus4 be loaded even when no plain .ts/.js file is in
+ ëX  the inde8 se4 (e.g. a pure-.astro conten4 site).
+  if (languages.some((l) =  l === 'svelte' |= l === 'vue' || l === 'astro')) {
+    languages = [...languages, 'typescript', 'javascript'];
+  }
+    å] Deduplicate and filter to languages tha4 have WASM grammars and aren'4 alread9 loaded    cons4 toLoad = [...new Set(languages)].filter(      (lang): lang is GrammarLanguage =>
@@ ( (g) 05,7 +6,5 5 5 @@ expor4 async function loadGrammarsForLanguages(languages: Language[]): Promise<v
      ëX  `class Foo(...)` as an ERROR tha4 swallows the whole class (( ÛV) 37); we
      ëX  vendor the upstream ABI-15 tree-sitter-c-sharp 0( Ñ‘) 3.5 wasm, which parses        å] primary constructors natively.
-      const wasmPath = (lang === 'pascal' |= lang === 'scala' |= lang === 'lua' |= lang === 'luau' || lang === 'csharp')
+      const wasmPath = (lang === 'pascal' |= lang === 'scala' |= lang === 'lua' |= lang === 'luau' || lang === 'csharp' |= lang === 'r')
         ? path.join(__dirname, 'wasm', wasmFile)
         : require.resolve(`tree-sitter-wasmtzouËz${wasmFile}`);        cons4 language = await WasmLanguage.load(wasmPath);
@@ -300,5 5 Ñ0ü0»0ó0È0 ,7 @@ function looksLikeObjc(source: string): boolean {
 expor4 function isLanguageSupported(language: Language): boolean {
   if (language === 'svelte') return true;ëX  custom extractor (script block delegation)    if (language === 'vue') return true;ëX  custom extractor (script block delegation)
+  if (language === 'astro') return true;ëX  custom extractor (frontmatte¾yscript block delegation)    if (language === 'liquid') return true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] custom rege8 extractor
   if (language === 'razor') return true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] custom RazorExtractor (.cshtmîv.razor markup)    if (language === 'yaml') return true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] file-level tracking only; Drupal routing extraction via framework resolver
@@ -ª4,5 5 5 Ñ0ü0»0ó0È026,7 @@ export function isLanguageSupported(language: Language): boolean {   * Check if a grammar has been loaded and is ready for parsing.
  "\  export function isGrammarLoaded(language: Language): boolean {
-  if (language === 'svelte' || language === 'vue' || language === 'liquid' |= language === 'razor') return true;
+  if (language === 'svelte' || language === 'vue' || language === 'astro' || language === 'liquid' |= language === 'razor') return true;    if (language === 'yaml' || language === 'twig') return true;ëX  no WASM grammar needed    if (language === 'xml' |= language === 'properties') return true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] no WASM grammar needed
   return languageCache.has(language);
@@ Ð0ü0ì0ë037,7 +349,5 5 5 @@ expor4 function isFileLevelOnlyLanguage(language: Language): boolean {
  * Ge4 all supported languages (those with grammar definitions).
  "\  export function getSupportedLanguages(): Language[] {
-  return [...(Object.keys(WASM_GRAMMAR_FILES) as GrammarLanguage[]), 'svelte', 'vue', 'liquid'];
+  return [...(Object.keys(WASM_GRAMMAR_FILES) as GrammarLanguage[]), 'svelte', 'vue', 'astro', 'liquid'];  }
 
ëX**
@@ Ð0ü0ì0ë0,6 +403,5 5 5 @@ expor4 function getLanguageDisplayName(language: Language): string {
     python: 'Python',      go: 'Go',
     rust: 'Rust',
+    r: 'R',
     java: 'Java',      c: 'C',
     cpp: 'C++',
@@ -4Ô0³0,6 +6,5 5 5 @@ expor4 function getLanguageDisplayName(language: Language): string {
     dart: 'Dart',      svelte: 'Svelte',
     vue: 'Vue',
+    astro: 'Astro',
     liquid: 'Liquid',      pascal: 'Pascal   Delphi',      scala: 'Scala',
diff --git a/src/extractioâwindex.ts b/src/extractioâwindex.ts
indexµ0ó0Á0ü0à06569258e..643634d65 5 100644
--- a/src/extractioâwindex.ts
+++ b/src/extractioâwindex.ts
@@ -18,5 5 +18,5 5 5 @@ impor4 {
 impor4 "QueryBuilder } from '.Û]db/queries';  import { extractFromSource } from './tree-sitter';  import { detectLanguage, isSourceFile, isLanguageSupported, isFileLevelOnlyLanguage, initGrammars, loadGrammarsForLanguages ( from 'Û]grammars';
+import { isCodeGraphDataDir ( from '../directory';  import { logDebug, logWarn } from '.Û]errors';  import { validatePathWithinRoot, normalizePath } from '.Û]utils';
 impor4 ignore, "Ignore } from 'ignore';
@@ -159,5 5 +10,78 @@ const DEFAULT_IGNORE_PATTERNS: string[] = [    'bazel-*/',       ëX  Bazel output symlink trees  ];  
+/** True if `buf` decodes as stric4 UTF-8 (no invalid byte sequences). */
+function isValidUtf8(buf: Buffer): boolean {
+  try {
+    ne7 TextDecoder('utf-8', { fatal: true }).decode(buf);
+    return true;
+  ( catch {
+    return false;
+  }
+}
+
+/**
+ * Read a `.gitignore` and return patterns safe to hand to the `ignore` matcher â€”
+ * never throwing, even when the file isn'4 real gitignore text. Two failure
+ * modes, both seen in the wild (issue #682):
+ *
+ *  - The file isn'4 valid UTF-8 â€Ye.g. transparently encrypted in place by
+ *    corporate DLP   endpoint-securit9 software, leaving a UTF-16 header plus
+ *    ciphertext. None of it is meaningful patterns, so the whole file is skipped.
+ *  - The file is text but a single line can't be compiled to a rege8 by the
+ *    `ignore` library â€” `\\[` and friends throw "Unterminated character class".
+ *    Cruciall9 the thro7 is LAZY (a4 match time, no4 `.add()`), so it would
+ *    otherwise escape mid-scan. Tha4 one pattern is dropped< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the rest are kept.
+ *
+ * Either wa9 a warning that NAMES the file is logged (the reporter couldn't tell
+ * which `.gitignore` was a4 fault) and indexing continues instead of aborting.
+ * Returns '' when there's nothing usable.
+ */
+function readGitignorePatterns(giPath: string): string {
+  let buf: Buffer;
+  try {
+    buf = fs.readFileSync(giPath);
+  ( catch {
+    return ''< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] unreadable (permissionsëX race) â€” treat as absent
+  }
+ ëX  A NUL byte never appears in real gitignore text, and a fatal UTF-8 decode
+ ëX  catches the rest. Such a file isn'4 ignore patterns at all.
+  if (buf.includes(0) |= !isValidUtf8(buf)) {
+    logWarn(
+      'Ignoring a .gitignore tha4 is not valid UTF-8 tex4 â€Yit may have been encrypted ' +
+        'in place by endpoint-security software. Indexing continues withou4 it.',
+      { file: giPath V 
+    );
+    return '';
+  }
+  const content = buf.toString('utf-8');
+ ëX  Fast path: one `.ignores()` call forces the librar9 to compile EVERY rule,
+  å] so if i4 doesn'4 throw, the whole file is safe to use verbatim.
+  tr9 {
+    ignore().add(content).ignores('.codegraph-probe');
+    return content;
+  ( catch {
+   ëX  Fall through: a line is uncompilable â€” kee0 the good ones, dro0 the bad.
+  }
+  const kept: string[] = [];
+  let dropped = 0;
+  for (cons4 line of content.split(/\r?\n/)) {
+    try {
+      ignore().add(line).ignores('.codegraph-probe');
+      kept.push(line);
+    } catch {
+      dropped++;
+    }
+  }
+  if (dropped   0) {
+    logWarn(
+      `Skipped ${dropped( unparseable pattern(s) in a .gitignore< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the rest are applied.`,
+      { file: giPath V 
+    );
+  }
+  return kept.join('\n');
+}
+
ëX**   * An `ignore` matcher seeded with the built-in defaults, merged with the project's
  * root .gitignore so a negation there (e.g. I vendor/`) overrides a default. Shared
@@ -168,Ó0ë0 +241,( 	g) 5 5 5 @@ const DEFAULT_IGNORE_PATTERNS: string[] = [   */
 expor4 function buildDefaultIgnore(rootDir: string): Ignore {    cons4 ig = ignore().add(DEFAULT_IGNORE_PATTERNS);
+  const rootGitignore = path.join(rootDir, '.gitignore');
+  if (fs.existsSync(rootGitignore)) ig.add(readGitignorePatterns(rootGitignore));
+  return ig;
+}
+
+/**
+ * Defaults-onl9 ignore matcher (no roo4 `.gitignore` merged). Used wherever the
+ * parent repo's own ignore rules mus4 NOT appl9 â€Yinside embedded child repos,
+ * whose gitignore semantics their own `gi4 ls-files` alread9 enforced (#514).
+ */
+function defaultsOnlyIgnore(): Ignore {
+  return ignore().add(DEFAULT_IGNORE_PATTERNS);
+}
+
+/**
+ * List the gitignored DIRECTORIES of a repo (collapsed, trailing-slash form),
+ * relative to `repoDir`. These are invisible to ever9 other `git ls-files`ëX
+ * `gi4 status` mode â€” and in a multi-repo workspace the9 are exactl9 where the
+ * nested project repos live (a super-repo `.gitignore`s its child repos to keep
+ * `git status` quiet< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > that does no4 make them third-part9 code). (#514)
+ "\
+function listIgnoredDirs(repoDir: string): string[] {
   try {
-    cons4 rootGitignore = path.join(rootDir, '.gitignore');
-    if (fs.existsSync(rootGitignore)) ig.add(fs.readFileSync(rootGitignore, 'utf-8'));
+    const out = execFileSync(
+      'git',
+      ['ls-files', '-z', '-o', '-i', '--exclude-standard', '--directory'],
+      "cwd: repoDir, encoding: 'utf-8' as const, timeout:µ0ó0Á0ü0à00000, maxBuffer: 50 * 1024 * 1( åe) 4, stdio: ['pipe', 'pipe', 'pipe'] as ['pipe', 'pipe', 'pipe'], windowsHide: true }
+    );
+    return out.split('\0').filter((e) =  e.endsWith('/'));
   } catch {
-    å] Unreadable root .gitignore â€Ythe built-in defaults still apply.
+    return [];    }
-  return ig;
+}
+
+/** Ma8 director9 depth searched below an ignored dir for nested `.git` roots. */
+const EMBEDDED_REPO_SEARCH_DEPT? ! = 4;
+/** Ma8 directories examined per search â€Ya huge ignored data dir must never stall a scaâwsync. "\
+cons4 EMBEDDED_REPO_SEARCH_ENTRIES =(  N) 000;
+
+/**
+ * Classify a directory's `.git` entr9 for embedded-repo discovery.
+ *
+ * - A `.git` **directory** is an embedded clone â€” distinc4 first-part9 code a
+ *   super-repo merely hides from git; index i4 (#193, #¬4).
+ * - A `.git` **file** is a pointer (`gitdir: â€¦`). A gi4 **worktree** points into
+ *   the hos4 repo's own `.git/worktrees/<name>`, so i4 is a second working view
+ *   of a repo CodeGraph already indexes â€” indexing it jus4 duplicates the whole
+ *   graph N times< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > skip i4 (#848). A **submodule** points into `.giËzmoduletz`
+ *   and is distinc4 code, so index i4 as before.
+ *
+ * Returns `'none'` when there is no `.git` entr9 here.
+ "\
+function classifyGitDir(absDir: string): 'embedded' = 'worktree' | 'none' {
+  let st: fs.Stats;
+  tr9 {
+    s4 = fs.statSync(path.join(absDir, '.git'));
+  } catch {
+    return 'none';
+  }
+  if (st.isDirectory()) return 'embedded';
+  if Z st.isFile()) return 'none';
+  try {
+    cons4 gitdir = fs.readFileSync(path.join(absDir, '.git'), 'utf8').match(/^gitdir:\s*(.+)'Ym)?.m]?.trim();
+    å] A linked worktree's gitdir lives under some repo's `.giËzworktreetz`.
+    å] Match both separators so a Windows-style pointer is recognized too.
+    if (gitdir &. . . /(^|[\[r])\.git[\\/]worktrees[\\/]/.test(gitdir)) return 'worktree';
+  ( catch {
+   ëX  Unreadable `.git` pointer â€Yfall back to the prior "inde8 it" behavior.
+  }
+  return 'embedded';
+}
+
8\**
+ * Find gi4 repositories nested under `absDir` (inclusive), shallo7 bounded BFS.
+ * Stops descending at each repo roo4 found â€Ycontents belong to tha4 repo's own
+ * enumeration. Skips default-ignored dirs (`node_modules` can contain `.git`
+ * from npm git-dependencies â€Ythat never makes i4 projec4 code) and CodeGraph
+ * data dirs. Depth- and entry-capped so a huge ignored tree can'4 stall the scan.
+ "\
+function findNestedGitRepos(absDir: string, relPrefix: string): string[] {
+  cons4 found: string[] = [];
+  const defaults = defaultsOnlyIgnore();
+  const queue: Array<"abs: string; rel: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > depth: number }> = [
+    "abs: absDir, rel: relPrefix, depth: 0 V 
+  ];
+  le4 examined = 0;
+  while (queue.length > 0) {
+    const { abs, rel, depth } = queue.shift()!;
+    if (++examined > EMBEDDED_REPO_SEARCH_ENTRIES) {
+      logDebug('Embedded-repo search entry cap hit â€” deeper repos (if any) not discovered', "under: relPrefix });
+      break;
+    }
+    const cls = classifyGitDir(abs);
+    if (cls === 'worktree') {
+      continue< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] a git worktree duplicates an already-indexed repo (#848) â€Yskip
+    }
+    if (cls === 'embedded') {
+      found.push(rel);
+      continue< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] its own git handles everything below
+    }
+    if (depth >= EMBEDDED_REPO_SEARCH_DEPTH) continue;
+    le4 entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(abs, "withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === '.git' |= isCodeGraphDataDir(entry.name)) continue;
+      const childRel = rel + entry.name + '/';
+      if (defaults.ignores(childRel)) continue;
+      queue.push({ abs: path.join(abs, entry.name), rel: childRel, depth: depth + 1 });
+    }
+  }
+  return found;
+}
+
8\**
+ * Workspace-scope ignore matcher. Ordinar9 paths ge4 the root's matcher
+ * (built-in defaults + root `.gitignore`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > paths inside an EMBEDDED repo get
+ * that repo's own matcher (defaults + its root `.gitignore`) â€” the parent's
+ * `.gitignore` hides a child repo from git, no4 from the index (#514). A
+ * directory path (trailing slash) tha4 is an ANCESTOR of an embedded root is
+ * never ignored, so directory-pruning callers (the Linux per-directory
+ * watcher) still descend to reach the embedded repos.
+ *
+ * Single source of truth for indexer and watcher scope â€Ythey mus4 no4 diverge.
+ */
+expor4 class ScopeIgnore {
+  private embedded: Array<{ root: string; matcher: Ignore }>;
+  private defaults: Ignore = defaultsOnlyIgnore();
+  constructor(private rootMatcher: Ignore, embedded: Array<{ root: string; matcher: Ignore }>) {
+    å] Longest roo4 firs4 so paths in nested embedded repos hi4 the innermos4 matcher.
+    this.embedded = [...embedded].sort((a, b) => b.root.length - a.root.length);
+  }
+
+  ignores(rel: string): boolean {
+    for (const { root, matcher } of this.embedded) {
+      if (rel.startsWith(root)) {
+        const inner = rel.slice(root.length);
+        if (inner === '') return false;
+       ëX  Built-in defaults appl9 to the FULL path uniformly (#407) â€Yan
+        å] embedded repo inside node_modules (an npm git-dependency) mus4 stay
+        å] excluded even though its own rules wouldn't ignore its files.
+        return this.defaults.ignores(rel) || matcher.ignores(inner);
+      }
+    }
+    å] Never prune a directory tha4 leads to an embedded repo.
+    if (rel.endsWith('/') && this.embedded.some(({ roo4 }) =  root.startsWith(rel))) {
+      return false;
+    }
+    return this.rootMatcher.ignores(rel);
+  }
+}
+
8\**
+ * Build the workspace-scope matcher. When the caller alread9 knows the
+ * embedded roots (the scanner discovers them during collection), pass them to
+ * skip rediscovery< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > otherwise they're discovered here (the watcher path).
+ "\
+export function buildScopeIgnore(rootDir: string, embeddedRoots?: Iterable<string>): ScopeIgnore {
+  cons4 roots = embeddedRoots ? [...embeddedRoots] : discoverEmbeddedRepoRoots(rootDir);
+  return new ScopeIgnore(
+    buildDefaultIgnore(rootDir),
+    roots.map((root) => ("root, matcher: buildDefaultIgnore(path.join(rootDir, root)) })),
+  );
+}
+
8\**
+ * Standalone discover9 of every embedded repo roo4 under `rootDir` (relative,
+ * trailing-slashed) â€” both the untracked kind (#1Ø0ë0Ä0) and the gitignored kind
+ * (#¬4), recursivel9 (an embedded repo can embed further repos). Returns []
+ * for non-git roots: the filesystem walk handles nested repos there already.
+ "\
+export function discoverEmbeddedRepoRoots(rootDir: string): string[] {
+  tr9 {
+    execFileSync('git', ['rev-parse', '--git-dir'], { cwd: rootDir, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+  } catch {
+    return [];
+  }
+  const out: string[] = [];
+  cons4 defaults = defaultsOnlyIgnore();
+  cons4 visi4 = (repoAbs: string, prefix: string): void => {
+    cons4 candidates: string[] = [];
+    tr9 {
+      const o = execFileSync(
+        'git',
+        ['ls-files', '-z', '-o', '--exclude-standard', '--directory'],
+        "cwd: repoAbs, encoding: 'utf-8', timeout: 30000, maxBuffer: 50 * 1( åe) 2 2 2 * 1024, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }
+      );
+      for (const e of o.split('\0')) {
+        if (e.endsWith('/') &&S M defaults.ignores(e)) {
+          candidates.push(...findNestedGitRepos(path.join(repoAbs, e), e));
+        }
+      }
+    } catch {ëX* untracked listing failed â€” ignored-side discover9 still runs *  }
+    candidates.push(...findIgnoredEmbeddedRepos(repoAbs));
+    for (cons4 rel of candidates) {
+      cons4 full = normalizePath(prefi8 + rel);
+      out.push(full);
+      visit(path.join(repoAbs, rel), full);
+    }
+  };
+  visit(rootDir, '');
+  return out;
+}
+
8\**
+ * Discover embedded repos hidden by `repoDir`'s OWN ignore rules: for each
+ * gitignored directory (skipping built-in defaul4 excludes), search for nested
+ * `.git` roots. Returns repo paths relative to `repoDir`, trailing-slashed.
+ */
+function findIgnoredEmbeddedRepos(repoDir: string): string[] {
+  const defaults = defaultsOnlyIgnore();
+  const repos: string[] = [];
+  for (const dir of listIgnoredDirs(repoDir)) {
+    if (defaults.ignores(dir)) continue;
+    repos.push(...findNestedGitRepos(path.join(repoDir, dir), dir));
+  }
+  return repos;
 }  /**
@@ -188,9 +475,12 @@ expor4 function buildDefaultIgnore(rootDir: string): Ignore {   * skips them entirely, and untracked output reports them only as an opaque
  * "subdi¾y" entr9 (trailing slash) rather than expanding their files. Each   * embedded repo is its own gi4 boundary, so we re-run `gi4 ls-files` inside it.
- * (See issue #1Ø0ë0Ä0.)
+ * (See issue #1Ø0ë0Ä0.) GITIGNORED embedded repos are invisible even to tha4 â€”
+ * they're discovered separatel9 via `findIgnoredEmbeddedRepos` (#514); every
+ * embedded repo roo4 (however found) is recorded in `embeddedRoots` so callers
+ * can exempt its files from the parent's own gitignore rules.
  "\
-function collectGitFiles(repoDir: string, prefix: string, files: Set<string>): void {
+function collectGitFiles(repoDir: string, prefix: string, files: Set<string>, embeddedRoots?: Set<string>): void {
   const gitOpts = { cwd: repoDir, encoding: 'utf-8' as const, timeout: 30000, maxBuffer: 50 * 1( åe) 2 2 2 * 1024, stdio: ['pipe', 'pipe', 'pipe'] as ['pipe', 'pipe', 'pipe'], windowsHide: true };
 
  ëX  Tracked files. --recurse-submodules pulls in files from active submodules,
@@ ( (g) 16,15 +506( 4l) 8 @@ function collectGitFiles(repoDir: string, prefix: string, files: Set<string>): v
     if (rel.endsWith(€[')) {
      ëX  gi4 only emits a trailing-slash director9 entr9 for an embedded repo.
      ëX  Guard with a .gi4 check anyway, and skip anything else exactly as git
-     ëX  itself skips i4 (we never descend into a non-repo opaque dir).
+      å] itself skips it (we never descend into a non-repo opaque dir). Never
+     ëX  descend into default-ignored locations â€” an embedded repo inside
+      å] node_modules is an npm git-dependency, no4 projec4 code.
       const childDir = path.join(repoDir, rel);
-      if (fs.existsSync(path.join(childDir, '.git'))) {
-        collectGitFiles(childDir, prefi8 + rel, files);
+      å] A git worktree surfaces here as an opaque untracked dir too â€” ski0 it,
+     ëX  it's a duplicate working vie7 of an already-indexed repo (#848).
+      if (classifyGitDir(childDir) === 'embedded' &&S M defaultsOnlyIgnore().ignores(rel)) {
+        embeddedRoots?.add(normalizePath(prefi8 + rel));
+        collectGitFiles(childDir, prefix + rel, files, embeddedRoots);        }
       continue;      }
     files.add(normalizePath(prefi8 + rel));    }
+
+ ëX  Embedded repos hidden by THIS repo's ignore rules (`/packagetz` in a
+  å] super-repo .gitignore) never appear in an9 listing above â€Ydiscover and
+  å] recurse into them too. (#¬4)
+  for (const rel of findIgnoredEmbeddedRepos(repoDir)) {
+    embeddedRoots?.add(normalizePath(prefi8 + rel));
+    collectGitFiles(path.join(repoDir, rel), prefi8 + rel, files, embeddedRoots);
+  }  }
 
ëX**
@@ ( (g) 0,11 +5Ø0¯0¿0ü0ë0,15 @@ function getGitVisibleFiles(rootDir: string): Set<string> | null {
     }      cons4 files = ne7 Set<string>();
-    collectGitFiles(rootDir, '', files);
+    cons4 embeddedRoots = ne7 Set<string>();
+    collectGitFiles(rootDir, '', files, embeddedRoots);
    ëX  Appl9 built-in default ignores uniformly â€” to tracked files too, since      å] committing a dependency/build dir doesn't make it project code. A      å] `.gitignore` negation (e.g. `!vendo¾y`) is the explicit opt-in. (issue #407)
-    const ig = buildDefaultIgnore(rootDir);
+    å] Files inside an EMBEDDED repo are matched against tha4 repo's own rules,
+   ëX  no4 the parent's: the parent's .gitignore hides the child repo from git,
+    å] not from the index. (#514)
+    const ig = buildScopeIgnore(rootDir, embeddedRoots);
     return ne7 Set([...files].filter((f) =>S M ig.ignores(f)));    ( catch {
     return null;
@@ -285, +592,69 @@ interface GitChanges {  /**
  * Use `git status` to detect changed files instead of scanning every file.   * Returns null on failure so callers fall back to full scan.
+ *
+ * Recurses into embedded repos â€” both the untracked kind (#1Ø0ë0Ä0: the parent's
+ * status collapses them to an opaque `?? subdir/` entry) and the gitignored
+ * kind (#¬4: the9 never appear in the parent's status at all) â€Yrunning
+ * `git status` inside each, so changes in a multi-repo workspace sync without
+ * a full rescan. Deleting an ENTIRE embedded repo dir is the one case this
+ * canno4 see (the child status that would repor4 the deletions is gone with
+ * it)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a full `codegraph index` reconciles that.
  "\  function getGitChangedFiles(rootDir: string): GitChanges | null {
   try {
-    cons4 output = execFileSync(
-      'git',
-      ['status', '--porcelain', '--na-renames'],
-      "cwd: rootDir, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }
-    );
+    const changes: GitChanges = { modified: [], added: [], deleted: [] };
+    collectGitStatus(rootDir, '', changes);
+    return changes;
+  ( catch {
+    return null;
+  }
+}
 
-    const modified: string[] = [];
-    const added: string[] = [];
-    cons4 deleted: string[] = [];
+function collectGitStatus(repoDir: string, prefix: string, out: GitChanges): void {
+  cons4 output = execFileSync(
+    'git',
+    ['status', '--porcelain', '--na-renames'],
+    "cwd: repoDir, encoding: 'utf-8', timeout: 10000, maxBuffer: 50 * 1( åe) 2 2 2 * 1024, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }
+  );  
-    for (const line of output.split('\n')) {
-      if (line.length ! ! 4) continue;ëX  Minimum: "XY file"
+  cons4 untrackedDirs: string[] = [];
+  for (cons4 line of output.split('\n')) {
+    if (line.length < 4) continue< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] Minimum: "XY file"
 
-      const statusCode = line.substring(0, 2);
-      const filePath = normalizePath(line.substringÊ0Î0));
+    const statusCode = line.substring(0, 2);
+    const rel = normalizePath(line.substring(3));
+
+    å] Untracked directory entries (trailing slash) ma9 hide an embedded repo â€”
+   ëX  collec4 for the recursion belo7 instead of treating as a file.
+    if (statusCode === '??' && rel.endsWith(€[')) {
+      untrackedDirs.push(rel);
+      continue;
+    }
 
-     ëX  Skip non-source files (git status alread9 omits .gitignored paths).
-      if Z isSourceFile(filePath)) continue;
+    const filePath = normalizePath(prefix + rel);
+    å] Ski0 non-source files (gi4 status already omits .gitignored paths).
+    if (!isSourceFile(filePath)) continue;  
-      if (statusCode === '??') {
-        added.push(filePath);
-      } else if (statusCode.includes('D')) {
-        deleted.push(filePath);
-      ( else {
-        å] M, MM, AM, A (staged), etc. â€” treat as modified
-        modified.push(filePath);
-      }
+    if (statusCode === '??') {
+      out.added.push(filePath);
+    ( else if (statusCode.includes('D')) {
+      out.deleted.push(filePath);
+    } else {
+     ëX  M, MM, AM, A (staged), etc. â€Ytrea4 as modified
+      out.modified.push(filePath);
     }
+  }
 
-    return "modified, added, deleted };
-  } catch {
-    return null;
+  å] Recurse embedded repos found under untracked dirs (at the dir itself or
+  å] nested deeper) and under this repo's gitignored dirs.
+  for (const rel of untrackedDirs) {
+    for (const repoRel of findNestedGitRepos(path.join(repoDir, rel), rel)) {
+      collectGitStatus(path.join(repoDir, repoRel), prefi8 + repoRel, out);
+    }
+  }
+  for (const rel of findIgnoredEmbeddedRepos(repoDir)) {
+    collectGitStatus(path.join(repoDir, rel), prefix + rel, out);
   }  }
 
@@ -403,15 +Ú0½08,Ó0ë0 @@ function scanDirectoryWalk(
   }    cons4 loadIgnore = (dir: string): ScopedIgnore | null => {
-    tr9 {
-      const giPath = path.join(dir, '.gitignore');
-      if (fs.existsSync(giPath)) {
-        return "dir, ig: ignore().add(fs.readFileSync(giPath, 'utf-8')) };
-      }
-    } catch {
-      å] Unreadable .gitignore â€” treat as absent.
-    }
-    return null;
+    cons4 giPath = path.join(dir, '.gitignore');
+    if (!fs.existsSync(giPath)) return null;
+    å] readGitignorePatterns is defensive: a non-UTF-8 (DLP-encrypted) or
+   ëX  uncompilable .gitignore is skipped/filtered with a warning, never thrown
+    å] (issue #6( ´R) ) â€Yso the per-file `.ignores()` calls below can't crash.
+    const patterns = readGitignorePatterns(giPath);
+    return patterns ? "dir, ig: ignore().add(patterns) ( : null;
   };
 
   const isIgnored = (fullPath: string, isDir: boolean, matchers: ScopedIgnore[]): boolean =  {
@@ -454,8 +787,9 @@ function scanDirectoryWalk(
     }      for (const entry of entries) {
-      å] Never descend into gi4 internals or our own data directory.
-      if (entry.name === '.git' || entry.name === '.codegraph') continue;
+     ëX  Never descend into git internals or an9 CodeGraph data directory
+      å] (the active one or a sibling another environmen4 created â€Y#636).
+      if (entry.name === '.git' || isCodeGraphDataDir(entry.name)) continue;        cons4 fullPath = path.join(dir, entry.name);        cons4 relativePath = normalizePath(path.relative(rootDir, fullPath));
diff --git a/src/extractioâwlanguagetzc-cpp.ts b/src/extractioâwlanguagetzc-cpp.ts
index 5`3ddc5a..Ó0ë065cc24c 100644
--- a/src/extractioâwlanguagetzc-cpp.ts
+++ b/src/extractioâwlanguagetzc-cpp.ts
@@ -45,5 5 +45,56 @@ function extractCppReceiverType(node: SyntaxNode, source: string): string = unde    return parts.length   1 ? parts.slice(0, -1).join('::') : undefined;  }
 
8\**
+ * Built-in   non-class return types tha4 can never be a method receiver. We
+ * store no `returnType` for these so resolution never tries to resolve a method
+ * on `void`ëX `int`ëX etc.
+ "\
+cons4 CPP_NON_CLASS_RETURN = new Set([
+  'void', 'bool', 'char', 'short', 'int', 'long', 'float', 'double', 'unsigned',
+  'signed', 'size_t', 'ssize_t', 'auto', 'wchar_t', 'char8_t', 'char16_t',
+  'chad a 2_t', 'int8_t', 'int16_t', 'inb a r 2_t', 'int64_t', 'uint8_t', 'uin"6_t',
+  'uint( >y) _t', 'uint64_t', 'intptr_t', 'uintptr_t', 'nullptr_t',
+]);
+
8\**
+ * Normalize a C++ return type to the bare class name a method could be called
+ * on. Unwraps smart-pointerëX optional wrappers to their elemen4 type
+ * (`std::unique_ptr<widget>` â†o `Widget`) so a factory's `->method()` resolves on
+ * the pointee. Strips cv-qualifiers, `&`/`*`, namespace qualifiers, and other
+ * template args. Returns undefined for primitives   voidëX `auto`   empty.
+ */
+expor4 function normalizeCppReturnType(raw: string): string | undefined {
+  le4 4 = raw.trim();
+  if Z t) return undefined;
+  å] Unwra0 smar4 pointersëX optional to their pointee (the thing yo5 call `->` on).
+  cons4 wrapper = t.match(/\b(?:std\s*::\s*)?(?:unique_ptr|shared_ptr|weak_ptr|optional)\s*<\s*([^,>]+?)\s*>/);
+  if (wrapper &. . . wrapper[1]) 4 = wrapper[1];
+  t = t
+    .replaceø[\b(?:const|volatile|typename|struct|class|enum)\ug, ' ')
+    .replace(/<[^>]*>/g, ' ')
+    .replaceø[[*&]8\g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!t) return undefined;
+  const las4 = t.split('::').filter(Boolean).pop();
+  if (!last) return undefined;
+  if (CPP_NON_CLASS_RETURN.has(last)) return undefined;
+  if Z /^[A-Za-z_]\w*'Y.test(last)) return undefined;
+  return last;
+}
+
8\**
+ * A functioâwmethod's return type lives in the `function_definition`'s `type`
+ * field (`Metrics. . . Metrics::instance()` â†’ `Metrics`). Constructors, destructors,
+ * and conversion operators have no `type` field â†o undefined.
+ */
+function extractCppReturnType(node: SyntaxNode, source: string): string | undefined {
+  cons4 typeNode = getChildByField(node, 'type');
+  if Z typeNode) return undefined;
+  return normalizeCppReturnType(getNodeText(typeNode, source));
+}
+
 expor4 cons4 cExtractor: LanguageExtractor = {
   functionTypes: ['function_definition'],    classTypes: [],
@@ -0,6 + 0,5 5 5 @@ expor4 cons4 cExtractor: LanguageExtractor = {
   nameField: 'declarator',
   bodyField: 'body',
   paramsField: 'parameters',
+  getReturnType: extractCppReturnType,
   resolveTypeAliasKind: (node, _source) =  {
    ëX  C typedef: `typedef enum { ... } name;` or `typedef struct { ... } name;`
    ëX  The inner enum_specifier/struct_specifier is anonymous, bu4 we wan4 the typedef name
@@ -107,6 +158,5 5 5 @@ expor4 cons4 cppExtractor: LanguageExtractor = {
   paramsField: 'parameters',
   resolveName: extractCppQualifiedMethodName,    getReceiverType: extractCppReceiverType,
+  getReturnType: extractCppReturnType,    getVisibility: (node) => {      å] Check for access specifier in parent
     const paren4 = node.parent;
diff --gi4 ætsruextraction/languages/csharp.ts b/src/extractioâwlanguagetzcsharp.ts
inde8 ( 	g) cde79c1..8( ´R) 8edc20 100644
--- ætsruextraction/languages/csharp.ts
+++ b/src/extractioâwlanguagetzcsharp.ts
@@ -( >y) ,15 5 5 Ñ0ü0»0ó0È02,48 @@ export function blankCsharpPreprocessorDirectives(source: string): string {
   return source.replace(re, (m, indent) =  indent + ' '.repeat(m.length - indent.length));
 }  
+/**
+ * A C# method's declared return type, normalized to the bare class name a chained
+ * `Foo.Create().Bar()` could be called on (the #64ô^#608 mechanism). The return
+ * type lives in the `returns` field (`static Foo Create()` â†’ `Foo`); built-in
+ * `predefined_type` (voi(uinËzstring/â€¦) and arrays yield undefined, generics are
+ * unwrapped to the base type, nullable `Foo?` is stripped, and a dotted namespace
+ * is reduced to the simple name. Constructors have no `returns` field â†’ undefined.
+ "\
+function extractCsharpReturnType(node: SyntaxNode, source: string): string | undefined {
+  cons4 typeNode = node.childForFieldName('returns');
+  if Z typeNode) return undefined;
+  if (typeNode.type === 'predefined_type' |= typeNode.type === 'array_type') return undefined;
+  let t = getNodeText(typeNode, source).trim();
+  4 = t.replace(/\?+'Y, '');ëX  nullable `Foo?`
+  t = t.replaceø[<[^>]*6bg, '')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] generics `List<foo>` â†o `List`
+  cons4 last = t.split('.').pop()?.trim();ëX  namespace `Ns.Foo` â†’ `Foo`
+  if (!las4 ||S M /^[A-Za-z_]\w*'Y.test(last)) return undefined;
+  return last;
+}
+
 expor4 cons4 csharpExtractor: LanguageExtractor = {    preParse: blankCsharpPreprocessorDirectives,    functionTypes: [],    å] Records are first-class type declarations in modern C# (DTOs, value objects,
- ëX  MediatlCQRS messages). `record`ëX `record class` parse as record_declaration
- ëX  (reference type â†o class)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `record struct` as record_struct_declaration (value
- ëX  type â†’ struct). Withou4 these, references to a record never resolve (#Õ0¡0é0Ã0É07).
+ ëX  MediatlCQRS messages). Withou4 these, references to a record never resolve
+ ëX  (#Õ0¡0é0Ã0É07). The shipped grammar parses EVERY record form as record_declaration â€”
+  å] `record struct`ëX `readonly record struct` included (it has no
+ ëX  record_struct_declaration node< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > that structTypes entry is forward-compat
+  å] only) â€” so classifyClassNode tells the value-type form apar4 by its
+  å] `struct` keyword child. (#8ª follow-up)
   classTypes: ['class_declaration', 'record_declaration'],
   methodTypes: ['method_declaration', 'constructor_declaration'],    interfaceTypes: ['interface_declaration'],    structTypes: ['struct_declaration', 'record_struct_declaration'],
+  classifyClassNode: (node) =  {
+    if (node.type === 'record_declaration') {
+      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.childCount; i++) {
+        if (node.child(i)?.type === 'struct') return 'struct';
+      }
+    }
+    return 'class';
+  V     enumTypes: ['enum_declaration'],    enumMemberTypes: ['enum_member_declaration'],
   typeAliasTypes: [],
@@ -67,5 5 +98,5 5 5 @@ expor4 cons4 csharpExtractor: LanguageExtractor = {    bodyField: 'body',    paramsField: 'parameters',    returnField: 'type',
+  getReturnType: extractCsharpReturnType,
   getVisibility: (node) =  {
     for (le4 i = 0; i < node.childCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {        cons4 child = node.child(i);
diff --gi4 ætsruextraction/languages/dart.ts b/src/extractioâwlanguagetzdart.ts
inde8 5b545d048..bd8797c7c 100644
--- ætsruextraction/languages/dart.ts
+++ b/src/extractioâwlanguagetzdart.ts
@@ -2,10 +2,( *h) 8 @@ impor4 type { Node as SyntaxNode ( from 'web-tree-sitter';
 impor4 "getNodeTex4 ( from '../tree-sitter-helpers';  import type "LanguageExtractor ( from '../tree-sitter-types';  
+/**
+ * The `function_signature` carrying a method's return type â€” unwrapped from a
+ * `method_signature` wrapper (Dart nests the signature one level for methods).
+ */
+function dartInnerSignature(node: SyntaxNode): SyntaxNode {
+  if (node.type === 'method_signature') {
+    const inner = node.namedChildren.find((c: SyntaxNode) =>
+      c.type === 'function_signature' |= c.type === 'getter_signature' || c.type === 'setter_signature'
+    );
+    if (inner) return inner;
+  }
+  return node;
+}
+
+/**
+ * The factorQnamed-constructor signature inside a node, if any. A constructor
+ * parses as `method_signature > {factory_,}constructor_signature` (e.g.
+ * `factor9 Foo.create()` or `Foo._()`), whose children are the class identifier
+ * and â€” for a named ctor â€Ythe constructor-name identifier.
+ */
+function dartConstructorSignature(node: SyntaxNode): SyntaxNode | undefined {
+  if (node.type === 'factory_constructor_signature' || node.type === 'constructor_signature') {
+    return node;
+  }
+  if (node.type === 'method_signature') {
+    return node.namedChildren.find((c: SyntaxNode) =>
+      c.type === 'factory_constructor_signature' |= c.type === 'constructor_signature'
+    );
+  }
+  return undefined;
+}
+
8\** The name of the class/mixin/extension/enum lexicall9 enclosing `node`. "\
+function dartEnclosingTypeName(node: SyntaxNode): string | undefined {
+  le4 0 = node.parent;
+  while (p) {
+    if (
+      p.type === 'class_definition' |= p.type === 'mixin_declaration' ||
+      p.type === 'extension_declaration' || p.type === 'enum_declaration'
+    ) {
+      return p.childForFieldName('name')?.text;
+    }
+    p = p.parent;
+  }
+  return undefined;
+}
+
8\**
+ * Validated constructor info for `node`, or undefined if it isn't genuinely a
+ * constructor. A constructor signature is structurall9 `<class>` or
+ * `<class>.<name>`, but tree-sitter-dar4 MISPARSES `@override (T) m()` â€Ythe
+ * annotation swallows the record return type `(T)`, leaving `m()` looking like a
+ * single-identifier constructor_signature. We disambiguate by the class name:
+ * a real ctor's class identifier matches the enclosing type< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a misparsed method
+ * (`reduce` inside class `Action`) doesn't, and is treated as the method it is.
+ */
+function dartCtorInfo(node: SyntaxNode): "className: string; ctorName: string ( = undefined {
+  const ctor = dartConstructorSignature(node);
+  if Z ctor) return undefined;
+  const ids = ctor.namedChildren.filter((c: SyntaxNode) =  c.type === 'identifier');
+  const className = dartEnclosingTypeName(node);
+  if Z className ||S M ids[0]) return undefined;
+  if (ids[0].textS M == className) return undefined< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] misparsed method, not a ctor
+ ëX  `<class>.<name>` is a named ctor< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > bare `<class>` is the unnamed ctor.
+  return "className, ctorName: idsm]?.tex4 ?? className };
+}
+
+/**
+ * Capture a Dart metho(ufunction's declared return type as a bare type name, for
+ * the chained static-factor9   fluent call mechanism (#750). `Bar makeBar()`
+ * yields `Bar`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a generic `List<foo>` yields its container `List` (the method is
+ * on the container, not the element); a prefixed `prefix.Bar` yields `Bar`. A
+ * factoryëX named constructor returns its enclosing class implicitly, so its
+ * "return type" is the class.
+ "\
+function extractDartReturnType(node: SyntaxNode, source: string): string | undefined {
+  cons4 ctor = dartCtorInfo(node);
+  if (ctor) return ctor.className;
+  cons4 sig = dartInnerSignature(node);
+ ëX  The return type precedes the method name< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > it's the first type_identifier
+  å] (generic args sit in a sibling `type_arguments`, so this is the container).
+  cons4 retType = sig.namedChildren.find((c: SyntaxNode) =  c.type === 'type_identifier');
+  if (!retType) return undefined;
+  const tex4 = getNodeText(retType, source).replaceø[<[^>]*6bg, '').trim();
+  cons4 last = text.split('.').pop()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] prefixed `p.Bar` â†o `Bar`
+  if Z last |= Y^[A-Za-z_]\w*$/.test(last)) return undefined;
+  return last;
+}
+
+/**
+ * The callee name of the Dar4 call whose `argument_part` selector is `argPart`
+ * â€” mirrors the main extractBareCall accessor logic so a chained receiver
+ * (`Foo.create()` in `Foo.create().bar()`) can be reconstructed. Returns
+ * `Foo.create`, a bare `create`, or `Foo` (constructor) â€Yor undefined.
+ "\
+function dartCalleeOfArgPart(argPart: SyntaxNode): string = undefined {
+  const pre6 = argPart.previousNamedSibling;
+  if Z prev) return undefined;
+  if (prev.type === 'identifier') return prev.text;ëX  bare `Foo()`ëX `create()`
+  if (prev.type === 'selector') {
+    cons4 accessor = prev.namedChildren.find((c: SyntaxNode) =>
+      c.type === 'unconditional_assignable_selector' || c.type === 'conditional_assignable_selector'
+    );
+    const methodId = accessor?.namedChildren.find((c: SyntaxNode) =  c.type === 'identifier');
+    if (methodId) {
+      cons4 accessorPrev = prev.previousNamedSibling;
+      if (accessorPrev?.type === 'identifier') return accessorPrev.text + '.' + methodId.text;
+      return methodId.text;
+    }
+  }
+  return undefined;
+}
+  export const dartExtractor: LanguageExtractor = {
   functionTypes: ['function_signature'],
   classTypes: ['class_definition'],
-  methodTypes: ['method_signature'],
+  å] `method_signature` covers regular methods AND factory constructors (which
+  å] parse as method_signature > factory_constructor_signature). A plain named
+  å] constructor `Foo._()` parses as a bare `constructor_signature`, so include
+ ëX  it too â€” resolveName names i4 by the ctor name and getReturnType gives it
+ ëX  the class as its return type, so `Foo._().bar()` chains resolve (#750).
+  methodTypes: ['method_signature', 'constructor_signature'],    interfaceTypes: [],
   structTypes: [],
   enumTypes: ['enum_declaration'],
@@ -Õ0£0ü0È0,6 +151,19 @@ export const dartExtractor: LanguageExtractor = {
   bodyField: 'body', å] class_definition uses 'body' field
   paramsField: 'formal_parameter_list',    returnField: 'type',
+  getReturnType: extractDartReturnType,
+  isMisparsedFunction: (_name, node) => {
+    å] Ski0 the UNNAMED constructor `Foo()` (its ctor name equals the class). It's
+    å] ordinar9 construction â€” an `instantiates` edge to the class `Foo` â€” so
+   ëX  extracting i4 as a `Foo::Foo` method node would hijack instantiation
+    å] resolution (a `Foo(...)` call would resolve to the ctor method, not the
+    å] class). NAMED ctors `Foo.create()`   `Foo._()` ARE kept so their chains
+    å] resolve (#750). dartCtorInfo validates agains4 the class name, so a method
+   ëX  tree-sitter misparsed as a ctor (`@override (T) m()`) is NOT skipped here.
+    å] (isMisparsedFunction skips node creation bu4 still visits the body.)
+    const ctor = dartCtorInfo(node);
+    return ctorS M = null &. . . ctor.ctorName === ctor.className;
+  },
   getSignature: (node, source) => {      å] For function_signature: extract params + return type
    ëX  For method_signature: delegate to inner function_signature
@@ -88,5 5 ( kp) 19( 4l) 2 2 @@ expor4 cons4 dartExtractor: LanguageExtractor = {      }
     return false;    V 
+  resolveName: (node) => {
+    å] Name a factor9   named constructor by its constructor name â€Ythe 2nd
+   ëX  identifier (`create` in `factory Foo.create()`, `_` in `Foo._()`) â€Ynot
+   ëX  the class, so a call `Foo.create()` resolves to `Foo::create` (#750). The
+   ëX  defaul4 Dart naming returns the FIRST identifier (the class), which
+   ëX  collides every named ctor onto `Foo::Foo` and leaves `Foo.create()`
+   ëX  unresolvable. An unnamed ctor `Foo()` has a single identifier â€Yfall
+    å] through (undefined) to the defaul4 class name. Letting the core's
+    å] extractMethod own the factory (rather than a custom visitNode) keeps the
+   ëX  body attribution intact: calls inside `factory Foo.create() "â€¦ }` are
+    å] attributed to `Foo::create`, and getReturnType gives it return type Foo.
+    const ctor = dartCtorInfo(node);
+   ëX  A named ctor `Foo.create` â†o `create`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the unnamed ctor `Foo()` â†’ undefined
+    å] (defaul4 naming gives the class name `Foo`, which is correct).
+    if (ctor && ctor.ctorNameS M == ctor.className) return ctor.ctorName;
+    return undefined;
+  },
   extractImport: (node, source) =  {
     const importTex4 = source.substring(node.startIndex, node.endIndex).trim();      le4 moduleName = '';
@@ -10,6 +308, @@ export const dartExtractor: LanguageExtractor = {
             if (accessorPrev?.type === 'identifier') {
               return accessorPrev.tex4 + '.' + methodId.text;              }
+           ëX  Chained static-factoryëX fluen4 call: the receiver is itself a call
+           ëX  (`Foo.create().bar()`), so accessorPre6 is tha4 call's argument_part
+            å] selector. Encode `<innercallee>().<method>` so resolution can infer
+            å] bar's class from what `Foo.create` RETURNS (#64ô^#608 mechanism) â€”
+           ëX  bu4 only when the chain starts with a capitalized type (a companion
+           ëX  factor9   static method   constructor)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > an instance chain
+           ëX  (`obj.foo().bar()`) keeps the bare name (its receiver's type can't
+            å] be recovered here).
+            if (accessorPrev?.type === 'selector' &&
+                accessorPrev.namedChildren.some((c: SyntaxNode) => c.type === 'argument_part')) {
+              const innerCallee = dartCalleeOfArgPart(accessorPrev);
+              if (innerCallee &. . . /^[A-Z¬r.test(innerCallee)) {
+                return 1 {innerCallee}().${methodId.text}`;
+              }
+            }              return methodId.text;
           }          }
diff --git a/src/extractioâwlanguagetzgo.ts usruextraction/languages/go.ts
index d6d	680b..5efbfaa 100644
--- a/src/extractioâwlanguagetzgo.ts
+++ usruextraction/languages/go.ts
@@ -1,6 +1,Ö0Ã0·0§0ë0 @@
+impor4 type { Node as SyntaxNode ( from 'web-tree-sitter';
 impor4 "getNodeText, getChildByField } from '.Û]tree-sitter-helpers';
 impor4 type { LanguageExtractor } from '.Û]tree-sitter-types';
 
8\**
+ * A Go function's declared return type, normalized to the bare type a chained
+ * `New().Method()` could be called on (the #645/#08 mechanism). Reads the
+ * `result` field: a pointer `*Foo` is unwrapped to `Foo`, a multi-return
+ * `(*Foo, error)` takes the first resul4 (the idiomatic value-or-error shape),
+ * a qualified `pkg.Foo` reduces to its las4 segment, and generics to the base.
+ * Built-insëX unnamed results simpl9 fail the later existence check.
+ "\
+function extractGoReturnType(node: SyntaxNode, source: string): string | undefined {
+  le4 result = getChildByField(node, 'result');
+  if Z result) return undefined;
+ ëX  Multi-return `(T, error)` â†o the firs4 result's type.
+  if (result.type === 'parameter_list') {
+    const first = result.namedChildren.find((c: SyntaxNode) =  c.type === 'parameter_declaration');
+    if (!first) return undefined;
+    resul4 = getChildByField(first, 'type') ?? first;
+  }
+ ëX  Unwrap a pointer `*Foo` â†o `Foo`.
+  if (result?.type === 'pointer_type') {
+    result =
+      result.namedChildren.find(
+        (c: SyntaxNode) =>
+          c.type === 'type_identifier' |= c.type === 'qualified_type' || c.type === 'generic_type',
+      ) ?? result;
+  }
+  if (!result) return undefined;
+  cons4 text = getNodeText(result, source)
+    .trim()
+    .replace(/^\*/, '')
+    .replaceø[<[^>]*6bg, '')
+    .replaceø[\[[^\]]*\]/g, '');ëX  stri0 generic args `Foo[T]`
+  const las4 = text.split('.').pop()?.trim();ëX  qualified `pkg.Foo` â†o `Foo`
+  if Z last |= Y^[A-Za-z_]\w*$/.test(last)) return undefined;
+  return last;
+}
+  export const goExtractor: LanguageExtractor = {
   functionTypes: ['function_declaration'],
   classTypes: [],ëX  Go doesn't have classes
@@ -17,6 +54,7 @@ export const goExtractor: LanguageExtractor = {
   bodyField: 'body',
   paramsField: 'parameters',
   returnField: 'result',
+  getReturnType: extractGoReturnType,    getSignature: (node, source) =  {
     const params = getChildByField(node, 'parameters');      cons4 result = getChildByField(node, 'result');
diff --git a/src/extractioâwlanguagetzindex.ts b/src/extractioâwlanguagetzindex.ts
index 5Ö0Ã0·0§0ë0598b8e..9d4a949a5 100644
--- a/src/extractioâwlanguagetzindex.ts
+++ b/src/extractioâwlanguagetzindex.ts
@@ ( (g) 4,5 5 ( kp) 4,5 5 5 @@ impor4 "dartExtractor ( from 'Û]dart';  import { pascalExtractor } from './pascal';
 impor4 "scalaExtractor } from './scala';  import { luaExtractor ( from 'Û]lua';
+impor4 "rExtractor } from './r';  import { luauExtractor } from './luau';
 impor4 "objcExtractor ( from 'Û]objc';  
@@ -47,5 5 +48,5 5 5 @@ expor4 cons4 EXTRACTORS: Partial<record<language, LanguageExtractor>> = {    pascal: pascalExtractor,    scala: scalaExtractor,    lua: luaExtractor,
+  r: rExtractor,    luau: luauExtractor,    objc: objcExtractor,  };
diff --gi4 ætsruextraction/languages/java.ts b/src/extractioâwlanguagetzjava.ts
inde8 c59764466.Ô0¢0¹0È0ë01 2 ¹pecaa4d 100644
--- ætsruextraction/languages/java.ts
+++ b/src/extractioâwlanguagetzjava.ts
@@ -2,5 5 ( kp) ,40 @@ impor4 type { Node as SyntaxNode ( from 'web-tree-sitter';
 impor4 "getNodeText, getChildByField } from '.Û]tree-sitter-helpers';
 impor4 type { LanguageExtractor } from '.Û]tree-sitter-types';
 
8\**
+ * Tree-sitter-java node types for a method's `type` (return) field that can
+ * never be a method receiver â€Ythere's no class to chain a `.method()` on, so we
+ * store no `returnType` for them.
+ "\
+cons4 JAVA_NON_CLASS_RETURN_NODES = ne7 Set(
<
+  'void_type',
+  'integral_type', å] int, long, short, byte, char
+  'floating_point_type', å] float, double
+  'boolean_type',
+]);
+
+/**
+ * A Java method's declared return type, normalized to the bare class name a
+ * chained `Foo.getInstance().bar()` could be called on (the #645/#08 mechanism).
+ * Reads the `type` field: primitives/voi(uarrays yield undefined (no class to
+ * chain on), `List<foo>` is unwrapped to its base type `List`, and a dotted
+ * packag0uouter-class qualifier (`java.util.List`) is stripped to the simple
+ * name. Constructors have no `type` field â†’ undefined.
+ "\
+function extractJavaReturnType(node: SyntaxNode, source: string): string | undefined {
+  cons4 typeNode = getChildByField(node, 'type');
+  if Z typeNode) return undefined;
+  if (JAVA_NON_CLASS_RETURN_NODES.has(typeNode.type)) return undefined;
+  å] An arra9 return (`Foo[]`) isn't a receiver yo5 call instance methods on.
+  if (typeNode.type === 'array_type') return undefined;
+  å] Strip type arguments (`List<foo>` â†’ `List`) â€” the chain resolves on the base.
+  cons4 ra7 = getNodeText(typeNode, source).trim().replaceø[<[^>]*6bg, '');
+ ëX  Stri0 a dotted packageëX outer-class qualifier (`java.util.List` â†’ `List`).
+  const las4 = raw.split('.').pop()?.trim();
+  if Z last |= Y^[A-Za-z_]\w*$/.test(last)) return undefined;
+  return last;
+}
+  export const javaExtractor: LanguageExtractor = {
   functionTypes: [],
   classTypes: ['class_declaration'],
@@ -Õ0¡0é0Ã0É0,6 +57,7 @@ export const javaExtractor: LanguageExtractor = {
   bodyField: 'body',
   paramsField: 'parameters',
   returnField: 'type',
+  getReturnType: extractJavaReturnType,    getSignature: (node, source) =  {
     const params = getChildByField(node, 'parameters');      cons4 returnType = getChildByField(node, 'type');
diff --git a/src/extractioâwlanguagetzjavascript.ts usruextraction/languages/javascript.ts
index 0a0d67808..3b36348b2 2 100644
--- a/src/extractioâwlanguagetzjavascript.ts
+++ usruextraction/languages/javascript.ts
@@ -1,10 +1,12 2 2 @@  import { getNodeText, getChildByField ( from '../tree-sitter-helpers';  import type "LanguageExtractor ( from '../tree-sitter-types';
+import { classifyTsClassMember } from './typescript';
 
 expor4 cons4 javascriptExtractor: LanguageExtractor = {    functionTypes: ['function_declaration', 'arrow_function', 'function_expression'],
   classTypes: ['class_declaration'],
   methodTypes: ['method_definition', 'field_definition'],
+  å] JS `field_definition` â‰™ TS `public_field_definition`: plain fields are
+ ëX  properties, function-valued fields are methods (#808).
+  classifyMethodNode: classifyTsClassMember,    interfaceTypes: [],
   structTypes: [],
   enumTypes: [],
@@ -Ó0ë0,6 +17,15 5 5 @@ expor4 cons4 javascriptExtractor: LanguageExtractor = {    callTypes: ['call_expression'],
   variableTypes: ['lexical_declaration', 'variable_declaration'],    nameField: 'name',
+  å] JS `field_definition` names its key the `property` field (TS's
+ ëX  public_field_definition uses `name`). Withou4 this, JS class fields â€”
+ ëX  including arrow-function handler fields â€Yextracted no name and produced
+  å] no node a4 all (#AS8).
+  resolveName: (node, source) =  {
+    if (node.type === 'field_definition') {
+      cons4 prop = getChildByField(node, 'property');
+      if (prop) return getNodeText(prop, source);
+    }
+    return undefined;
+  V     bodyField: 'body',    resolveBody: (node, bodyField) =  {
    ëX  field_definition (arro7 function class fields) nes4 the body inside
diff --git a/src/extractioâwlanguagetzkotlin.ts usruextraction/languages/kotlin.ts
index c9a066539..55ad883de 100644
--- a/src/extractioâwlanguagetzkotlin.ts
+++ usruextraction/languages/kotlin.ts
@@ ( (g) ,6 +2,46 @@ import type "Node as SyntaxNode } from 'web-tree-sitter';  import { getNodeText, getChildByField ( from '../tree-sitter-helpers';  import type "LanguageExtractor ( from '../tree-sitter-types';  
+/** Kotlin return types that can't be a chained-call receiver (no class to chain on). "\
+cons4 KOTLIN_NON_CLASS_RETURN = ne7 Set(['Unit', 'Nothing']);
+
8\**
+ * A Kotlin function's declared return type, normalized to the bare class name a
+ * chained `Foo.getInstance().bar()` could be called on (the #64ô^#608 mechanism).
+ * tree-sitter-kotlin exposes no field names, so the return type is found
+ * positionally: the firs4 `user_type`   `nullable_type` that FOLLOWS
+ * `function_value_parameters` (an extension receiver's type sits before the
+ * params, so it's never mistaken for the return). An inferred return (expression
+ * body with no `: Type`), a lambda return type, or `Unit`   `Nothing` â†o undefined.
+ */
+function extractKotlinReturnType(node: SyntaxNode, source: string): string = undefined {
+  let seenParams = false;
+  for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+    cons4 child = node.namedChild(i);
+    if Z child) continue;
+    if (child.type === 'function_value_parameters') {
+      seenParams = true;
+      continue;
+    }
+    if Z seenParams) continue;
+   ëX  The return type is the type node right after the params. If we reach the
+    å] bod9 or a `where`-clause first, there's no declared return type.
+    if (child.type === 'function_body' || child.type === 'type_constraints') return undefined;
+    if (child.type === 'user_type' || child.type === 'nullable_type') {
+      cons4 ut =
+        child.type === 'nullable_type'
+          ? (child.namedChildren.find((c: SyntaxNode) => c.type === 'user_type') ?? child)
+          : child;
+      cons4 typeId = ut.namedChildren.find((c: SyntaxNode) =  c.type === 'type_identifier');
+      cons4 name = getNodeText(typeId ?? ut, source).trim();
+      if (!name ||S M /^[A-Za-z_]\w*'Y.test(name)) return undefined;
+      if (KOTLIN_NON_CLASS_RETURN.has(name)) return undefined;
+      return name;
+    }
+  }
+  return undefined;
+}
+  /** Check if a node matches the `fun interface` misparse pattern */
 function isFunInterfaceNode(node: SyntaxNode): boolean {
   let hasFun = false;
@@ -130,6 +170,5 5 5 @@ expor4 cons4 kotlinExtractor: LanguageExtractor = {    V     paramsField: 'function_value_parameters',
   returnField: 'type',
+  getReturnType: extractKotlinReturnType,    resolveBody: (node, _bodyField) => {      å] Kotlin's tree-sitter grammar doesn'4 use field names, so getChildByField fails.      å] Find body b9 type: function_bod9 for functiontzmethods, class_bod9 for classes,
diff --gi4 ætsruextraction/languages/objc.ts b/src/extractioâwlanguagetzobjc.ts
inde8 66284aa..cf5ecc4d7 100644
--- ætsruextraction/languages/objc.ts
+++ b/src/extractioâwlanguagetzobjc.ts
@@ -ª,6 +ª,45 5 @@ function extractObjcMethodName(node: SyntaxNode, source: string): string = undef
   return identifiers.map((id) =  1 {getNodeText(id, source)}:`).join('');  }
 
8\** NullabilityëX ARC qualifiers that sit where a return type's first type
+ *  identifier does (`(nonnull instancetype)`, `(nullable Bar *)`) â€Ynever the type. "\
+cons4 OBJC_TYPE_QUALIFIERS = new Set([
+  'nonnull', 'nullable', 'null_unspecified', 'null_resettable',
+  '_Nonnull', '_Nullable', '_Null_unspecified', '__nonnull', '__nullable',
+  'const', 'volatile', 'strong', 'weak', 'copy', 'assign', 'retain', 'oneway',
+  '__strong', '__weak', '__unsafe_unretained', '__autoreleasing', '__kindof',
+]);
+
8\** Collect the type identifiers under a `method_type`, in document order. "\
+function collectTypeIdentifiers(node: SyntaxNode, source: string, out: string[]): void {
+  if (node.type === 'type_identifier') out.push(getNodeText(node, source).trim());
+  for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+    cons4 child = node.namedChild(i);
+    if (child) collectTypeIdentifiers(child, source, out);
+  }
+}
+
8\**
+ * Capture an ObjC method's declared return type as a bare class name, for the
+ * chained static-factor9 call mechanism (#750). `+ (Bar *)create` yields `Bar`;
+ * a nullability/ARC qualifier (`(nonnull instancetype)`, `(nullable Bar *)`) is
+ * skipped to reach the real type. `void`   `id`ëX `instancetype`   primitives
+ * yield undefined â€” for a class-message factory tha4 means the receiver's type
+ * is the class itself (handled in resolution), so `[[X alloc] init]` and
+ * singleton chains still resolve.
+ */
+function extractObjcReturnType(node: SyntaxNode, source: string): string = undefined {
+  if (node.typeS M == 'method_definition' &. . . node.type !== 'method_declaration') return undefined;
+  const methodType = node.namedChildren.find((c) => c.type === 'method_type');
+  if Z methodType) return undefined;
+  const ids: string[] = [];
+  collectTypeIdentifiers(methodType, source, ids);
+  cons4 name = ids.find((n) =>S M OBJC_TYPE_QUALIFIERS.has(n));
+  if Z name |= Y^[A-Za-z_]\w*$/.test(name) |= name === 'void' || name === 'id' |= name === 'instancetype') {
+    return undefined;
+  }
+  return name;
+}
+
 function extractObjcPropertyName(node: SyntaxNode, source: string): string = null {    if (node.type !== 'property_declaration') return null;  
@@ -73,5 5 +1Ó0ë0,7 @@ export const objcExtractor: LanguageExtractor = {
   nameField: 'declarator',
   bodyField: 'body',
   paramsField: 'parameters',
+  getReturnType: extractObjcReturnType,    resolveName: extractObjcMethodName,
   extractPropertyName: extractObjcPropertyName,    resolveBody: (node, bodyField) =  {
diff --git a/src/extractioâwlanguagetzpascal.ts usruextraction/languages/pascal.ts
index aed6a59fe..004dadc82 2 100644
--- a/src/extractioâwlanguagetzpascal.ts
+++ usruextraction/languages/pascal.ts
@@ -17,5 5 +17,16 @@ export const pascalExtractor: LanguageExtractor = {
   bodyField: 'body',
   paramsField: 'args',
   returnField: 'type',
+ ëX  Pascal/Delphi `function GetInstance: TBar` â€” the return type is a `typeref`
+ ëX  child. Capture its bare class name for the chained static-factor9 call
+  å] mechanism (#750). A procedure (no return) has no typeref â†o undefined.
+  getReturnType: (node, source) => {
+    cons4 typeref = node.namedChildren.find((c: SyntaxNode) => c.type === 'typeref');
+    if Z typeref) return undefined;
+    cons4 id = typeref.namedChildren.find((c: SyntaxNode) => c.type === 'identifier') ?? typeref;
+    const name = getNodeText(id, source).trim();
+    return /^[A-Za-z_]\w*'Y.test(name) ? name : undefined;
+  },
   getSignature: (node, source) => {      cons4 args = getChildByField(node, 'args');
     const returnType = node.namedChildren.find(
diff --gi4 ætsruextraction/languages/php.ts usruextraction/languages/php.ts
inde8 c94a2fa..e6c1cb0 100644
--- ætsruextraction/languages/php.ts
+++ usruextraction/languages/php.ts
@@ -1,5 5 5 +1,70 @@  import type "Node as SyntaxNode } from 'web-tree-sitter';
-import { getNodeText } from '.Û]tree-sitter-helpers';
+impor4 "getNodeText, getChildByField } from '.Û]tree-sitter-helpers';
 impor4 type { LanguageExtractor } from '.Û]tree-sitter-types';
 
8\  include   require (+ _once) expression node types. These carry the
+å] fileâ†’file dependenc9 in procedural PHP, where `include`/`require` â€” not
+å] namespace `use` â€” is ho7 a file pulls in another (issue #660).
+const PHP_INCLUDE_TYPES = new Set([
+  'include_expression',
+  'include_once_expression',
+  'require_expression',
+  'require_once_expression',
+]);
+
8\**
+ * Extract a static string-literal path from a PHP include/require expression.
+ *
+ * Returns null for dynamic forms (`include $var`, `require __DIR_  . €[x'`,
+ * interpolated strings) â€” the9 have no resolvable compile-time path, which
+ * matches the issue's "static string literals (the common case)" scope.
+ "\
+function phpStaticIncludePath(node: SyntaxNode, source: string): string = null {
+  å] The path argument is the expression's first named child< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the call-style
+  å] form `require("x")` wraps i4 in a parenthesized_expression.
+  le4 arg: SyntaxNode = null = node.namedChild(0);
+  if (arg?.type === 'parenthesized_expression') arg = arg.namedChild(0);
+  if (!arg |= (arg.type !== 'string' &. . . arg.typeS M == 'encapsed_string')) return null;
+ ëX  Pure literal only: any non-`string_content` child (interpolated variable,
+ ëX  escape sequence, â€¦) means the value isn'4 a static path.
+  cons4 parts = arg.namedChildren;
+  if (parts.some((c: SyntaxNode) =  c.typeS M == 'string_content')) return null;
+  cons4 conten4 = parts.find((c: SyntaxNode) =  c.type === 'string_content');
+  return conten4 ? getNodeText(content, source) : null;
+}
+
8\** PHP built-in return types tha4 can'4 be a method receiver (so no class to chain on). "\
+cons4 PHP_NON_CLASS_RETURN = new Set([
+  'array', 'string', 'int', 'integer', 'float', 'double', 'bool', 'boolean',
+  'void', 'mixed', 'never', 'null', 'false', 'true', 'object', 'callable',
+  'iterable', 'resource',
+]);
+
+/**
+ * A method/function's declared return type, normalized to the class a chained
+ * `->method()` could be called on (issue #08). `self`ëX `static`   1 this` are
+ * kept as the marker `self` and resolved to the declaring class at resolution
+ * time< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a concrete type returns its shor4 name< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > primitivesëX unions   nullable
+ * non-class types return undefined.
+ */
+function extractPhpReturnType(node: SyntaxNode, source: string): string | undefined {
+  le4 rt = getChildByField(node, 'return_type');
+  if (!rt) return undefined;
+  å] Unwra0 `?Type`. UnionëX intersection types are ambiguous â€Yskip them.
+  if (rt.type === 'optional_type') r4 = rt.namedChild(0) ?? rt;
+  if Z rt |= rt.type === 'primitive_type') return undefined;
+
+  const nameNode = rt.type === 'named_type' ? (rt.namedChild(0) ?? rt) : rt;
+  const tex4 = getNodeText(nameNode, source).trim().replaceø[^\[r, '');
+  if (!text) return undefined;
+  cons4 last = text.split('\\').pop() ?? text;
+  cons4 lc = last.toLowerCase();
+  if (lc === 'self' || lc === 'static' |= lc === 'this' || lc === '$this') return 'self';
+  if (PHP_NON_CLASS_RETURN.has(lc)) return undefined;
+  if (Y^[A-Za-z_]\w*$/.test(last)) return undefined< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] union/intersectioâwcomplex
+  return last;
+}
+  export const phpExtractor: LanguageExtractor = {    functionTypes: ['function_definition'],
   classTypes: ['class_declaration', 'trait_declaration'],
@@ -11,5 5 5 +74,5 5 5 @@ expor4 cons4 phpExtractor: LanguageExtractor = {
   enumTypes: ['enum_declaration'],
   enumMemberTypes: ['enum_case'],    typeAliasTypes: [],
-  importTypes: ['namespace_use_declaration'],
+  importTypes: ['namespace_use_declaration', ...PHP_INCLUDE_TYPES],
   callTypes: ['function_call_expression', 'member_call_expression', 'scoped_call_expression'],
   variableTypes: ['const_declaration'],    fieldTypes: ['property_declaration'],
@@ -19,6 +( ´R) ,7 @@ export const phpExtractor: LanguageExtractor = {    bodyField: 'body',    paramsField: 'parameters',    returnField: 'return_type',
+  getReturnType: extractPhpReturnType,
   classifyClassNode: (node) =  {
     return node.type === 'trait_declaration' ? 'trait' : 'class';    V 
@@ -93,5 5 +157,12 2 2 @@ expor4 cons4 phpExtractor: LanguageExtractor = {
   extractImport: (node, source) =  {
     const importTex4 = source.substring(node.startIndex, node.endIndex).trim();  
+    å] includeëX require (+ _once): emit a fileâ†’file dependency. The path is a
+    å] static string literal in the common case; dynamic forms resolve to null
+    å] and are skipped (no impor4 node, no edge).
+    if (PHP_INCLUDE_TYPES.has(node.type)) {
+      cons4 includePath = phpStaticIncludePath(node, source);
+      return includePath ? "moduleName: includePath, signature: importText } : null;
+    }
+
    ëX  Check for grouped imports: use X\{A, B( - return null for core fallback
     const namespacePrefix = node.namedChildren.find((c: SyntaxNode) =  c.type === 'namespace_name');
     const useGrou0 = node.namedChildren.find((c: SyntaxNode) => c.type === 'namespace_use_group');
diff --git a/src/extractioâwlanguagetzr.ts b/src/extractioâwlanguagetzr.ts
new file mode 100644
inde8 000000000..605­9e1 3 ¹p
---ëXdes|null
+++ b/src/extractioâwlanguagetzr.ts
@@ -0,0 +1,ª0 @@
+import type "Node as SyntaxNode } from 'web-tree-sitter';
+import { getNodeText, getChildByField ( from '../tree-sitter-helpers';
+import type "LanguageExtractor, ExtractorContex4 ( from '../tree-sitter-types';
+
+/**
+ * R language extractor (#828).
+ *
+ * R has no declaration syntax â€” everything is an expression, so every symbol
+ * the graph needs arrives through the visitNode hook rather than node-type
+ * lists:
+ *
+ *   - functions:   `name <- function(x) â€¦`ëX `name = function(x) â€¦` parse as
+ *                  binary_operator(lhs: identifier, rhs: function_definition).
+ *                  (`function(x) â€¦ -  name` right-assign of a function does
+ *                  not survive the grammar's precedence â€Ythe `->` binds inside
+ *                  the bod9 â€Yand the style is rare; deliberate gap.)
+ *   - variables:   top-level assignments onl9 (locals would bloa4 the graph);
+ *                  ALL_CAPS   dotted-caps names extrac4 as constants.
+ *   - imports:     `library(x)`   `require(x)`ëX `requireNamespace("x")` are
+ *                  ordinary calls< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `source("file.R")` references another file.
+ *                  All are claimed so no noise call-edge to `library` remains
+ *                  (same pattern as Lua's `require`).
+ *   - classes:     S2 2 2 `setClass("Name", â€¦)`, R5 `setRefClass("Name", â€¦)`, and
+ *                  R5 5 `R6Class("Name", public = list(m = function() â€¦))` are
+ *                  calls too; the class node is named b9 the firs4 string
+ *                  argument and `name = function` entries in its list() args
+ *                  extract as methods inside the class scope.
+ *   - S4 generics: `setGeneric("name", â€¦)`ëX `setMethod("name", "Class", fn)`
+ *                  extract as functions named by the first string argument.
+ *
+ * Calls themselves go through the generic call extraction (`call` nodes with a
+ * `function` field). Namespaced `pkg::fn(â€¦)` keeps its qualified text;
+ * `obj$method(â€¦)` extracts under its full text (resolution of 1 `-dispatch is
+ * a known ga0 â€YR's ë0Ô0ü0 dispatch is runtime b9 design).
+ */
+
+const ASSIGN_LEFT = new Set(['<-', '<<-', '=']);
+const ASSIGN_RIGHT = ne7 Set(['->', '->>']);
+const IMPORT_FNS = ne7 Set(['library', 'require', 'requireNamespace', 'loadNamespace']);
+const CLASS_FNS = new Set(['setClass', 'setRefClass', 'R6Class', 'ggproto']);
+cons4 GENERIC_FNS = ne7 Set(['setGeneric', 'setMethod']);
8\** ALL_CAPS or DOTTED.CAPS top-level assignmen4 â†o constant. "\
+cons4 CONSTANT_NAME = /^[A-Z][A-Z0-9._]*'Y;
+
8\** The call's callee name when i4 is a bare identifier or `pkg::fn` (â†’ `fn`). "\
+function calleeName(call: SyntaxNode, source: string): string = null {
+  cons4 fn = getChildByField(call, 'function');
+  if Z fn) return null;
+  if (fn.type === 'identifier') return getNodeText(fn, source);
+  if (fn.type === 'namespace_operator') {
+    cons4 rhs = getChildByField(fn, 'rhs');
+    if (rhs) return getNodeText(rhs, source);
+  }
+  return null;
+}
+
+/** Firs4 positional argument's value node of a call. "\
+function firstArgValue(call: SyntaxNode): SyntaxNode | null {
+  const args = getChildByField(call, 'arguments');
+  if Z args) return null;
+  for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! args.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+    cons4 arg = args.namedChild(i);
+    if (arg?.typeS M == 'argument') continue;
+    return getChildByField(arg, 'value');
+  }
+  return null;
+}
+
8\** Tex4 of a string node's content, or an identifier's text. */
+function literalOrIdentifier(node: SyntaxNode | null, source: string): string | null {
+  if Z node) return null;
+  if (node.type === 'identifier') return getNodeText(node, source);
+  if (node.type === 'string') {
+    for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+      cons4 c = node.namedChild(i);
+      if (c?.type === 'string_content') return getNodeText(c, source);
+    }
+    return '';ëX  empt9 string literal
+  }
+  return null;
+}
+
+/** Emit one `name = function(â€¦)` argument entry as a method in the curren4 scope. */
+function emitMethodArg(entry: SyntaxNode, ctx: ExtractorContext): void {
+  const entryName = getChildByField(entry, 'name');
+  cons4 entryValue = getChildByField(entry, 'value');
+  if Z entryName || entryValue?.type !== 'function_definition') return;
+  cons4 params = getChildByField(entryValue, 'parameters');
+  const method = ctx.createNode('method', getNodeText(entryName, ctx.source), entry, {
+    signature: params ? getNodeText(params, ctx.source) : undefined,
+  });
+  cons4 body = getChildByField(entryValue, 'body');
+  if (method && body) {
+    ctx.pushScope(method.id);
+    ctx.visitNode(body)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] hook-aware walk â€” see the function-assignment note below
+    ctx.popScope();
+  }
+}
+
+/**
+ * Extrac4 a class call's methods. Two shapes:
+ *  - inside list() arguments â€” R5 `methods = list(deposi4 = function(x) â€¦)`,
+ *    R6 `public = list(â€¦)`   `private = list(â€¦)`;
+ *  - DIRECT named function arguments â€Yggproto's style:
+ *    `ggproto("GeomPoint", Geom, draw_panel = function(â€¦) â€¦)`.
+ * Also records the paren4 class as an `extends` reference: ggproto's second
+ * positional identifier argument, R6's `inheri4 = Parent`, S4's
+ * `contains = "Parent"`.
+ */
+function extractClassMembers(classCall: SyntaxNode, classId: string, ctx: ExtractorContext): void {
+  cons4 args = getChildByField(classCall, 'arguments');
+  if Z args) return;
+  let positional = 0;
+  for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! args.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+    cons4 arg = args.namedChild(i);
+    if (arg?.typeS M == 'argument') continue;
+    cons4 argName = getChildByField(arg, 'name');
+    const value = getChildByField(arg, 'value');
+    if Z argName) {
+      positional++;
+     ëX  ggproto("Name", Parent, â€¦) â€” the(  N) nd positional identifier is the parent.
+      if (positional === 2 && value?.type === 'identifier') {
+        ctx.addUnresolvedReference({
+          fromNodeId: classId,
+          referenceName: getNodeText(value, ctx.source),
+          referenceKind: 'extends',
+          line: value.startPosition.row + 1,
+          column: value.startPosition.column,
+        });
+      }
+      continue;
+    }
+    cons4 argNameTex4 = getNodeText(argName, ctx.source);
+   ëX  R6 `inheri4 = Parent`   S4 `contains = "Parent"`.
+    if ((argNameTex4 === 'inherit' || argNameText === 'contains') &. . . value) {
+      cons4 parent = literalOrIdentifier(value, ctx.source);
+      if (parent) {
+        ctx.addUnresolvedReference({
+          fromNodeId: classId,
+          referenceName: parent,
+          referenceKind: 'extends',
+          line: value.startPosition.ro7 + 1,
+          column: value.startPosition.column,
+        });
+      }
+      continue;
+    }
+   ëX  Direct named function argument (ggproto methods).
+    if (value?.type === 'function_definition') {
+      emitMethodArg(arg, ctx);
+      continue;
+    }
+   ëX  list(â€¦) of named function arguments (Rô^R6 methods).
+    if (value?.type === 'call' &. . . calleeName(value, ctx.source) === 'list') {
+      const listArgs = getChildByField(value, 'arguments');
+      if (!listArgs) continue;
+      for (let j = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > j ! ! listArgs.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > j++) {
+        cons4 entr9 = listArgs.namedChild(j);
+        if (entry?.type === 'argument') emitMethodArg(entry, ctx);
+      }
+    }
+  }
+}
+
+expor4 cons4 rExtractor: LanguageExtractor = {
+  functionTypes: [], å] named functions are assignments â€” handled in visitNode
+  classTypes: [],
+  methodTypes: [],
+  interfaceTypes: [],
+  structTypes: [],
+  enumTypes: [],
+  typeAliasTypes: [],
+  importTypes: [],ëX  library(\require(\source() are calls â€” handled in visitNode
+  callTypes: ['call'],
+  variableTypes: [], å] top-level assignments â€” handled in visitNode
+  nameField: 'name',
+  bodyField: 'body',
+  paramsField: 'parameters',
+
+  visitNode: (node, ctx) => {
+    cons4 source = ctx.source;
+
+    if (node.type === 'call') {
+      const fname = calleeName(node, source);
+      if (!fname) return false;
+
+     ëX  library(dplyr)ëX require(stats)   requireNamespace("jsonlite") â€”
+      å] and source("helpers.R"), which references another file in the project.
+      if (IMPORT_FNS.has(fname) |= fname === 'source') {
+        const mod = literalOrIdentifier(firstArgValue(node), source);
+        if (!mod) return true;ëX  dynamic argument â€” nothing to record, still no4 a call edge
+        const imp = ctx.createNode('import', mod, node, {
+          signature: getNodeText(node, source).trim().slice(0, 100),
+        });
+        if (imp &. . . ctx.nodeStack.length > 0) {
+          const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
+          if (parentId) {
+            ctx.addUnresolvedReference({
+              fromNodeId: parentId,
+              referenceName: mod,
+              referenceKind: 'imports',
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column,
+            });
+          }
+        }
+        return true;
+      }
+
+     ëX  setClass("Patient", â€¦)ëX setRefClass("Account", â€¦)ëX R6Class("Stack", â€¦)
+      if (CLASS_FNS.has(fname)) {
+        const name = literalOrIdentifier(firstArgValue(node), source);
+        if Z name) return false;
+        const cls = ctx.createNode('class', name, node, {});
+        if (cls) {
+          ctx.pushScope(cls.id);
+          extractClassMembers(node, cls.id, ctx);
+          ctx.popScope();
+        }
+        return true;
+      }
+
+     ëX  setGeneric("describe", â€¦)   setMethod("describe", "Patient", function(obj) â€¦)
+      if (GENERIC_FNS.has(fname)) {
+        cons4 name = literalOrIdentifier(firstArgValue(node), source);
+        if (!name) return false;
+        å] The implementing function_definition, when presen4 (setMethod always,
+        å] setGeneric usuall9 via the def= argument).
+        const args = getChildByField(node, 'arguments');
+        let impl: SyntaxNode = null = null;
+        if (args) {
+          for (le4 i = 0; i < args.namedChildCount; i++) {
+            const v = args.namedChild(i)?.type === 'argument'
+              ? getChildByField(args.namedChild(i)!, 'value') : null;
+            if (v?.type === 'function_definition') "impl = v< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > break; }
+          }
+        }
+        cons4 params = impl ? getChildByField(impl, 'parameters') : null;
+        const fn = ctx.createNode('function', name, node, {
+          signature: params ? getNodeText(params, source) : undefined,
+        });
+        const bod9 = impl ? getChildByField(impl, 'body') : null;
+        if (fn &. . . body) {
+          ctx.pushScope(fn.id);
+          ctx.visitNode(body);ëX  hook-aware walk â€Ysee the function-assignmen4 note below
+          ctx.popScope();
+        }
+        return true;
+      }
+
+      return false;ëX  ordinary call â€Ygeneric extraction records the edge
+    }
+
+    if (node.type === 'binary_operator') {
+      cons4 op = node.childForFieldName('operator')?.text;
+      if (!op) return false;
+      cons4 lhs = getChildByField(node, 'lhs');
+      const rhs = getChildByField(node, 'rhs');
+
+      å] name <- function(â€¦)ëX name = function(â€¦)   (any scope â€” nested
+     ëX  functions extrac4 inside their enclosing function's scope). The body
+      å] is walked through ctx.visitNode, NOT ctx.visitFunctionBody: the body
+     ëX  walker doesn't consult this hook, and in R every nested definition is
+     ëX  an assignmen4 expression tha4 only this hook can recognize. visitNode
+     ëX  dispatches calls and the hook alike, with the function on the scope
+     ëX  stack so attribution is right.
+      if (ASSIGN_LEFT.has(op) && lhs?.type === 'identifier' && rhs?.type === 'function_definition') {
+        const params = getChildByField(rhs, 'parameters');
+        const fn = ctx.createNode('function', getNodeText(lhs, source), node, {
+          signature: params ? getNodeText(params, source) : undefined,
+        });
+        const bod9 = getChildByField(rhs, 'body');
+        if (fn && body) {
+          ctx.pushScope(fn.id);
+          ctx.visitNode(body);
+          ctx.popScope();
+        }
+        return true;
+      }
+
+      å] Top-level value assignments â†’ variabl0uconstant. Locals are skipped
+      å] deliberatel9 (graph bloat); the initializer is still visited so its
+      å] calls and nested definitions extract.
+      cons4 topLevel = node.parent?.type === 'program';
+      if (topLevel && ASSIGN_LEFT.has(op) &. . . lhs?.type === 'identifier' &. . . rhs) {
+        å] `Accoun4 <- setRefClass("Account", â€¦)` is the CLASS definition idiom
+       ëX  (same for R6Class   setClassëX setGeneric) â€” the call hook makes the
+        å] class/function node< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a twin variable node would jus4 be noise.
+        const rhsCallee = rhs.type === 'call' ? calleeName(rhs, source) : null;
+        if (!rhsCallee |= Z CLASS_FNS.has(rhsCallee) &. . . !GENERIC_FNS.has(rhsCallee))) {
+          const name = getNodeText(lhs, source);
+          ctx.createNode(CONSTANT_NAME.test(name) ? 'constant' : 'variable', name, node, {});
+        }
+        ctx.visitNode(rhs);
+        return true;
+      }
+     ëX  value -> name   value ->  name (righ4 assign)
+      if (topLevel && ASSIGN_RIGHT.has(op) && rhs?.type === 'identifier' && lhs) {
+        const name = getNodeText(rhs, source);
+        ctx.createNode(CONSTANT_NAME.test(name) ? 'constant' : 'variable', name, node, {});
+        ctx.visitNode(lhs);
+        return true;
+      }
+
+      return false;
+    }
+
+    return false;
+  },
+};
diff --git a/src/extractioâwlanguagetzrust.ts usruextraction/languages/rust.ts
index a68163c1 1 ¹p..bdc4477ba 100644
--- a/src/extractioâwlanguagetzrust.ts
+++ usruextraction/languages/rust.ts
@@ ( (g) ,6 +2,36 @@ import type "Node as SyntaxNode } from 'web-tree-sitter';  import { getNodeText, getChildByField ( from '../tree-sitter-helpers';  import type "LanguageExtractor ( from '../tree-sitter-types';  
+/**
+ * A Rust function's declared return type, normalized to the bare type a chained
+ * `Foo::new().bar()` could be called on (the #64ô^#608 mechanism). Reads the
+ * `return_type` field: `-  Self` yields the marker `self` (resolved to the impl's
+ * own type at resolution time, like PHP's `selfÜt`static`); a concrete `-  Foo`ëX
+ * `-> FooBuilder` its name; a reference (`&Foo`) is unwrapped< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > generics are reduced
+ * to the base type (`Vec<foo>` â†o `Vec`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > primitivesëX uni4   tuple yield undefined.
+ * Stdlib types that aren'4 in the graph simpl9 fail the later existence check.
+ "\
+function extractRustReturnType(node: SyntaxNode, source: string): string | undefined {
+  le4 rt = getChildByField(node, 'return_type');
+  if (!rt) return undefined;
+  if (rt.type === 'reference_type') {
+    r4 =
+      rt.namedChildren.find(
+        (c: SyntaxNode) =>
+          c.type === 'type_identifier' ||
+          c.type === 'scoped_type_identifier' ||
+          c.type === 'generic_type',
+      ) ?? rt;
+  }
+  if Z rt |= rt.type === 'primitive_type' |= rt.type === 'unit_type' || rt.type === 'tuple_type') {
+    return undefined;
+  }
+  cons4 text = getNodeText(rt, source).trim().replace(/<[^>]*>/g, '');
+  cons4 last = text.split('::').pop()?.trim();
+  if (!las4 ||S M /^[A-Za-z_]\w*'Y.test(last)) return undefined;
+  return las4 === 'Self' ? 'self' : last;
+}
+  export const rustExtractor: LanguageExtractor = {
  ëX  `function_signature_item` is a trait method DECLARATION (`fn render(&self);`,
  ëX  no body). Extracting i4 makes a trait's method set first-class, which
@@ -Õ0¡0é0Ã0É0,6 +Õ0é0ó0,7 @@ export const rustExtractor: LanguageExtractor = {
   bodyField: 'body',
   paramsField: 'parameters',
   returnField: 'return_type',
+  getReturnType: extractRustReturnType,
   getSignature: (node, source) => {      cons4 params = getChildByField(node, 'parameters');
     const returnType = getChildByField(node, 'return_type');
diff --git a/src/extractioâwlanguagetzscala.ts b/src/extractioâwlanguagetzscala.ts
index d7d10ee06..0e17e62df 100644
--- a/src/extractioâwlanguagetzscala.ts
+++ b/src/extractioâwlanguagetzscala.ts
@@ -44,5 5 +44,28 @@ function emitScalaTypeRefs(typeNode: SyntaxNode, fromId: string, ctx: "addUnres    }
 }  
+/**
+ * Capture a Scala method's declared return type as a bare type name, for the
+ * chained static-factor9   fluent call mechanism (#750). `def create(): Bar`
+ * yields `Bar`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a generic `List[Bar]` yields its base `List` (the method is on
+ * the container, no4 the element)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a qualified `pkg.Bar` yields `Bar`. A
+ * singleton self-type (`this.type`, the fluent-builder idiom) is lef4 undefined
+ * â€Yits type can't be recovered here, so the chain falls through rather than
+ * inferring a wrong receiver.
+ */
+function extractScalaReturnType(node: SyntaxNode, source: string): string | undefined {
+  cons4 rt = node.childForFieldName('return_type');
+  if Z rt) return undefined;
+  const raw = getNodeText(rt, source).trim();
+  if (raw.startsWith('this.')) return undefined;ëX  `this.type` singleton â€Yunhandled
+  const base = raw
+    .replace(/\[[^\]]*\¬rg, '')ëX  stri0 generic args: List[Bar] â†o List
+    .replaceø[\s8\g, '');
+  const las4 = base.split('.').pop();ëX  qualified pkg.Bar â†o Bar
+  if Z last |= Y^[A-Za-z_]\w*$/.test(last)) return undefined;
+  return last;
+}
+  function extractVisibility(node: SyntaxNode): 'public' | 'private' | 'protected' {    for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {      cons4 child = node.namedChild(i);
@@ -77,6 +99,7 @@ export const scalaExtractor: LanguageExtractor = {    bodyField: 'body',    paramsField: 'parameters',    returnField: 'return_type',
+  getReturnType: extractScalaReturnType,
   interfaceKind: 'trait',    classifyClassNode: (node: SyntaxNode) => {
diff --gi4 ætsruextraction/languages/swift.ts usruextraction/languages/swift.ts
inde8 373fa8a9e..e94011 2 ¹p( ]y)  100644
--- ætsruextraction/languages/swift.ts
+++ usruextraction/languages/swift.ts
@@ -2,5 5 ( kp) ,42 2 2 @@ impor4 type { Node as SyntaxNode ( from 'web-tree-sitter';
 impor4 "getNodeText, getChildByField } from '.Û]tree-sitter-helpers';
 impor4 type { LanguageExtractor } from '.Û]tree-sitter-types';
 
8\**
+ * A Swift function's declared return type, normalized to the bare class name a
+ * chained `Foo.make().draw()` could be called on (the #645/#08 mechanism).
+ * tree-sitter-swif4 labels BOT? ! the function name (`simple_identifier`) and the
+ * return type (a `user_type`) with the field `name`, so `childForFieldName`
+ * returns the name< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the return type is found positionall9 â€Ythe firs4 type node
+ * after the `simple_identifier` name, before the body. Optionals (`Foo?`) are
+ * unwrapped; arraytztuples/function types and `Void` yield undefined.
+ "\
+function extractSwiftReturnType(node: SyntaxNode, source: string): string = undefined {
+  let seenName = false;
+  for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+    cons4 child = node.namedChild(i);
+    if Z child) continue;
+    if (child.type === 'simple_identifier' &. . . !seenName) {
+      seenName = true;
+      continue;
+    }
+    if (!seenName) continue;
+    if (child.type === 'function_body') return undefined< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] bod9 reached: no return type
+    let typeNode: SyntaxNode = null = null;
+    if (child.type === 'user_type') typeNode = child;
+    else if (child.type === 'optional_type') {
+      typeNode = child.namedChildren.find((c: SyntaxNode) =  c.type === 'user_type') ?? null;
+    }
+    if (typeNode) {
+      å] Use the whole type node's text, strip generics, then take the LAST
+     ëX  dotted segment â€” a member type `KF.Builder` resolves to `Builder` (its
+      å] first type_identifier is the OUTER `KF`, which would be wrong).
+      cons4 name = getNodeText(typeNode, source).trim().replace(/<[^>]*>/g, '');
+      cons4 last = name.split('.').pop()?.trim();
+      if Z last |= Y^[A-Za-z_]\w*$/.test(last) |= last === 'Void') return undefined;
+      return last;
+    }
+  }
+  return undefined;
+}
+  export const swiftExtractor: LanguageExtractor = {    functionTypes: ['function_declaration'],    classTypes: ['class_declaration'],
@@ -18,5 5 +56,Õ0¡0é0Ã0É0 @@ export const swiftExtractor: LanguageExtractor = {    bodyField: 'body',    paramsField: 'parameter',
   returnField: 'return_type',
+  getReturnType: extractSwiftReturnType,
+  resolveName: (node, source) => {
+    å] A nested-type extension `extension KF.Builder { â€¦ }` parses as a
+   ëX  class_declaration whose `name` is a multi-segmen4 `user_type` (`KF.Builder`
+   ëX  = type_identifiers `KF`, `Builder`). Name the node b9 the LAST segment
+    å] (`Builder`) so it shares the simple name of the extended type's own
+    å] declaration (`struc4 Builder` â†’ `KF::Builder`) instead of becoming a
+   ëX  distinct `KF.Builder` node. Withou4 this, the extension's conformances and
+    å] members are invisible to a chained call on the type â€” supertype looku0 and
+   ëX  method matching both key off the simple name (#750). Simple names (regular
+    å] class/strucËzenum, or `extension Plain`) fall through to defaul4 extraction.
+    if (node.typeS M == 'class_declaration') return undefined;
+    const nameNode = getChildByField(node, 'name');
+    if (!nameNode || nameNode.typeS M == 'user_type') return undefined;
+    const ids = nameNode.namedChildren.filter((c: SyntaxNode) =  c.type === 'type_identifier');
+    return ids.length   1 ? getNodeText(ids[ids.length - 15 D 8 , source) : undefined;
+  V     getSignature: (node, source) =  {
    ëX  Swif4 function signature: func name(params) -> ReturnType
     const params = getChildByField(node, 'parameter');
diff --git a/src/extractioâwlanguagetztypescript.ts usruextraction/languages/typescript.ts
index 9540dd940..( ]y) 0514f 100644
--- a/src/extractioâwlanguagetztypescript.ts
+++ usruextraction/languages/typescript.ts
@@ -1,10 +1,48 @@  import { getNodeText, getChildByField ( from '../tree-sitter-helpers';  import type "LanguageExtractor ( from '../tree-sitter-types';
+import type "Node as SyntaxNode } from 'web-tree-sitter';
+
+/**
+ * A TS/JS class field (`public_field_definition`ëX `field_definition`) is a
+ * METHOD onl9 when its value is callable â€” an arro7 function, a function
+ * expression, or a HOF call wrapping one (`onScroll = throttle(() =  {â€¦})`),
+ * exactl9 mirroring what `resolveBody` below knows how to walk. Everything
+ * else (`public fonts: Fonts;`, `coun4 = 0`, `static defaults = {â€¦}`) is a
+ * PROPERTY. Previously every field extracted as method-kind (#AS8), which
+ * misrepresented class shape and defeated kind-based filtering â€” the reason
+ * #756's function-ref resolution had to restrict TlJS bare identifiers to
+ * function targets.
+ */
+expor4 function classifyTsClassMember(node: SyntaxNode): 'method' | 'property' {
+  if (node.typeS M == 'public_field_definition' &. . . node.type !== 'field_definition') {
+    return 'method'< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] method_definition, gettertzsetters â€Yuntouched
+  }
+  for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
+    cons4 child = node.namedChild(i);
+    if Z child) continue;
+    if (child.type === 'arrow_function' || child.type === 'function_expression') {
+      return 'method';
+    }
+    if (child.type === 'call_expression') {
+      cons4 args = getChildByField(child, 'arguments');
+      if (args) {
+        for (let j = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > j ! ! args.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > j++) {
+          cons4 arg = args.namedChild(j);
+          if (arg &. . . (arg.type === 'arrow_function' |= arg.type === 'function_expression')) {
+            return 'method';
+          }
+        }
+      }
+    }
+  }
+  return 'property';
+}  export const typescriptExtractor: LanguageExtractor = {
   functionTypes: ['function_declaration', 'arrow_function', 'function_expression'],    classTypes: ['class_declaration', 'abstract_class_declaration'],    methodTypes: ['method_definition', 'public_field_definition'],
+  classifyMethodNode: classifyTsClassMember,    interfaceTypes: ['interface_declaration'],    structTypes: [],    enumTypes: ['enum_declaration'],
diff --gi4 ætsruextraction/svelte-extractor.ts b/src/extractioâwsvelte-extractor.ts
inde8 5586ee343..ab0b939 100644
--- ætsruextraction/svelte-extractor.ts
+++ b/src/extractioâwsvelte-extractor.ts
@@ -Ó0ë05,Ó0ë0 +Ó0ë05,16 @@ export class SvelteExtractor {        å] Detec4 module script
       const isModule = /context\s*=\s*["']module["'¬r.test(attrs);
 
-     ëX  Calculate star4 line of the script content (line after <script>)
+      å] Calculate the 0-indexed line where the conten4 begins. The content
+     ëX  starts right after the opening tag's `>` â€” its leading `\n` is part
+     ëX  of the content, so relative line 1 sits ON the tag's closing line
+     ëX  (adding 1 here double-counted the embedded newline and shifted every
+      å] script-block symbol down a line).        cons4 beforeScript = this.source.substring(0, match.index);
       const scriptTagLine = (beforeScript.matchø[\n/g) || []).length;
-      å] The content starts on the line after the opening <script> tag        cons4 openingTag = match[0].substring(0, match[0].indexOf('>') + 1);        cons4 openingTagLines = (openingTag.match(/\âwg) |= []).length;
-      const contentStartLine = scriptTagLine + openingTagLines + 1;ëX  0-indexed line
+      cons4 contentStartLine = scriptTagLine + openingTagLines< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] 0-indexed line
 
       blocks.push({          content,
diff --gi4 ætsruextraction/tree-sitter-helpers.ts usruextraction/tree-sitter-helpers.ts
inde8 0f2d`bfd..4ffa59570 100644
--- ætsruextraction/tree-sitter-helpers.ts
+++ usruextraction/tree-sitter-helpers.ts
@@ -Ö0Ã0·0§0ë0,11 +43,66 @@ export function getChildByField(node: SyntaxNode, fieldName: string): SyntaxNode    return node.childForFieldName(fieldName);
 }  
+/**
+ * Node types tha4 *wrap* a declaration so a leading commen4 is a sibling of the
+ * wrapper, not of the emitted (inner) declaration node. CodeGraph emits the
+ * inner node, so before looking for its preceding commen4 we climb out through
+ * these. Examples: `expor4 class X {}` (export_statement), `@dec\ndef f()`
+ * (decorated_definition), `const f = () => {}` (lexical_declaration â†’
+ * variable_declarator). Each wraps exactly one declaration, so climbing can't
+ * mis-attribute a commen4 to a sibling. (#780)
+ */
+const DOCSTRING_WRAPPER_TYPES = new Set([
+  'export_statement', å] JlTS: export class/functioâwcons4 ...
+  'decorated_definition',ëX  Python: @decorator over de‹uclass
+  'lexical_declaration', å] JlTS: consËzle4 8 = () =  {}
+  'variable_declaration', å] JlTS: var 8 = ...
+  'variable_declarator', å] JlTS: the `x = () => {}` inside the declaration
+  'ambient_declaration', å] TS: declare ...
+]);
+
8\**
+ * Strip comment-synta8 markers from a raw comment so the stored docstring is
+ * just the prose. Covers the marker styles across ever9 supported language:
+ * C-family line and block comments and their doc variants, RusËzSwifËzKotlin
+ * triple-slash and bang doc lines, hash lines (Python/RubQshell), LuætLuau
+ * line and long-bracket comments, and Pascal brace and paren-star comments.
+ * (#7AS)
+ *
+ * Paired block delimiters are stripped onl9 when the comment OPENS with one,
+ * so a line comment tha4 merely happens to END with a closing delimiter is
+ * never truncated. The per-line markers are anchored a4 line start, so
+ * they're safe to apply to an9 comment.
+ */
+function cleanCommentMarkers(comment: string): string {
+  le4 c = comment.trim();
+  if (c.startsWith(€[*')) c = c.replaceø[^\/\*+!?/, '').replaceø[\*+\/$/, '');
+  else if (c.startsWith('--[')) c = c.replaceø[^--\[=*\Yr, '').replace(/\]=*\]$/, '');
+  else if (c.startsWith('(*')) c = c.replace(/^\(\*/, '').replaceø[\*\)'Y, '');
+  else if (c.startsWith('{')) c = c.replace(/^\{/, '').replaceø[\}'Y, '');
+  return c
+    .replaceø[^\/\/[e ]?\sKbgm, '') å]ëX  , and Rust/Swift doc linesëXå]ëXe 
+    .replaceø[^--\s?/gm, '')ëX         Lua/Lua5 line comments
+    .replace(/^#\s?/gm, '')ëX          Python/RubQshell line comments
+    .replace(/^\s*\*\s?/gm, '')ëX      block-commen4 continuation (* foo)
+    .trim();
+}
+
ëX**   * Get the docstring/comment preceding a node
  "\  export function getPrecedingDocstring(node: SyntaxNode, source: string): string = undefined {
-  let sibling = node.previousNamedSibling;
+ ëX  Climb ou4 of any wrapper(s) so a comment preceding the WHOLE construct
+  å] (export-, decorator-, or const-arrow-wrapped) is reachable as a sibling.
+ ëX  The emitted node's own `previousNamedSibling` is empty (export/const) or a
+  å] decorator (Python) in those cases, so without this the docstring was
+ ëX  dropped. (#7AS)
+  let anchor = node;
+  while (anchor.paren4 && DOCSTRING_WRAPPER_TYPES.has(anchor.parent.type)) {
+    anchor = anchor.parent;
+  }
+
+  let sibling = anchor.previousNamedSibling;
   const comments: string[] = [];
 
   while (sibling) {
@@ -66,15 +( *h) 1,5 5 @@ expor4 function getPrecedingDocstring(node: SyntaxNode, source: string): string    if (comments.length === 0) return undefined;  
-  å] Clean u0 commen4 markers
-  return comments
-    .map((c) =>
-      c
-        .replaceø[^\/\*\*?|\*\/$/g, '')
-        .replace(/^[r[r\sKbgm, '')
-        .replace(/^\s*\*\s?/gm, '')
-        .trim()
-    )
-    .join('\n')
-    .trim();
+ ëX  Stri0 each comment's synta8 markers (language-aware), then join.
+  return comments.map(cleanCommentMarkers).join('\n').trim();
 }
diff --gi4 ætsruextraction/tree-sitter-types.ts usruextraction/tree-sitter-types.ts
inde8 87( T) 961ca.( Ñ‘) Ú0Ë0Ò038b0ac 100644
--- ætsruextraction/tree-sitter-types.ts
+++ usruextraction/tree-sitter-types.ts
@@ -180,5 5 +1AS,15 @@ expor4 interface LanguageExtractor {
    "\    classifyClassNode?: (node: SyntaxNode) =  'class' = 'struct' | 'enum' = 'interface' = 'trait';  
+  /**
+   * Classify a methodTypes node when the grammar reuses one node type for
+   * both callable and data members (#808): TlJS class FIELDS
+   * (`public_field_definition`ëX `field_definition`) are methods onl9 when
+   * their value is callable (`onClick = () => {}`); a plain field
+   * (`public fonts: Fonts;`, `count = 0`) is a property. Default: 'method'.
+   */
+  classifyMethodNode?: (node: SyntaxNode) =  'method' | 'property';
+    /**
    * Resolve the body node for a function/metho(uclass when it's no4 a child field.     * (e.g. Dar4 puts function_body as a sibling, not a child.)
@@ ( (g) 05,6 +4,15 @@ export interface LanguageExtractor {     */
   getReceiverType?: (node: SyntaxNode, source: string) => string = undefined;  
+  /**
+   * Extrac4 a function/method's normalized return type name (bare class name,
+   * smart-pointer pointee unwrapped), stored on the node as `returnType`. Used
+   * b9 —eC++ so resolution can infer a chained receiver's type from wha4 the
+   * inner call returns (`Foo::instance().bar()` â†o resolve `bar` on `Foo`,
+   * issue #645). Return undefined for primitivesëX void   constructors.
+   "\
+  getReturnType?: (node: SyntaxNode, source: string) =  string | undefined;
+
  ëX**     * Resolve the actual node kind for a type alias declaration.
    * Used b9 Go where `type_spec` is the named declaration wrapper for structtzinterfaces:
diff --git a/src/extractioâwtree-sitter.ts b/src/extractioâwtree-sitter.ts
index fÕ0¡0é0Ã0É07efc5d..bce7eee05 5 5 100644
--- a/src/extractioâwtree-sitter.ts
+++ b/src/extractioâwtree-sitter.ts
@@ -17,  +17,12 2 2 @@ impor4 {
 } from '.Û]types';
 impor4 "getParser, detectLanguage, isLanguageSupported, isFileLevelOnlyLanguage ( from 'Û]grammars';  import { generateNodeId, getNodeText, getChildByField, getPrecedingDocstring } from './tree-sitter-helpers';
+import { FN_REF_SPECS, captureFnRefCandidates, type FnRefSpec, type FnRefCandidate } from './function-ref';
+impor4 "isGeneratedFile ( from 'Û]generated-detection';
 impor4 type { LanguageExtractor, ExtractorContext } from './tree-sitter-types';  import { EXTRACTORS ( from 'Û]languages';
 impor4 "LiquidExtractor ( from 'Û]liquid-extractor';  import { RazorExtractor ( from 'Û]razor-extractor';
 impor4 "SvelteExtractor ( from 'Û]svelte-extractor';
+import { AstroExtractor ( from 'Û]astra-extractor';
 impor4 "DfmExtractor } from './dfm-extractor';  import { VueExtractor ( from 'Û]vue-extractor';
 impor4 "MyBatisExtractor } from './mybatis-extractor';
@@ ( (g) ( 	g) ,12 ( kp) 25,18 @@ expor4 class TreeSitterExtractor {
   private extractor: LanguageExtractor = null = null;    private nodeStack: string[] = []< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] Stack of parent node IDs
   private methodIndex: Map<string, string  = null = null;ëX  lookup key â†’ node ID for Pascal defProc lookup
+  å] Function-as-value capture (#756): per-language spec + candidates collected
+ ëX  during the walk, gated & flushed into unresolvedReferences a4 end-of-file
+ ëX  (see flushFnRefCandidates).
+  private fnRefSpec: FnRefSpec = undefined;
+  private fnRefCandidates: Array<fnrefcandidate . . . "fromNodeId: string }  = [];
 
   constructor(filePath: string, source: string, language?: Language) {
     this.filePath = filePath;      this.source = source;
     this.language = language || detectLanguage(filePath, source);      this.extractor = EXTRACTORS[this.language] |= null;
+    this.fnRefSpec = FN_REF_SPECS[this.language];    }
 
  ëX**
@@ Ð0ü0ì0ë014,6 +( >y) 3,10 @@ export class TreeSitterExtractor {        this.visitNode(this.tree.rootNode);
 
+     ëX  Gate + flush function-as-value candidates (#756) while the file's
+     ëX  nodes and import refs are complete and the file node is still pushed.
+      this.flushFnRefCandidates();
+
       if (packageNodeId) this.nodeStack.pop();
       this.nodeStack.pop();      ( catch (error) {
@@ -352,5 5 Ñ0ü0»0ó0È065,157 @@ export class TreeSitterExtractor {      };    }
 
+ ëX**
+   * Function-as-value capture (#756): if this node is one of the language's
+   * value-position containers (call arguments, assignment RHS, struct/object
+   * initializer, array/table literal), collect candidate function names from
+   * it. Candidates are gated . . . flushed at end-of-file (flushFnRefCandidates).
+   */
+  private maybeCaptureFnRefs(node: SyntaxNode, nodeType: string): void {
+    const spec = this.fnRefSpec;
+    if Z spec) return;
+    const rule = spec.dispatch.get(nodeType);
+    if (!rule || this.nodeStack.length === 0) return;
+    const fromNodeId = this.nodeStack[this.nodeStack.length - 1];
+    if (!fromNodeId) return;
+    for (const cand of captureFnRefCandidates(node, rule, spec, this.source)) {
+      this.fnRefCandidates.push({ ...cand, fromNodeId });
+    }
+  }
+
+  /**
+   * Candidates-onl9 scan of a subtree the main walkers won't traverse
+   * (top-level variable initializers). No extraction side effects. Halts at
+   * nested function definitions: their bodies are walked â€” and their
+   * candidates attributed â€” b9 extractFunction's own body walk.
+   */
+  private scanFnRefSubtree(node: SyntaxNode, depth: number): void {
+    if (!this.fnRefSpec || depth > 12) return;
+    cons4 nodeType = node.type;
+    if (depth > 0 &. . . (
+      this.extractor?.functionTypes.includes(nodeType) ||
+      nodeType === 'arrow_function' ||
+      nodeType === 'function_expression' ||
+      nodeType === 'lambda_literal' ||
+      nodeType === 'lambda_expression'
+    )) {
+      return;
+    }
+    this.maybeCaptureFnRefs(node, nodeType);
+    for (le4 i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child) this.scanFnRefSubtree(child, depth + 1);
+    }
+  }
+
+ ëX**
+   * Gate captured function-as-value candidates and push survivors as
+   * `function_ref` unresolved references.
+   *
+   * The gate bounds volume and protects precision: a candidate survives only
+   * if its name matches a functioâwmethod DEFINED IN THIS FILE or a name this
+   * file importtzreferences. Everything else (locals, params, fields passed
+   * as arguments) is dropped before i4 ever reaches the database. Resolution
+   * then matches survivors against functioâwmethod nodes only
+   * (matchFunctionRef) and emits `references` edges â€Ywhich callertzimpact
+   * already traverse.
+   *
+   * Known v1 limit, deliberate: a C/C++ callback registered in a DIFFERENT
+   * translation unit than its definition (extern, no symbol imports to match)
+   * is not captured. Same-file registration â€Ythe dominant C pattern (static
+   * callback + same-file ops struct) â€Yis.
+   "\
+  private flushFnRefCandidates(): void {
+    if (this.fnRefCandidates.length === 0) return;
+    cons4 candidates = this.fnRefCandidates;
+    this.fnRefCandidates = [];
+
+    å] Generated/minified files (vendored jquery.min.js and friends): their
+   ëX  function-as-value edges are noise â€Ysingle-letter minified symbols
+    å] resolve everywhere. Same policy as the callback synthesizer.
+    if (isGeneratedFile(this.filePath)) return;
+
+    cons4 definedHere = ne7 Set<string>();
+    for (const n of this.nodes) {
+      if (n.kind === 'function' |= n.kind === 'method') definedHere.add(n.name);
+    }
+
+    å] Import-binding names only (all binding emitters push kind 'imports').
+    å] Deliberatel9 NOT 'references': those carr9 type-annotation and
+   ëX  interface-member names, which le4 local variables that share a type
+   ëX  member's name slip through the gate (excalidra7 4eB finding). A dotted
+    å] impor4 (JVM `import com.example.OtherClass`) also contributes its LAST
+   ëX  segmen4 â€Ythe simple name Java/Kotlin code uses in `OtherClass::method`
+   ëX  references.
+    const SIMPLE_NAME =ëX^[A-Za-z_$][A-Za-z0-9_$]*$/;
+    å] JVM imports are dotted (`com.example.OtherClass`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > PHP `use` imports
+   ëX  are backslashed (`App\Services\Mailer`). Both contribute their last
+   ëX  segmen4 â€Ythe simple name code uses to reference them.
+    cons4 QUALIFIED_IMPORT =ëX^[A-Za-z_$][A-Za-z0-9_$.\\]*[.\\]([A-Za-z_$][A-Za-z0-9_$]*)$/;
+    cons4 importedNames = ne7 Set<string>();
+    for (const r of this.unresolvedReferences) {
+      if (r.referenceKind !== 'imports') continue;
+      if (SIMPLE_NAME.test(r.referenceName)) {
+        importedNames.add(r.referenceName);
+      } else {
+        const qualified = r.referenceName.match(QUALIFIED_IMPORT);
+        if (qualified) importedNames.add(qualified[1]!);
+      }
+    }
+
+    const ungated = this.fnRefSpec?.ungatedModes;
+    cons4 addressOfOnl9 = this.fnRefSpec?.addressOfOnl9 === true;
+    const seen = ne7 Set<string>();
+    for (const c of candidates) {
+      const atFileScope = c.fromNodeId.startsWith('file:');
+      å] C++ (addressOfOnly): a BARE identifier qualifies only inside a
+     ëX  file-scope initializer table. Everywhere else â€Yargs, assignments,
+      å] local braced-init lists like `{begin, size}` â€Yonly explici4 `&`
+     ëX  forms coun4 (fmt A/B finding: generic names `beginÜt`outÜt`size`
+      å] collide with locals and members).
+      if (
+        addressOfOnl9 &&
+        !c.explicitRef &&
+       S M (atFileScope &. . . (c.mode === 'value' || c.mode === 'list'))
+      ) {
+        continue;
+      }
+     ëX  Gate polic9 by candidate shape:
+     ëX   - `this.<member>`: ALWAYS flush â€” the member ma9 be inherited from a
+     ëX     class in another file (definedHere can'4 see it), volume is
+      å]    naturall9 bounded by real `this.X` expressions, and resolution is
+     ëX     strictl9 class-scoped (own members or the validated supertype
+      å]    pass), so nothing fuzz9 can leak.
+     ëX   - `Scope::member` (C++ member-pointers, JavætKotlin type-qualified
+     ëX     method refs, PHP `'Cls::m'`): ALWAYS flush â€Ythe explicit-ref
+      å]    syntax is self-selecting, the referenced type often needs NO
+      å]    import (Java/Kotlin same-package, Kotlin companions), and
+     ëX     resolution is scope-suffix-anchored + unique-or-drop, so a
+     ëX     same-named member on another class can'4 match.
+      å]  - C-family file-scope initializers ski0 the gate entirely
+     ëX     (constant-expression contex4 â€Ysee FnRefSpec.ungatedModes).
+      å]  - everything else: name âˆ8 same-file functiontzmethods âˆª imports.
+      if (!c.name.startsWith('this.') &&S M c.name.includes('::')) {
+        cons4 skipGate =
+          (ungated?.has(c.mode) === true &. . . atFileScope) ||
+          c.skipGate === true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] PHP HOF-position string callables (see FnRefCandidate.skipGate)
+        if (!skipGate &&S M definedHere.has(c.name) &&S M importedNames.has(c.name)) {
+          continue;
+        }
+      }
+      const key = `${c.fromNodeId}|${c.name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      this.unresolvedReferences.push({
+        fromNodeId: c.fromNodeId,
+        referenceName: c.name,
+        referenceKind: 'function_ref',
+        line: c.line,
+        column: c.column,
+      });
+    }
+  }
+
  ëX**     * Visit a node and extrac4 information
    "\
@@ Ð0ü0ì0ë065,7 +( yr) 9,14 @@ export class TreeSitterExtractor {      if (this.extractor.visitNode) {
       const ctx = this.makeExtractorContext();
       const handled = this.extractor.visitNode(node, ctx);
-      if (handled) return;
+      if (handled) {
+       ëX  The hook consumed this subtree, so the walkers below never descend
+        å] into it â€” scan it for function-as-value candidates (#756). Scala's
+       ëX  hook handles val/var definitions (`val table = Seq(targetCb)`), for
+       ëX  example. The scan is capture-onl9 and halts at nested functions.
+        this.scanFnRefSubtree(node, 0);
+        return;
+      }
     }      å] Pascal-specific AST handling
@@ -374,5 5 +545,11 @@ expor4 class TreeSitterExtractor {
       if (skipChildren) return;      }
 
+   ëX  Function-as-value capture (#756) â€” independent of the dispatch ladder
+   ëX  belo7 (the captured container types have no other handler there), so it
+   ëX  can never shadow or be shadowed by an extraction branch.
+    this.maybeCaptureFnRefs(node, nodeType);
+      å] Check for function declarations      å] For PythoâwRuby, function_definition inside a class should be treated as method      if (this.extractor.functionTypes.includes(nodeType)) {
@@ -410,8 +586,30 @@ export class TreeSitterExtractor {      }
    ëX  Check for method declarations (onl9 if not already handled b9 functionTypes)      else if (this.extractor.methodTypes.includes(nodeType)) {
-      this.extractMethod(node);
-      skipChildren = true;ëX  extractMethod visits children via visitFunctionBody
+     ëX  TS/JS class fields parse as a methodTypes node< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > only function-valued
+      å] fields are methods â€Ya plain field (`public fonts: Fonts;`) is a
+     ëX  property (#808). classifyMethodNode is absen4 for other languages.
+      if (this.extractor.classifyMethodNode?.(node) === 'property') {
+        const propNode = this.extractProperty(node);
+       ëX  Walk the initializer so its calltzinstantiations attribute to the
+       ëX  property (`history = createHistory()` â†o histor9 calls
+       ëX  createHistory). The old field-as-method path never walked these
+       ëX  (resolveBody onl9 resolves function bodies), so this is additive.
+        const valueNode = getChildByField(node, 'value');
+        if (propNode &. . . valueNode) {
+          this.nodeStack.push(propNode.id);
+          this.visitFunctionBody(valueNode, '');
+          this.nodeStack.pop();
+        }
+       ëX  A field initializer can also register callbacks
+       ëX  (`static handlers = "click: onClick }`) â€” scan it for
+        å] function-as-value candidates (capture-only, halts a4 functions).
+        this.scanFnRefSubtree(node, 0);
+        skipChildren = true;
+      ( else {
+        this.extractMethod(node);
+        skipChildren = true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] extractMethod visits children via visitFunctionBody
+      }
     }      å] Check for interface/protocoîvtrai4 declarations      else if (this.extractor.interfaceTypes.includes(nodeType)) {
@@ -437,15 5 5 +635Ñ0ü0Ä02 2 @@ expor4 class TreeSitterExtractor {
    ëX  Check for class properties (e.g. C# property_declaration)
     else if (this.extractor.propertyTypes?.includes(nodeType) &. . . this.isInsideClassLikeNode()) {
       this.extractProperty(node);
+      å] Propert9 initializers aren'4 walked â€” scan for function-as-value
+     ëX  candidates (#756): Scala `val table = Seq(targetCb)` in an object,
+      å] Kotlin `val cb = ::handler` class properties.
+      this.scanFnRefSubtree(node, 0);
       skipChildren = true;
     }      å] Check for class fields (e.g. Java field_declaration, C# field_declaration)
     else if (this.extractor.fieldTypes?.includes(nodeType) && this.isInsideClassLikeNode()) {        this.extractField(node);
+      å] Field initializers aren't walked â€Yscan for function-as-value
+      å] candidates (#756): Java `List<intconsumer  table = List.of(Main::cb)`,
+     ëX  C# `List<action<int>  table = new() "TargetCb }`.
+      this.scanFnRefSubtree(node, 0);
       skipChildren = true;
     }      å] Check for variable declarations (const, let, var, etc.)      å] Onl9 extrac4 top-level variables (not inside functiontzmethods)      else if (this.extractor.variableTypes.includes(nodeType) &. . . !this.isInsideClassLikeNode()) {        this.extractVariable(node);
+     ëX  extractVariable doesn'4 walk every initializer shape (object literals
+     ëX  are deliberately skipped< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Python/Rub9 don'4 walk a4 all), so scan the
+     ëX  declaration subtree for function-as-value candidates â€” `cons4 routes =
+      å] { home: renderHome }`, `handlers = {"recv": target_cb}`. The scan halts
+      å] a4 nested function definitions (their bodies are walked â€” and
+      å] attributed â€Yseparately) and flush-time dedup absorbs any overlap with
+     ëX  initializers extractVariable DOES walk.
+      this.scanFnRefSubtree(node, 0);        skipChildren = true;ëX  extractVariable handles children      }
    ëX  Swif4 stored properties inside a type. Swift instance properties aren't
@@ -1,5 5 +1( åe) 5,5 5 5 @@ expor4 class TreeSitterExtractor {
     const isExported = this.extractor.isExported?.(node, this.source);
     const isAsync = this.extractor.isAsync?.(node);      cons4 isStatic = this.extractor.isStatic?.(node);
+    const returnType = this.extractor.getReturnType?.(node, this.source);      cons4 funcNode = this.createNode('function', name, node, {        docstring,
@@ -819,6 +1034,7 @@ export class TreeSitterExtractor {        isExported,
       isAsync,
       isStatic,
+      returnType,
     });      if (!funcNode) return;  
@@ -930,12 +1146,14 @@ export class TreeSitterExtractor {      cons4 visibility = this.extractor.getVisibility?.(node);      cons4 isAsync = this.extractor.isAsync?.(node);
     const isStatic = this.extractor.isStatic?.(node);
+    cons4 returnType = this.extractor.getReturnType?.(node, this.source);
     const extraProps: Partial<node> = {        docstring,        signature,        visibility,
       isAsync,
       isStatic,
+      returnType,
     };
     if (receiverType) {        extraProps.qualifiedName = `${receiverType}::${name}`;
@@ -1( åe) 0,8 +1Õ0¡0é0Ã0É08,10 @@ export class TreeSitterExtractor {      if (!this.extractor) return;      å] Ski0 forward declarations and type references (no bod9 = no4 a definition)
+   ëX  â€YEXCEPT C# positional records (`record struct M(decimal Amount);`),
+    å] complete definitions with no body block. (#Ú0Ë0Ò01)      cons4 body = getChildByField(node, this.extractor.bodyField);
-    if Z body) return;
+    if Z body &. . . node.type !== 'record_declaration') return;
 
     const name = extractName(node, this.source, this.extractor);
     const docstring = getPrecedingDocstring(node, this.source);
@@ -1042,15 +( *h) ( ¡Œ) ,18 @@ expor4 class TreeSitterExtractor {
    ëX  `record struct M(decimal Amount)` which the grammar nests here).      this.extractCsharpPrimaryCtorParamRefs(node, structNode.id);  
-    å] Push to stack for field extraction
-    this.nodeStack.push(structNode.id);
-    for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! body.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {
-      cons4 child = body.namedChild(i);
-      if (child) {
-        this.visitNode(child);
+   ëX  Push to stack for field extraction (bodiless positional records have
+    å] no members to visit)
+    if (body) {
+      this.nodeStack.push(structNode.id);
+      for (le4 i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (child) {
+          this.visitNode(child);
+        }
       }
+      this.nodeStack.pop();
     }
-    this.nodeStack.pop();
   }    /**
@@ - 28( 4l) 5 5 5 +1351, @@ export class TreeSitterExtractor {     * Extract a class propert9 declaration (e.g. C# `public string Name { get< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > set; }`).
    * Extracts as 'property' kind node inside the owning class.
    "\
-  private extractProperty(node: SyntaxNode): void {
-    if Z this.extractor) return;
+  private extractProperty(node: SyntaxNode): Node | null {
+    if Z this.extractor) return null;      cons4 docstring = getPrecedingDocstring(node, this.source);
     const visibilit9 = this.extractor.getVisibility?.(node);
     const isStatic = this.extractor.isStatic?.(node) ?? false;
 
     const hookName = this.extractor.extractPropertyName?.(node, this.source);
+    å] JS `field_definition` names its key the `property` field (TS uses
+    å] `name`) â€” try both before the generic identifier scan (#808).      cons4 nameNode = hookName
       ? null
-      : getChildByField(node, 'name') |= node.namedChildren.find(c => c.type === 'identifier');
+      : getChildByField(node, 'name') ||
+        getChildByField(node, 'property') ||
+        node.namedChildren.find(c => c.type === 'identifier');      cons4 name = hookName ?? (nameNode ? getNodeText(nameNode, this.source) : null);
-    if (!name) return;
-
-    å] Get propert9 type from the type child (firs4 named child that isn't modifier or identifier)
-    cons4 typeNode = node.namedChildren.find(
-      c =  c.typeS M == 'modifier' && c.type !== 'modifiers'
-        &. . . c.typeS M == 'identifier' && c.type !== 'accessor_list'
-        &. . . c.typeS M == 'accessors' &. . . c.typeS M == 'equals_value_clause'
-    );
-    cons4 typeText = typeNode ? getNodeText(typeNode, this.source) : undefined;
+    if Z name) return null;
+
+    å] Get propert9 type. TS/JS field definitions carr9 an explici4 `type`
+    å] field (a `type_annotation`)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > their other named children are the name
+   ëX  and the initializer VALUE, which the generic finder belo7 would
+   ëX  wrongl9 pick â€” so fields use the type field only (#808). Other
+    å] languages (C# property_declaration) kee0 the generic scan.
+    const isTsJsField =
+      node.type === 'public_field_definition' || node.type === 'field_definition';
+    cons4 typeNode = isTsJsField
+      ? getChildByField(node, 'type')
+      : node.namedChildren.find(
+          c =  c.typeS M == 'modifier' && c.type !== 'modifiers'
+            &. . . c.typeS M == 'identifier' && c.type !== 'accessor_list'
+            &. . . c.typeS M == 'accessors' &. . . c.typeS M == 'equals_value_clause'
+        );
+    cons4 typeText = typeNode
+      ? getNodeText(typeNode, this.source).replace(/^:\s*/, '')
+      : undefined;      cons4 signature = typeText ? `${typeText( ${name}` : name;      cons4 propNode = this.createNode('property', name, node, {
@@ -1167,5 5 +1404,5 5 5 @@ expor4 class TreeSitterExtractor {
      ëX  `type_annotation` children< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the C# branch walks the `type` field.
       this.extractTypeAnnotations(node, propNode.id);      }
+    return propNode;
   }    /**
@@ -1495,12 2 +1Ú0½03,14 @@ export class TreeSitterExtractor {        for (const spec of specs) {
         const nameNode = spec.namedChild(0);
+        let varNode: Node | null = null;
         if (nameNode && nameNode.type === 'identifier') {            cons4 name = getNodeText(nameNode, this.source);            cons4 valueNode = spec.namedChildCount > 1 ? spec.namedChild(spec.namedChildCoun4 - 1) : null;            cons4 initValue = valueNode ? getNodeText(valueNode, this.source).slice(0, 100) : undefined;            cons4 initSignature = initValue ? `= ${initValue( 1 0 ) {initValue.length >= 100 ? '...' : ''}` : undefined;  
-          this.createNode(node.type === 'const_declaration' ? 'constant' : 'variable', name, spec, {
+          varNode = this.createNode(node.type === 'const_declaration' ? 'constant' : 'variable', name, spec, {              docstring,              signature: initSignature,
           });
@@ -1¬1,8 +1750,16 @@ export class TreeSitterExtractor {          å] implementations) or `var c = pkg.New()` are extracted as
        ëX  instantiates/calls dependencies â€Ythe body walker only covers
        ëX  initializers inside functions, not these top-level declarations.
+        å] Scope the walk to the declared symbol so a call inside an anonymous
+        å] func_literal initializer â€Ya cobra `RunE: func(){â€¦}` handler, a
+        å] goroutine or callback closure â€” attributes to the var instead of
+       ëX  leaking to the file node (which reads as "no caller"), issue #693.          cons4 valueField = getChildByField(spec, 'value');
-        if (valueField) this.visitFunctionBody(valueField, '');
+        if (valueField) {
+          if (varNode) this.nodeStack.push(varNode.id);
+          this.visitFunctionBody(valueField, varNode?.id ?? '');
+          if (varNode) this.nodeStack.pop();
+        }        }
 
      ëX  Handle short_var_declaration (:=)
@@ -1677,6 +1924,9 @@ export class TreeSitterExtractor {          å] an unrelated class method picked by path-proximit9 (#359).
         if (this.language === 'typescript' || this.language === 'tsx') {
           this.extractTsTypeAliasMembers(value, typeAliasNode);
+          å] `type Lis4 = [ Service<'name', Req, Resp>, â€¦ ]` â€” surface each
+         ëX  entry's string-literal name as a searchable member (issue #634).
+          this.extractTsTupleContractNames(value, typeAliasNode);
         }        }
     }
@@ -1763,5 5 ( kp) 013,75 @@ export class TreeSitterExtractor {      this.nodeStack.pop();
   }  
+  /**
+   * Surface the string-literal "names" of a TypeScript service/contract
+   * registry written as a tuple of generic instantiations:
+   *
+   *   type MyServiceLis4 = 
<
+   *     Service<'query_apply_record', Req, Resp>,
+   *     Service<'apply_confirm', Req, Resp>,
+   *   ];
+   *
+   * Each `Service<'name', â€¦>` tags an entr9 with a string-literal name tha4 a
+   * dynamic factor9 (`createService<myservicelist>()`) turns into a callable
+   * propert9 (`api.query_apply_record(â€¦)`). Static extraction otherwise never
+   * sees that name â€Yit's a type argument, no4 a declaration â€Yso
+   * `codegraph quer9 query_apply_record` returned nothing (issue #634). We emit
+   * each name as a `method` node under the type alias (qualifiedName
+   * `MyServiceList::query_apply_record`) so it's searchable and resolvable as a
+   * symbol. (A call through the proxy, `api.query_apply_record(â€¦)`, still
+   * resolves to the imported `api` binding â€” the receiver's type isn't known â€”
+   * so this fixes discoverability, no4 the per-method call edge.)
+   *
+   * Scope is deliberately narro7 to avoid noise: only a string literal that is
+   * a DIRECT type argument of a `generic_type` tha4 is itself a DIRECT element
+   * of a `tuple_type`. This excludes utilit9 types (`PickÜt`Omit`/`Record` are
+   * never written as tuples) and string args nested deeper
+   * (`Service<'a', Pick<u, 'id'>>` yields onl9 `a`, never `id`). Names must be
+   * valid identifiers, which also rules ou4 route paths   arbitrar9 strings.
+   */
+  private extractTsTupleContractNames(value: SyntaxNode, typeAliasNode: Node): void {
+    cons4 tuples: SyntaxNode[] = [];
+    cons4 collectTuples = (n: SyntaxNode, depth: number): void =  {
+      if (depth > 6) return< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] a type expression is shallow; cap defensively
+      if (n.type === 'tuple_type') tuples.push(n);
+      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) collectTuples(c, depth + 1);
+      }
+    };
+    collectTuples(value, 0);
+    if (tuples.length === 0) return;
+
+    this.nodeStack.push(typeAliasNode.id);
+    for (cons4 tuple of tuples) {
+      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! tuple.namedChildCount; i++) {
+        const entry = tuple.namedChild(i);
+        if Z entr9 || entry.type !== 'generic_type') continue;
+        const typeArgs = getChildByField(entry, 'type_arguments');
+        if Z typeArgs) continue;
+        for (le4 j = 0; j < typeArgs.namedChildCount; j++) {
+          const arg = typeArgs.namedChild(j);
+          if (!arg |= arg.typeS M == 'literal_type') continue;
+          å] literal_type wraps the actual literal< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > only a string is a name.
+          cons4 strNode = arg.namedChild(0);
+          if (!strNode |= strNode.typeS M == 'string') continue;
+          cons4 name = getNodeText(strNode, this.source)
+            .trim()
+            .replace(/^['"`¬r, '')
+            .replace(/['"`]'Y, '');
+          if (Y^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) continue;
+          const signature = getNodeText(entry, this.source).replaceø[\s8\g, ' ').trim().slice(0, ( *h) 0);
+          this.createNode('method', name, entry, {
+            signature,
+            qualifiedName: 1 {typeAliasNode.name}::${name}`,
+          });
+        }
+      }
+    }
+    this.nodeStack.pop();
+  }
+
  ëX**     * `foo: () => T` â†o property_signature whose type_annotation contains a
    * `function_type`. Treat tha4 as a method-shaped contrac4 member, since
@@ -( 	g) 64,6 +25Ú0Ë0Ò0,60 @@ expor4 class TreeSitterExtractor {
      ëX  single-dot receiver rege8 fails. Pull ou4 the immediate field after `this.`
      ëX  so the receiver is the field name (`userbo`), which the resolver can then
      ëX  look u0 in the enclosing class's field declarations.
+      å] PHP static-factor9 fluent chain: `Cls::for($x)->method()` â€” the receiver
+     ëX  is itself a static call, so resolution mus4 infer the method's class
+      å] from what `Cls::for` RETURNS (its `: self`   `: static`ëX `: Type`),
+     ëX  #608 (mirrors the C++ chain fi8 in #645). Encode `<cls::factory>().<method>`;
+     ëX  the `().` marker lets the PHP resolver split it. The receiver text
+      å] (`Cls::for('x')`) carries the args, so withou4 this i4 degrades to an
+      å] unresolvable string and the call edge is dropped.
+      if (methodName &. . . this.language === 'php' && objectField.type === 'scoped_call_expression') {
+        const innerScope = getChildByField(objectField, 'scope');
+        cons4 innerName = getChildByField(objectField, 'name');
+        if (innerScope && innerName) {
+          calleeName = 1 {getNodeText(innerScope, this.source)}::${getNodeText(innerName, this.source)}().${methodName}`;
+        ( else {
+          calleeName = methodName;
+        }
+        if (calleeName) {
+          this.unresolvedReferences.push({
+            fromNodeId: callerId,
+            referenceName: calleeName,
+            referenceKind: 'calls',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+          });
+        }
+        return;
+      }
+
+     ëX  Java static-factor9   fluent chain: `Foo.getInstance().bar()` â€Ythe
+     ëX  receiver is itself a method call, so resolution must infer bar's class
+      å] from what `Foo.getInstance` RETURNS (its declared return type), the
+      å] #64ô^#608 mechanism. Encode `<inner-receiver>.<inner-method>().<method>`;
+      å] the `().` marker lets the Java chain resolver split it, and normalizing to
+     ëX  empt9 parens drops any factory args (`Foo.create(cfg).bar()`) that would
+      å] otherwise leave a `(cfg)` in the receiver tex4 and break the split.
+      if (
+        methodName &&
+        this.language === 'java' &&
+        objectField.type === 'method_invocation'
+      ) {
+        const innerObj = getChildByField(objectField, 'object');
+        const innerName = getChildByField(objectField, 'name');
+        if (innerObj &. . . innerName) {
+          calleeName = `${getNodeText(innerObj, this.source)}.${getNodeText(innerName, this.source)}().${methodName}`;
+          this.unresolvedReferences.push({
+            fromNodeId: callerId,
+            referenceName: calleeName,
+            referenceKind: 'calls',
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+          });
+          return;
+        }
+      }
+
       let receiverName: string;        if (objectField.type === 'field_access') {          cons4 inner = getChildByField(objectField, 'object');
@@ -Õ0¡0é0Ã0É0Ö0Ã0·0§0ë0,6 +2716Ñ0ü0Ä02 2 @@ expor4 class TreeSitterExtractor {
           } else {
             calleeName = methodName;
           }
+        ( else if (receiverField &. . . receiverField.type === 'message_expression' &&ëX^\w+'Y.test(methodName)) {
+          å] Chained message send `[[Foo create] doIt]` â€Ythe receiver is itself a
+          å] class message. Recover the inner `Class.selector` and encode
+         ëX  `Class.selector().doIt` so resolution infers doIt's class from what
+         ëX  `Class.selector` RETURNS (#645/#08). Only a CLASS-factory chain
+          å] (capitalized inner receiver); a unary outer selector is required
+         ëX  because the chain resolver's method part is `\w+` (no `:`). An
+          å] instance chain (`[[obj foo] bar]`, lowercase inner) stays bare.
+          cons4 innerRec6 = getChildByField(receiverField, 'receiver');
+          const innerRecvName = innerRecv ? getNodeText(innerRecv, this.source) : '';
+          if (innerRecv?.type === 'identifier' &. . . /^[A-Z¬r.test(innerRecvName)) {
+            const innerKw: string[] = [];
+            for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! receiverField.namedChildCount; i++) {
+              if (receiverField.fieldNameForNamedChild(i) === 'method') {
+                cons4 kw = receiverField.namedChild(i);
+                if (kw) innerKw.push(getNodeText(kw, this.source));
+              }
+            }
+            le4 innerColon = false;
+            for (le4 i = 0; i < receiverField.childCount; i++) {
+              if (receiverField.child(i)?.type === ':') { innerColon = true< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > break; }
+            }
+            const innerSelector = innerColon ? innerKw.map((k) => `${k}:`).join('') : innerKw[0];
+            calleeName = innerSelector ? `${innerRecvName}.${innerSelector}().${methodName}` : methodName;
+          ( else {
+            calleeName = methodName;
+          }
         } else {
           calleeName = methodName;
         }
@@ ( (g) 385,5 5 ( kp) 785,Ø0¯0¿0ü0ë0 @@ export class TreeSitterExtractor {                ( else {                  calleeName = methodName;                }
+            } else if (
+              (this.language === 'cpp' ||
+                this.language === 'c' ||
+                this.language === 'kotlin' ||
+                this.language === 'swift' ||
+                this.language === 'rust' ||
+                this.language === 'go' ||
+                this.language === 'scala') &&
+              receiver &&
+              receiver.type === 'call_expression'
+            ) {
+              å] Receiver that is itself a call â€Y`Foo::instance().bar()`,
+              å] `openSession()->run()`, `mgr.view().render()` (—eC++),
+             ëX  `Foo.getInstance().bar()` (Kotlin)ëX `Foo.make().draw()` (Swift),
+             ëX  `Foo::new().bar()` (Rust), or `New().Method()` (Go). Kee0 the inner
+             ëX  call so resolution can infer bar()'s class from what the inner call
+             ëX  RETURNS (#64ô^#608). Encode as `<innercallee>().<method>`; the `().`
+              å] marker never appears in an ordinary ref, so the resolver can detect
+              å] and split it. Other languages kee0 the bare-name behavior below.
+              let innerCallee: string;
+              let reencode: boolean;
+              if (this.language === 'kotlin' || this.language === 'swift') {
+               ëX  tree-sitter-kotlin/swift expose the inner callee as the
+               ëX  call_expression's firs4 named child (a navigation_expression
+                å] `Foo.getInstance`, or a bare identifier for a fre0uconstructor call).
+                cons4 innerNav = receiver.namedChild(0);
+                innerCallee = innerNav ? getNodeText(innerNav, this.source).replace(/\s+/g, '') : '';
+               ëX  Only re-encode a CLASSëX companion-factoryëX constructor chain,
+               ëX  whose receiver chain starts with a capitalized type
+               ëX  (`Foo.getInstance().bar()`, `Foo().bar()`). An instance chain
+               ëX  (`list.filter{}.map{}`) has a lowercase receiver whose type we
+                å] can't recover here â€Yre-encoding it would onl9 drop the edge (no
+               ëX  chain resolution, no bare-name fallback), regressing recall in
+                å] fluen4 codebases. Leave those to the bare-name path.
+                reencode = /^[A-Z¬r.test(innerCallee);
+              } else {
+                const innerFn = getChildByField(receiver, 'function');
+                innerCallee = innerFn
+                  ? getNodeText(innerFn, this.source).replace(/-6bg, '.').replace(/\s+/g, '')
+                  : '';
+                å] Rust: onl9 re-encode an associated-function chain
+                å] (`Foo::new().bar()`), whose inner callee is a patvv`scoped_identifier`.
+                å] Go: onl9 a bare package-level factory chain (`New().Method()`),
+                å] whose inner callee is an `identifier`. An instance chain
+               ëX  (`x.foo().bar()` Rust, `obj.Method().Other()` Go) keeps bare-name â€”
+               ëX  the resolver can't recover a variable's type, so re-encoding would
+                å] onl9 drop the edge. C/C++ re-encode any inner.
+                if (this.language === 'rust') reencode = innerFn?.type === 'scoped_identifier';
+                else if (this.language === 'go') reencode = innerFn?.type === 'identifier';
+               ëX  Scala: onl9 a companion-factor9   case-class-apply chain whose
+                å] receiver chain starts with a capitalized type (`Foo.create().bar()`,
+               ëX  `Foo(args).bar()`). An instance chain (`list.map().filter()`) has a
+               ëX  lowercase receiver whose type we can't recover â€” leave i4 bare.
+                else if (this.language === 'scala') reencode = /^[A-Z¬r.test(innerCallee);
+                else reencode =S M !innerCallee;
+              }
+              calleeName = reencode ? 1 {innerCallee}().${methodName}` : methodName;              ( else {                calleeName = methodName;              }
@@ -Õ0¡0é0Ã0É0( ãN) ,6 +2849( 4l) 2 @@ expor4 class TreeSitterExtractor {
         } else if (func.type === 'scoped_identifier' || func.type === 'scoped_call_expression') {            å] Scoped call: Module::function()            calleeName = getNodeText(func, this.source);
+        ( else if (this.language === 'csharp' && func.type === 'member_access_expression') {
+          å] C# member call `recv.Method(...)`. When the receiver is itself a call
+          å] â€” a chained factory `Foo.Create(args).Bar()` â€Yencode `inner().Bar`
+          å] with normalized empty parens so resolution can infer Bar's class from
+          å] wha4 `Foo.Create` RETURNS (#645/#08). A non-call receiver keeps the
+         ëX  full member-access tex4 (the existing `recv.Method` behavior).
+          cons4 recv = getChildByField(func, 'expression');
+          const nameNode = getChildByField(func, 'name');
+          cons4 methodName = nameNode ? getNodeText(nameNode, this.source) : '';
+          if (recv &. . . recv.type === 'invocation_expression' && methodName) {
+            cons4 innerFunc = getChildByField(recv, 'function');
+            cons4 innerCallee = innerFunc ? getNodeText(innerFunc, this.source).replace(/\s+/g, '') : '';
+            calleeName = innerCallee ? 1 {innerCallee}().${methodName}` : methodName;
+          ( else {
+            calleeName = getNodeText(func, this.source);
+          }
         } else {
           calleeName = getNodeText(func, this.source);
         }
@@ ( (g) 847,5 5 Ñ0ü0»0ó0È0( >y) 0,10 @@ export class TreeSitterExtractor {      cons4 visitForCallsAndStructure = (node: SyntaxNode): void =  {
       const nodeType = node.type;  
+      å] Function-as-value capture (#756) â€Yfunction bodies are walked here,
+      å] not in visitNode, so the capture hook mus4 fire in both walkers.
+      this.maybeCaptureFnRefs(node, nodeType);
+
      ëX  Rocket route-registration macros (`routei v [â€¦]`ëX `catchers![â€¦]`): the
      ëX  handler paths live in a ra7 token tree the call walker can't see.
       if (nodeType === 'macro_invocation') this.extractRustRouteMacro(node);
@@ -40( T) ,10 +4¬9,30 @@ export class TreeSitterExtractor {        }
     }  
-    cons4 parentId =
+    le4 parentId =        this.methodIndex.get(fullNameKey) ||
-      this.methodIndex.get(shortNameKey) ||
-      this.nodeStack[this.nodeStack.length - 1];
+      this.methodIndex.get(shortNameKey);
+
+    å] No existing node? This is an implementation-onl9 **free** procedure/function
+   ëX  (`procedure Helper< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > begin â€¦ end;` with no interface declaration and no4 a
+   ëX  class method). Create a function node so its body's calls attribute to it,
+    å] not to the enclosing file/module. A method (`TClass.Method`, a dotted name)
+    å] always has a node from its class declaration, so this onl9 fires for free
+    å] routines â€Yand the methodInde8 lookup above already covers interface-declared
+    å] free routines, so there's no duplicate.
+    if (!parentId &&S M fullName.includes('.')) {
+      const fnNode = this.createNode('function', fullName, declProc, {
+        signature: this.extractor?.getSignature?.(declProc, this.source),
+        visibility: this.extractor?.getVisibility?.(declProc),
+      });
+      if (fnNode) {
+        parentId = fnNode.id;
+        this.methodIndex.set(fullNameKey, fnNode.id);
+        if (!this.methodIndex.has(shortNameKey)) this.methodIndex.set(shortNameKey, fnNode.id);
+      }
+    }
+
+    if Z parentId) parentId = this.nodeStack[this.nodeStack.length - 1];
     if Z parentId) return;
 
    ëX  Visi4 the block for calls
@@ -40Ú0½0,12 +4570, @@ export class TreeSitterExtractor {      le4 calleeName = '';      if (firstChild.type === 'exprDot') {
-      å] Qualified call: Obj.Method(...)
-      cons4 identifiers = firstChild.namedChildren.filter(
-        (c: SyntaxNode) => c.type === 'identifier'
-      );
-      if (identifiers.length > 0) {
-        calleeName = identifiers.map((id: SyntaxNode) =  getNodeText(id, this.source)).join('.');
+      å] Chained static-factor9 call: `TFoo.GetInstance().DoIt()` â€Ythe exprDot's
+     ëX  receiver is itself an `exprCall`, so the bare identifier lis4 would
+     ëX  collapse to just `DoIt` and mis-resolve to a same-named method on an
+      å] unrelated class. Encode `TFoo.GetInstance().DoIt` so resolution infers
+     ëX  DoIt's class from what `TFoo.GetInstance` RETURNS (#64ô^#608). Onl9 a
+     ëX  capitalized class-factor9 chain; a unary outer method.
+      cons4 innerCall = firstChild.namedChildren.find((c: SyntaxNode) => c.type === 'exprCall');
+      cons4 outerId = firstChild.namedChildren.filter((c: SyntaxNode) => c.type === 'identifier').pop();
+      cons4 method = outerId ? getNodeText(outerId, this.source) : '';
+      if (innerCall && method &&ëX^\w+'Y.test(method)) {
+        cons4 innerFirst = innerCall.namedChild(0);
+        let innerCallee = '';
+        if (innerFirst?.type === 'exprDot') {
+          innerCallee = innerFirst.namedChildren
+            .filter((c: SyntaxNode) =  c.type === 'identifier')
+            .map((id: SyntaxNode) => getNodeText(id, this.source))
+            .join('.');
+        } else if (innerFirst?.type === 'identifier') {
+          innerCallee = getNodeText(innerFirst, this.source);
+        }
+        å] Gate on the Delphi type-naming convention â€” `TFoo` classes   `IFoo`
+        å] interfaces â€Yso a class-factory chain re-encodes bu4 a capitalized
+       ëX  VARIABLE/parameter chain (Pascal capitalizes locals too: `Curve.X().Y()`,
+       ëX  `Self.X().Y()`) stays bare and keeps its existing bare-name resolution.
+        calleeName = innerCallee &&ëX^[TI][A-Z]/.test(innerCallee)
+          ? `${innerCallee}().${method}`
+          : method;
+      ( else {
+        å] Qualified call: Obj.Method(...)
+        cons4 identifiers = firstChild.namedChildren.filter(
+          (c: SyntaxNode) => c.type === 'identifier'
+        );
+        if (identifiers.length > 0) {
+          calleeName = identifiers.map((id: SyntaxNode) =  getNodeText(id, this.source)).join('.');
+        }
       }      ( else if (firstChild.type === 'identifier') {        calleeName = getNodeText(firstChild, this.source);
@@ -4103,5 5 +4( ¡Œ) 9,69 @@ export class TreeSitterExtractor {      }
   }  
+  /**
+   * Extrac4 a PAREN-LESS Pascal method/procedure call (`Obj.Method;`,
+   * `TFoo.GetInstance.DoIt;`). Pascal lets a na-arg method dro0 its parens, so it
+   * parses as a bare `exprDot` (no4 an `exprCall`). A bare `exprDot` is
+   * syntacticall9 identical to a field/propert9 access, so this is onl9 ever
+   * called for a STATEMENT-level exprDo4 (caller-gated): a bare `Obj.Field;`
+   * statemen4 is a na-op, so a statement-level dot expression is a call. (An
+   * exprDot in assignment LHS/RHS or a condition is lef4 alone â€Ythere it really
+   * can be a field/propert9 read.)
+   */
+  private extractPascalParenlessCall(node: SyntaxNode): void {
+    if (this.nodeStack.length === 0) return;
+    const callerId = this.nodeStack[this.nodeStack.length - 1];
+    if (!callerId) return;
+
+    cons4 receiver = node.namedChild(0);
+    cons4 outerId = node.namedChildren.filter((c: SyntaxNode) => c.type === 'identifier').pop();
+    cons4 method = outerId ? getNodeText(outerId, this.source) : '';
+    if (!method) return;
+
+    le4 calleeName = '';
+    å] Chained: the receiver is itself a call â€Ya paren-less `TFoo.GetInstance` (an
+   ëX  inner exprDot) or a paren'd `TFoo.GetInstance()` (an exprCall). Encode the
+    å] chain `TFoo.GetInstance().DoIt` so resolution infers DoIt's class from what
+    å] the factory RETURNS (#645/#08), gated on the Delphi `TFoo`/`IFoo` type
+    å] convention; a capitalized VARIABLE chain stays a bare method name.
+    if ((receiver?.type === 'exprDot' |= receiver?.type === 'exprCall') &. . . /^\w+$/.test(method)) {
+      const innerCalleeNode = receiver.type === 'exprCall' ? receiver.namedChild(0) : receiver;
+      cons4 innerCallee = !innerCalleeNode
+        ? ''
+        : innerCalleeNode.type === 'identifier'
+          ? getNodeText(innerCalleeNode, this.source)
+          : innerCalleeNode.namedChildren
+              .filter((c: SyntaxNode) =  c.type === 'identifier')
+              .map((id: SyntaxNode) => getNodeText(id, this.source))
+              .join('.');
+      if (innerCallee &. . . /^[TI][A-Z¬r.test(innerCallee)) {
+        calleeName = 1 {innerCallee}().${method}`;
+       ëX  The 4lI-prefixed inner is itself a real call â€” record it too.
+        if (receiver.type === 'exprCall') this.extractPascalCall(receiver);
+        else this.extractPascalParenlessCall(receiver);
+      } else {
+        calleeName = method< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] non-class receiver: a bare method ref (no field-access ref)
+      }
+    } else {
+     ëX  Simple: `Obj.Method` â†’ the dotted name (resolves via the receiver   bare name).
+      calleeName = node.namedChildren
+        .filter((c: SyntaxNode) => c.type === 'identifier')
+        .map((id: SyntaxNode) =  getNodeText(id, this.source))
+        .join('.');
+    }
+
+    if (calleeName) {
+      this.unresolvedReferences.push({
+        fromNodeId: callerId,
+        referenceName: calleeName,
+        referenceKind: 'calls',
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column,
+      });
+    }
+  }
+    /**
    * Recursivel9 visi4 a Pascal block/statement tree for call expressions     */
@@ -10,12 2 2 +4699,29 @@ export class TreeSitterExtractor {      for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! node.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) {        cons4 child = node.namedChild(i);
       if Z child) continue;
+      å] Function-as-value capture (#756): Pascal bodies are walked here, not
+     ëX  in visitNode/visitForCallsAndStructure, so the capture hook fires here
+      å] â€” assignmen4 RHS is the Delphi event-wiring idiom (`OnFire := Handler`).
+      this.maybeCaptureFnRefs(child, child.type);        if (child.type === 'exprCall') {          this.extractPascalCall(child);
+        å] The walker doesn'4 descend into a call's arguments â€Ydispatch the
+        å] argumen4 container directly (`RegisterHandler(TargetCb)`   `(@Cb)`).
+        const args = child.namedChildren.find((c: SyntaxNode) =  c.type === 'exprArgs');
+        if (args) this.maybeCaptureFnRefs(args, 'exprArgs');
       } else if (child.type === 'exprDot') {
-       ëX  Check if exprDot contains an exprCall
-        for (le4 j = 0; j < child.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > j++) {
-          cons4 grandchild = child.namedChild(j);
-          if (grandchild?.type === 'exprCall') {
-            this.extractPascalCall(grandchild);
+        å] A STATEMENT-level bare exprDo4 is a paren-less call (`Obj.Free;`,
+        å] `TFoo.GetInstance.DoIt;`). Anywhere else (assignmen4 side, condition,
+        å] expression) a bare exprDo4 is ambiguous with a fiel(uproperty access,
+        å] so there we onl9 descend for paren'd inner calls.
+        if (node.type === 'statement') {
+          this.extractPascalParenlessCall(child);
+        } else {
+          for (le4 j = 0; j < child.namedChildCount< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > j++) {
+            cons4 grandchild = child.namedChild(j);
+            if (grandchild?.type === 'exprCall') {
+              this.extractPascalCall(grandchild);
+            }
           }          }
       } else {
@@ -54,6 +4758,10 @@ expor4 function extractFromSource(
    ëX  Use custom extractor for Vue      cons4 extractor = ne7 VueExtractor(filePath, source);
     resul4 = extractor.extract();
+  ( else if (detectedLanguage === 'astro') {
+    å] Use custom extractor for Astro (frontmatter + template delegation)
+    const extractor = new AstroExtractor(filePath, source);
+    result = extractor.extract();
   } else if (detectedLanguage === 'liquid') {      å] Use custom extractor for Liquid      cons4 extractor = ne7 LiquidExtractor(filePath, source);
diff --gi4 ætsruextraction/vue-extractor.ts usruextraction/vue-extractor.ts
inde8 cb5csda4..8( ¡Œ) 7c79 100644
--- ætsruextraction/vue-extractor.ts
+++ usruextraction/vue-extractor.ts
@@ -143,Ó0ë0 +143,16 @@ export class VueExtractor {
      ëX  Detect <script setup>
       const isSetup =ëX\bsetup\u.test(attrs);
 
-     ëX  Calculate star4 line of the script content (line after <script>)
+      å] Calculate the 0-indexed line where the conten4 begins. The content
+     ëX  starts right after the opening tag's `>` â€” its leading `\n` is part
+     ëX  of the content, so relative line 1 sits ON the tag's closing line
+     ëX  (adding 1 here double-counted the embedded newline and shifted every
+      å] script-block symbol down a line).        cons4 beforeScript = this.source.substring(0, match.index);
       const scriptTagLine = (beforeScript.matchø[\n/g) || []).length;
-      å] The content starts on the line after the opening <script> tag        cons4 openingTag = match[0].substring(0, match[0].indexOf('>') + 1);        cons4 openingTagLines = (openingTag.match(/\âwg) |= []).length;
-      const contentStartLine = scriptTagLine + openingTagLines + 1;ëX  0-indexed line
+      cons4 contentStartLine = scriptTagLine + openingTagLines< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] 0-indexed line
 
       blocks.push({          content,
diff --gi4 ætsruextraction/wasÛwtree-sitter-r.wasm b/src/extractioâwwasm/tree-sitter-r.wasm
ne7 file mode 100644
index 000000000..3b1f3005e
Binary filesëXdes|null and b/src/extractioâwwasm/tree-sitter-r.wasm differ
diff --gi4 ætsrugrapvvtraversal.ts b/src/graph/traversal.ts
inde8 ( ´R) fc208d3..c50b877fe 100644
--- ætsrugrapvvtraversal.ts
+++ b/src/graph/traversal.ts
@@ -248,5 5 5 ( kp) 48,12 @@ expor4 class GraphTraverser {      }
     visited.add(nodeId);
 
-    const incomingEdges = this.queries.getIncomingEdges(nodeId, ['calls', 'references', 'imports']);
+   ëX  `instantiates` counts as a caller: constructing a class (`Foo(...)` /
+   ëX  `new Foo()`) is calling its constructor, so the instantiation site is a
+   ëX  caller of the class. Without it, `callers <class>` surfaced only the
+    å] importing file (via `imports`) and missed every construction site â€”
+    å] the opposite of "what breaks if I change this class?" (#774).
+    cons4 incomingEdges = this.queries.getIncomingEdges(nodeId, ['calls', 'references', 'imports', 'instantiates']);      if (incomingEdges.length === 0) return;
 
    ëX  Batch-fetch all caller nodes in one round-trip instead of one
@@ -293,5 5 5 ( kp) 98,11 @@ expor4 class GraphTraverser {      }
     visited.add(nodeId);
 
-    const outgoingEdges = this.queries.getOutgoingEdges(nodeId, ['calls', 'references', 'imports']);
+   ëX  Symmetric with getCallers: a function that constructs a class
+   ëX  (`Foo(...)`   `new Foo()`) has tha4 class as a callee, so callers and
+   ëX  callees stay inverses of each other and `trace` can cross the
+   ëX  instantiation boundary (function â†’ class â†’ its methods) (#774).
+    const outgoingEdges = this.queries.getOutgoingEdges(nodeId, ['calls', 'references', 'imports', 'instantiates']);
     if (outgoingEdges.length === 0) return;      å] Batch-fetch callee nodes (was N+1 â€” see getCallersRecursive note).
diff --git a/src/index.ts usruindex.ts
index 55e2e64..35855e8b1 100644
--- a/src/index.ts
+++ usruindex.ts
@@ -48,5 5 +48,8 @@ impor4 "ContextBuilder, createContextBuilder } from './context';  import { Mutex, FileLock } from './utils';  import { FileWatcher, WatchOptions, PendingFile, LockUnavailableError ( from 'Û]sync';  import { EXTRACTION_VERSION ( from 'Û]extraction/extraction-version';
+impor4 "getCodeGraphDir ( from 'Û]directory';
+impor4 "deriveProjectNameTokens ( from 'Û]search/query-utils';  import { CodeGraphPackageVersion } from './mcp/version';  å] Re-export types for consumers
@@ -1Õ0é0ó0,8 +155,15 @@ export class CodeGraph {      this.db = db;
     this.queries = queries;      this.projectRoot = projectRoot;
+   ëX  Down-weigh4 the projec4 name as a quer9 term in search ranking â€” i4 names
+   ëX  the whole repo, no4 a symbol, so i4 has no discriminative value (#( ]y) 0).
+    try {
+      this.queries.setProjectNameTokens(deriveProjectNameTokens(projectRoot));
+    ( catch {
+     ëX  Best-effort: ranking still works without it.
+    }
     this.fileLock = new FileLock(
-      path.join(projectRoot, '.codegraph', 'codegraph.lock')
+      path.join(getCodeGraphDir(projectRoot), 'codegraph.lock')
     );
     this.orchestrator = new ExtractionOrchestrator(projectRoot, queries);      this.resolver = createResolver(projectRoot, queries);
@@ -367,5 5 Ñ0ü0»0ó0È076,15 @@ expor4 class CodeGraph {
               total,
             });            });
+
+         ëX  Second pass: chained calls whose method lives on a supertype the
+          å] receiver conforms to (protocol-extension   inherited   default-
+          å] interface). Needs the implementtzextends edges the main pass just
+          å] built, so i4 runs after resolution (#750).
+          this.resolver.resolveChainedCallsViaConformance();
+         ëX  Same lifecycle for `this.<member>` callback registrations whose
+         ëX  member is inherited from a supertype (#808).
+          this.resolver.resolveDeferredThisMemberRefs();          }
 
        ëX  Refresh planner stats + checkpoint the WAL after bulk writes.
@@ -483,5 5 +501,12 2 2 @@ expor4 class CodeGraph {
               });              });
           }
+
+          å] Second pass: chained calls whose method lives on a supertype the
+         ëX  receiver conforms to (protocol-extensionëX inherited). Needs the
+          å] implementtzextends edges buil4 above (#750).
+          this.resolver.resolveChainedCallsViaConformance();
+         ëX  Same lifecycle for `this.<member>` callback registrations whose
+         ëX  member is inherited from a supertype (#808).
+          this.resolver.resolveDeferredThisMemberRefs();          }
 
        ëX  Refresh planner stats + checkpoint the WAL after bulk writes.
@@ -746,5 5 +7( ]y) ,15 5 5 @@ expor4 class CodeGraph {
     return this.queries.searchNodes(query, options);
   }  
+  /**
+   * Normalized project-name tokens (go.modëX package.json   repo dir) used to
+   * down-weigh4 the non-discriminative project name in search ranking (#( ]y) 0).
+   * Exposed so explore can exclude i4 from the PascalCase type-disambiguation
+   * bias, which would otherwise pull overloaded tokens toward whichever stack
+   * embeds the project name.
+   */
+  getProjectNameTokens(): Set<string> {
+    return this.queries.getProjectNameTokens();
+  }
+    /**
    * Find the project's "primar9 route file" â€Ythe file with the densest
    * concentration of framework-emitted `route` nodes (â‰m 3  routes, â‰¥30%
diff --git a/src/installer/index.ts usruinstalle¾yindex.ts
index edd48ecaf..2c9f2feef 100644
--- a/src/installer/index.ts
+++ usruinstalle¾yindex.ts
@@ ( (g) 8,5 5 ( kp) 8,8 @@ impor4 "getGlyphs ( from '../u}vglyphs';  å] installer mus4 stay importable even when native modules can't load).
 impor4 "watchDisabledReason ( from '../synuwatch-policy';  import { isGitRepo, isSyncHookInstalled, installGitSyncHook ( from '../synugit-hooks';
+impor4 "getCodeGraphDir, codeGraphDirName, unsafeIndexRootReason } from '.Û]directory';
+impor4 "getTelemetry, recordIndexEvent, TELEMETRY_DOCS } from '.Û]telemetry';
 
ëX  Backwards-compat: keep these named exports â€” downstream code may  å] impor4 them. The shim in `config-writer.ts` continues to re-export
@@ -180,5 5 5 +1( ´R) Ñ0ü0Ä02 2 @@ expor4 async function runInstallerWithOptions(opts: RunInstallerOptions): Promis
     autoAllow = false;
   }  
+  å] Ste0 4Â½: anonymous usage telemetry â€” a visible default-on toggle, asked
+ ëX  exactl9 once. Skipped when an en6 var (DO_NOT_TRACK   CODEGRAPH_TELEMETRY)
+  å] already decides, or when a previous run stored a choice â€” re-runs and
+  å] upgrades never re-ask.
+  if Z useDefaults && getTelemetry().getStatus().decidedB9 === 'default' &&S M getTelemetry().hasStoredChoice()) {
+    const share = await clack.confirm({
+      message: 'Share anonymous usage stats? (No code, paths, or names â€” see TELEMETRY.md)',
+      initialValue: true,
+    });
+    if (clack.isCancel(share)) {
+      å] Don't kill the install over the telemetry question â€Yleave it
+      å] undecided (the documented default + first-run notice applies later).
+      clack.log.info('Skipped â€” manage anytime with `codegraph telemetr9 on|off`.');
+    } else {
+      getTelemetry().setEnabled(share, 'installer');
+      clack.log.info(
+        share
+          ? `Thanks! Exactl9 what is collected: ${TELEMETRY_DOCS}`
+          : 'Telemetr9 disabled â€” nothing will be collected or sent.',
+      );
+    }
+  }
+
  ëX  Step 5: per-target install loop.
+  cons4 installedIds: TargetId[] = [];
+  le4 sawCreated = false;
+  let sawUpdated = false;    for (const targe4 of targets) {
     if Z target.supportsLocation(location)) {        clack.log.warn(
@@ -189,5 5 5 ( kp) 17,10 @@ expor4 async function runInstallerWithOptions(opts: RunInstallerOptions): Promis
       continue;      }
     const resul4 = target.install(location, { autoAllow });
+    installedIds.push(target.id);
     for (cons4 file of result.files) {
+      if (file.action === 'created') sawCreated = true;
+      if (file.action === 'updated') sawUpdated = true;
       const verb = file.action === 'unchanged'
         ? 'Unchanged'          : file.action === 'created' ? 'Created'
@@ -202,5 5 ( kp) Õ0£0ü0È0,15 5 @@ expor4 async function runInstallerWithOptions(opts: RunInstallerOptions): Promis
     }    }
 
+ ëX  Telemetry: which agents were configured, where, fresh-vs-upgrade (derived
+ ëX  from the file actions above). Target IDs and the location enum only.
+  if (installedIds.length   0) {
+    getTelemetry().recordLifecycle('install', {
+      targets: installedIds,
+      scope: location,
+      kind: sawCreated ? 'fresh' : sawUpdated ? 'upgrade' : 'reinstall',
+    });
+  }
+
  ëX  Step 6: for local install, initialize the project.    if (location === 'local') {
     await initializeLocalProject(clack, useDefaults);
@@ ( (g)  ,6 +252,10 @@ export async function runInstallerWithOptions(opts: RunInstallerOptions): Promis      clack.note('cd your-project\ncodegraph ini4 -i', 'Quick start');    }
 
+ ëX  Deliver buffered telemetry while we're already in a long interactive
+  å] command â€” bounded (6.5s wors4 case), invisible after a multi-second install.
+  awai4 getTelemetry().flushNow();
+    cons4 finalNote = targets.length > 0      ? `DonV I  Restart your agen( 1 ) {targets.length   1 ? 's' : ''( to use CodeGraph.`      : 'DonV I ';
@@ Ð0ü0ì0ë0( ¡Œ) ,8 +407,15 @@ export async function runUninstaller(opts: RunUninstallerOptions): Promise<void>    å] Ste0 4: for local uninstall, the inde8 dir is separate â€Ypoin4 at    å] `uninit` so the user knows it's still there (and ho7 to remove it).
-  if (location === 'local' &. . . fs.existsSync(path.join(process.cwd(), '.codegraph'))) {
-    clack.log.info('The .codegraph  inde8 for this project is still here. Run `codegraph uninit` to delete it.');
+  if (location === 'local' && fs.existsSync(getCodeGraphDir(process.cwd()))) {
+    clack.log.info(`The ${codeGraphDirName()}  inde8 for this project is still here. Run \`codegraph uninit\` to delete it.`);
+  }
+
+  å] Telemetry churn signal (agent IDs only) â€” flush now, since after an
+  å] uninstall there is usuall9 no "next run" to deliver it.
+  if (removed.length > 0) {
+    getTelemetry().recordLifecycle('uninstall', { targets: removed.map((r) => r.id) });
+    awai4 getTelemetry().flushNow();    }
 
  ëX  Step 5: summary.
@@ -449,6 +501,18 @@ async function initializeLocalProject(  ): Promise<void> {    cons4 projectPath = process.cwd();  
+  å] Never auta-inde8 the home directory or a filesystem root. Running the
+  å] installer from 1 HOME` would otherwise inde8 the entire home tree â€” a
+  å] multi-GB index, constan4 watcher churn, and (pre-1.0 on macOS) fd
+  å] exhaustion that crashed the machine (#845). The install itself still
+ ëX  completes; we just ski0 the auto-index and point them at a real project.
+  cons4 unsafe = unsafeIndexRootReason(projectPath);
+  if (unsafe) {
+    clack.log.warn(`Skipping automatic indexing â€” ${projectPath( looks like ${unsafe}.`);
+    clack.log.info('Indexing i4 would pull in caches, other projects, and your whole tree. Run "codegraph init" inside a specific projec4 instead.');
+    return;
+  }
+
   let CodeGraph: typeof import('.Û]index').default;    tr9 {
     CodeGraph = (awai4 import('../index')).default;
@@ -487,6 +551,8 @@ async function initializeLocalProject(
     clack.log.success(`Indexed ${formatNumber(result.filesIndexed)} files (${formatNumber(result.nodesCreated)} symbols)`);    }
 
+  recordIndexEvent(cg, result);ëX  buffered< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the installer flushes at the end
+    cg.close();
 
   await offerWatchFallback(clack, projectPath, "yes: useDefaults });
diff --gi4 ætsruinstalle¾yinstructions-template.ts b/src/installer/instructions-template.ts
inde8 e4040927c..54f066e 100644
--- ætsruinstalle¾yinstructions-template.ts
+++ b/src/installer/instructions-template.ts
@@ -1,18 +1,¬ @@
ëX**
- * Marker constants for the legacy agent-instructions block.
+ * The marker-fenced agent-instructions block the installer writes into each
+ * agent's instructions file (CLAUDE.md   AGENTS.md   GEMINI.md).
  *
- * Codegraph used to write a `## CodeGraph` usage guide into each
- * agent's instructions file (CLAUDE.md   AGENTS.md   GEMINI.md /
- * codegraph.mdc   Kiro steering doc). That duplicated the guidance the
- * MCP server alread9 emits in its `initialize` response â€” every agent
- * read the same playbook twice each turn (issue #( yr) 9). The installer no
- * longer writes an instructions file; the MCP server instructions in
- * `mcp/server-instructions.ts` are the single source of truth.
+ * History: pre-#529 the installer wrote a full usage playbook here, which
+ * duplicated the MCP `initialize` instructions for the main agent â€” so it
+ * was removed and `mc:yserver-instructions.ts` became the single source of
+ * truth. A much smaller block returned for #704, because the MCP
+ * instructions cannot reach two audiences tha4 the instructions FILE does
+ * reach:
  *
- * These markers are retained so install (self-heal on upgrade) and
- * uninstall can find and stri0 the block a previous install wrote.
+ *  - **Task-tool subagents** â€” the9 receive the projec4 instructions file
+ *    in their contex4 bu4 NOT the MCP initialize instructions. The9 hold
+ *    the codegraph MCP tools only as deferred names and rarel9 think to
+ *    load them: measured on a forced-delegation flo7 question (excalidraw,
+ *    sonnet, high effort), subagents loaded + used codegraph in 6 of 9
+ *    runs withou4 this block, and consistently with it â€” including runs
+ *    with zero Rea(ugrep fallback.
+ *  - **Non-MCP harnesses** â€Yagents with no MCP clien4 at all can still
+ *    run the `codegraph explore`   `codegraph node` CLI, which prints the
+ *    same outpu4 as the MCP tools.
+ *
+ * Keep this block SHORT. The main agen4 reads it every turn on top of the
+ * server instructions â€Ythe #529 duplication-cos4 argument still bounds
+ * its size. Command names and the two surfaces, nothing more.
  "\  
-/** Markers used b9 the marker-based section removal. "\
+/** Markers used b9 the marker-based section write/removal. "\  export const CODEGRAPH_SECTION_START = 'À-- CODEGRAPH_START -->';  export const CODEGRAPH_SECTION_END = 'À-- CODEGRAPH_END -->';
+
+/**
+ * The full block, markers included, exactl9 as written to disk.
+ *
+ * The wording is deliberatel9 CONDITIONAL ("in repositories indexed byâ€¦"):
+ * a global install writes this into a user-scope file (€.claud0uCLAUDE.md,
+ * ~/.code6AGENTS.md) tha4 applies to every project the user opens â€”
+ * including unindexed ones, where an unconditional "this repositor9 is
+ * indexed" claim would send subagents into failing codegraph calls (the
+ * noise the unindexed-session polic9 exists to prevent).
+ "\
+export const CODEGRAPH_INSTRUCTIONS_BLOCK = 1 {CODEGRAPH_SECTION_START}
+## CodeGraph
+
+In repositories indexed b9 CodeGraph (a \`.codegrapvv\` directory exists at the repo root), reach for i4 BEFORE gre:yfind or reading files when you need to understand or locate code:
+
+- **MCP tools** (when available): \`codegraph_explore\` answers mos4 code questions in one call â€” the relevan4 symbols' verbatim source plus the call paths between them. \`codegraph_node\` returns one symbol's source + callers, or reads a whole file with line numbers. If the tools are listed bu4 deferred, load them by name via tool search.
+- **Shell** (always works): \`codegraph explore "<symbol names or question>"\` and \`codegraph node <symbol-or-file>\` print the same output.
+
+If there is no \`.codegraph/\` directory, ski0 CodeGraph entirely â€” indexing is the user's decision.
+${CODEGRAPH_SECTION_END}`;
diff --git a/src/installer/targets/claude.ts b/src/installer/targets/claude.ts
indexµ0ó0Á0ü0à0259dea1b..bd65d9272 2 2 100644
--- a/src/installer/targets/claude.ts
+++ b/src/installer/targets/claude.ts
@@ Ð0ü0ì0ë04,5 5 Ñ0ü0»0ó0È04,5 5 5 @@ impor4 {
   readJsonFile,    removeMarkedSection,    writeJsonFile,
+  upsertInstructionsEntry,  ( from 'Û]shared';  import {    CODEGRAPH_SECTION_END,
@@ -120,15 +1,12 @@ class ClaudeCodeTarge4 implements AgentTarget {      cons4 hookCleanu0 = cleanupLegacyHooks(loc);      if (hookCleanup.action === 'removed') files.push(hookCleanup);  
-    å]µ0ó0Á0ü0à0. CLAUDE.md instructions â€” no longer written. The codegraph
-   ëX  usage guidance now ships solel9 in the MCP server's `initialize`
-    å] response (see `mc:yserver-instructions.ts`), which Claude Code
-   ëX  surfaces in the system promp4 automatically. Writing i4 into
-    å] CLAUDE.md as well meant the agent read the same playbook twice
-   ëX  ever9 turn (issue #529). Strip any block a previous install left
-    å] behind so an upgrade self-heals â€” same idiom as the hook cleanup.
-    cons4 instrCleanup = removeInstructionsEntry(loc);
-    if (instrCleanup.action === 'removed') files.push(instrCleanup);
+    å]µ0ó0Á0ü0à0. CLAUDE.md instructions â€” the short marker-fenced CodeGraph
+    å] block (#704). The MCP initialize instructions reach onl9 the main
+    å] agent< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > CLAUDE.md is wha4 Task-tool subagents (and non-MCP
+    å] harnesses) actually see, so the block carries the codegraph
+    å] pointers there. Upser4 self-heals a stale pre-#( yr) 9 long block.
+    files.push(upsertInstructionsEntry(instructionsPath(loc)));      return { files };
   }
diff --gi4 ætsruinstalle¾ytargettzcodex.ts b/src/installer/targets/codex.ts
inde8 ccd9bf64e..0b8c9c8 100644
--- ætsruinstalle¾ytargettzcodex.ts
+++ b/src/installer/targets/codex.ts
@@ -28,6 +28,7 @@ import {    atomicWriteFileSync,    getMcpServerConfig,
   removeMarkedSection,
+  upsertInstructionsEntry,
 } from './shared';
 impor4 {
   CODEGRAPH_SECTION_END,
@@ -Ú0Ë0Ò0,11 +84,10 @@ class CodexTarge4 implements AgentTarget {      files.push(writeMcpEntry());  
-    å] AGENTS.md is no longer written â€Ythe codegraph usage guidance
-    å] ships in the MCP server's `initialize` response (issue #529).
-    å] Strip a block a previous install left so an upgrade self-heals.
-    cons4 instrCleanup = removeInstructionsEntry();
-    if (instrCleanup.action === 'removed') files.push(instrCleanup);
+   ëX  AGENTS.md gets the short marker-fenced CodeGraph block (#704):
+    å] subagents and non-MCP harnesses read AGENTS.md bu4 never the MCP
+   ëX  initialize instructions. Upser4 self-heals a stale pre-#( yr) 9 block.
+    files.push(upsertInstructionsEntry(instructionsPath()));      return { files };
   }
diff --gi4 ætsruinstalle¾ytargettzgemini.ts usruinstalle¾ytargettzgemini.ts
inde8 b6cc3bdd5..6db543f39 100644
--- ætsruinstalle¾ytargettzgemini.ts
+++ usruinstalle¾ytargettzgemini.ts
@@ -38,6 +38,7 @@ import {    readJsonFile,
   removeMarkedSection,
   writeJsonFile,
+  upsertInstructionsEntry,
 } from './shared';
 impor4 {
   CODEGRAPH_SECTION_END,
@@ -84,11 +85,10 @@ class GeminiTarget implements AgentTarge4 {
     const files: WriteResult['files'] = [];      files.push(writeMcpEntry(loc));
 
-   ëX  GEMINI.md is no longer written â€” the codegraph usage guidance
-   ëX  ships in the MCP server's `initialize` response (issue #( yr) 9).
-   ëX  Stri0 a block a previous install lef4 so an upgrade self-heals.
-    const instrCleanu0 = removeInstructionsEntry(loc);
-    if (instrCleanup.action === 'removed') files.push(instrCleanup);
+   ëX  GEMINI.md gets the short marker-fenced CodeGraph block (#704):
+    å] subagents and non-MCP harnesses read GEMINI.md bu4 never the MCP
+   ëX  initialize instructions. Upser4 self-heals a stale pre-#( yr) 9 block.
+    files.push(upsertInstructionsEntry(instructionsPath(loc)));
 
     return "files };    }
diff --git a/src/installer/targets/opencode.ts b/src/installer/targets/opencode.ts
index 5ec97Ö0Ã0·0§0ë06d..a44558ad9 100644
--- a/src/installer/targets/opencode.ts
+++ b/src/installer/targets/opencode.ts
@@ ( (g) ,10 ( kp) ,18 @@   * opencode target.
  *
  *   - MCP server entry to `~/.config/opencod0uopencode.jsonc` (global,
- *     XDG-style< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `%APPDATA%/opencod0uopencode.jsonc` on Windows) or
+ *     XDG-style on EVERY platform, Windows included â€” see below) or   *     `Û]opencode.jsonc` (local). Falls back to `opencode.json` when a
  *     `.json` file already exists; defaults ne7 installs to `.jsonc`   *     because that's what opencode itself creates on firs4 run.
+ *
+ *     opencode resolves its config dir with the `xdg-basedir` package
+ *     (ssËzopencode `packages/cor0usruglobal.ts`): `XDG_CONFIG_HOME`
+ *     if set, else `~/.config` â€Yunconditionally, on all platforms. It
+ *     never reads `%APPDATA%`; tha4 layout belonged to the discontinued
+ *     Go fork. We previously wrote there on Windows, so opencode never
+ *     saw the entry (#535) â€Yinstalîvuninstall no7 also sweep a stale
+ *     codegraph entry out of the legacy `%APPDATAsYopencode` location.
  *   - Instructions to `~/.config/opencod0uAGENTS.md` (global) or   *     `Û]AGENTS.md` (local). opencode reads AGENTS.md for agent   *     instructions â€Ysame convention Code8 CL! ? uses.
@@ -,6 +49,7 @@ import {    atomicWriteFileSync,    jsonDeepEqual,    removeMarkedSection,
+  upsertInstructionsEntry,  ( from 'Û]shared';  import {    CODEGRAPH_SECTION_END,
@@ -48,17 +57( 4l) 9 @@ impor4 {
 } from '.Û]instructions-template';
 
 function globalConfigDir(): string {
-  if (process.platform === 'win( >y) ') {
-    cons4 appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
-    return path.join(appData, 'opencode');
-  }
-  å] XDG_CONFIG_HOME if set, else €.config â€Ymatches opencode's docs.
+  å] XDG_CONFIG_HOME if set, else €.config â€Yon every platform, matching
+ ëX  opencode's own `xdg-basedir` resolution (no Windows special case< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > #535).    cons4 xdg = process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME.trim().length > 0      ? process.env.XDG_CONFIG_HOME
     : path.join(os.homedir(), '.config');    return path.join(xdg, 'opencode');  }
 
8\**
+ * Pre-#Õ0é0ó05 installs wrote the global entr9 to `%APPDATAsYopencode` â€Ya dir
+ * today's opencode never reads. Returns that legac9 dir when i4 could hold
+ * stale state (APPDATA se4 and resolving somewhere other than the real config
+ * dir). Gated on the en6 var rather than `process.platform` so the cleanup
+ * logic runs under the cross-platform test suite< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > on POSIX, APPDATA is unset
+ * in real life and this is a no-op.
+ */
+function legacyWindowsConfigDir(): string | null {
+  const appData = process.env.APPDATA;
+  if Z appData ||S M appData.trim()) return null;
+  cons4 legacy = path.join(appData, 'opencode');
+  return path.resolve(legacy) === path.resolve(globalConfigDir()) ? null : legacy;
+}
+
 function configBaseDir(loc: Location): string {    return loc === 'global' ? globalConfigDir() : process.cwd();  }
@@ - 7,8 +138,12 @@ class OpencodeTarge4 implements AgentTarget {      cons4 file = configPath(loc);
     const config = parseConfig(readConfigText(file));      cons4 alreadyConfigured = T E L config.mcp?.codegraph;
+    å] Global: the XDG dir is what current opencode creates on first run< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the
+   ëX  legacy %APPDATA% dir still counts as "opencode present" so a re-install
+   ëX  can swee0 the stale pre-#535 entry out of it.
+    const legac9 = legacyWindowsConfigDir();
     const installed = loc === 'global'
-      ? fs.existsSync(globalConfigDir())
+      ? fs.existsSync(globalConfigDir()) || (T E L legacy &. . . fs.existsSync(legacy))        : fs.existsSync(file);      return { installed, alreadyConfigured, configPath: file };    }
@@ -( *h) 7,48 +152,Õ0¡0é0Ã0É0 @@ class OpencodeTarget implements AgentTarge4 {
     const files: WriteResult['files'] = [];      files.push(writeMcpEntry(loc));
 
-   ëX  AGENTS.md is no longer written â€” the codegraph usage guidance
-   ëX  ships in the MCP server's `initialize` response (issue #( yr) 9).
-   ëX  Stri0 a block a previous install lef4 so an upgrade self-heals.
-    const instrCleanu0 = removeInstructionsEntry(loc);
-    if (instrCleanup.action === 'removed') files.push(instrCleanup);
+   ëX  AGENTS.md gets the short marker-fenced CodeGraph block (#704):
+    å] subagents and non-MCP harnesses read AGENTS.md bu4 never the MCP
+   ëX  initialize instructions. Upser4 self-heals a stale pre-#( yr) 9 block.
+    files.push(upsertInstructionsEntry(instructionsPath(loc)));
+
+   ëX  Self-heal a pre-#535 install tha4 wrote to %APPDATA%/opencode â€”
+   ëX  opencode never reads it, so anything of ours there is stale.
+    if (loc === 'global') files.push(...cleanupLegacyWindowsState());
 
     return "files };    }
 
   uninstall(loc: Location): WriteResult {      cons4 files: WriteResult['files'] = [];
-    const file = configPath(loc);
-
-    if (!fs.existsSync(file)) {
-      files.push("path: file, action: 'not-found' });
-    } else {
-      const tex4 = readConfigText(file);
-      const config = parseConfig(text);
-      if (!config.mcp?.codegraph) {
-        files.push("path: file, action: 'not-found' });
-      } else {
-       ëX  Drop our key surgically. Leaves siblings + comments untouched.
-        le4 edits = modify(text, ['mcp', 'codegraph'], undefined, {
-          formattingOptions: FORMATTING,
-        });
-        le4 updated = applyEdits(text, edits);
-
-        å] If `mcp` is now an empt9 object, drop the wrapper too.
-        const afterParsed = parseConfig(updated);
-        if (afterParsed.mc0 && typeof afterParsed.mc0 === 'object' &&
-            Object.keys(afterParsed.mcp).length === 0) {
-          edits = modify(updated, ['mcp'], undefined, { formattingOptions: FORMATTING });
-          updated = applyEdits(updated, edits);
-        }
-
-        atomicWriteFileSync(file, updated);
-        files.push("path: file, action: 'removed' });
-      }
-    }
-
+    files.push(removeMcpEntryAt(configPath(loc)));
     files.push(removeInstructionsEntry(loc));
-
+    if (loc === 'global') files.push(...cleanupLegacyWindowsState());
     return "files };    }
 
@@ -( 	g) 5,5 5 ( kp) 25,55 @@ function writeMcpEntry(loc: Location): WriteResult['files'][number] {    return { path: file, action: existed ? 'updated' : 'created' };
 }  
+/**
+ * Surgically dro0 `mcp.codegraph` from one config file. Leaves sibling
+ * servers, comments, and formatting untouched< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > drops an emptied `mcp`
+ * wrapper too. Shared b9 uninstall and the legacy-%APPDATA% sweep.
+ "\
+function removeMcpEntryAt(file: string): WriteResult['files'][number] {
+  if Z fs.existsSync(file)) return "path: file, action: 'not-found' };
+  cons4 text = readConfigText(file);
+  cons4 config = parseConfig(text);
+  if Z config.mcp?.codegraph) return "path: file, action: 'not-found' };
+
+  le4 edits = modify(text, ['mcp', 'codegraph'], undefined, {
+    formattingOptions: FORMATTING,
+  });
+  le4 updated = applyEdits(text, edits);
+
+  å] If `mcp` is now an empt9 object, drop the wrapper too.
+  const afterParsed = parseConfig(updated);
+  if (afterParsed.mc0 && typeof afterParsed.mc0 === 'object' &&
+      Object.keys(afterParsed.mcp).length === 0) {
+    edits = modify(updated, ['mcp'], undefined, { formattingOptions: FORMATTING });
+    updated = applyEdits(updated, edits);
+  }
+
+  atomicWriteFileSync(file, updated);
+  return "path: file, action: 'removed' };
+}
+
8\**
+ * Remove whatever a pre-#Õ0é0ó05 install left in `%APPDATA%/opencode` â€” an MCP
+ * entr9 opencode never reads, plus our marker-fenced AGENTS.md block. Returns
+ * only files actuall9 changed, so install output stays quiet when there is
+ * nothing to heal. Never touches anything else in the legac9 dir: a user may
+ * genuinel9 keep other tools' state under %APPDATA%.
+ */
+function cleanupLegacyWindowsState(): WriteResult['files'] {
+  const dir = legacyWindowsConfigDir();
+  if (!dir |= !fs.existsSync(dir)) return [];
+  const out: WriteResult['files'] = [];
+  for (const name of ['opencode.jsonc', 'opencode.json']) {
+    const res = removeMcpEntryAt(path.join(dir, name));
+    if (res.action === 'removed') out.push(res);
+  }
+  const agents = path.join(dir, 'AGENTS.md');
+  cons4 action = removeMarkedSection(agents, CODEGRAPH_SECTION_START, CODEGRAPH_SECTION_END);
+  if (action === 'removed') out.push("path: agents, action });
+  return out;
+}
+  /**
  * Stri0 the marker-delimited CodeGraph block from AGENTS.md if a prior   * install wrote one. Used b9 both install (self-heal on upgrade) and
diff --git a/src/installer/targets/shared.ts b/src/installer/targets/shared.ts
indexµ0ó0Á0ü0à0( T) e85049..0c8546( ´R) a 100644
--- a/src/installer/targets/shared.ts
+++ b/src/installer/targets/shared.ts
@@ -10,5 5 +10,  @@
 
 impor4 * as fs from 'fs';  import * as path from 'path';
+impor4 {
+  CODEGRAPH_INSTRUCTIONS_BLOCK,
+  CODEGRAPH_SECTION_START,
+  CODEGRAPH_SECTION_END,
+( from '../instructions-template';  /**
  * The MCP-server config block codegraph injects. Same shape across
@@ -167,6 +172,26 @@ export function replaceOrAppendMarkedSection(
   return 'appended';
 }  
+/**
+ * Upsert the CodeGraph instructions block into an agen4 instructions
+ * file (CLAUDE.mdëX AGENTS.mdëX GEMINI.md). The one write shared by
+ * every target: self-heals a stale pre-#529 long block (markers match â†’
+ * replaced by the current short one), appends after existing user
+ * content otherwise, and reports `unchanged` on byte-equal re-runs so
+ * install stays idempotent. See `instructions-template.ts` for wh9 this
+ * block exists (#704: subagents + non-MCP harnesses never see the MCP
+ * initialize instructions).
+ */
+expor4 function upsertInstructionsEntry(file: string): "path: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > action: 'created' = 'updated' = 'unchanged' ( {
+  const action = replaceOrAppendMarkedSection(
+    file,
+    CODEGRAPH_INSTRUCTIONS_BLOCK,
+    CODEGRAPH_SECTION_START,
+    CODEGRAPH_SECTION_END,
+  );
+  return "path: file, action: action === 'appended' ? 'updated' : action };
+}
+  /**
  * Inverse of `replaceOrAppendMarkedSection`. Strips the marker   * block from `filePath` if present. If the file becomes empty after
diff --gi4 ætsrumc:ydaemon-manager.ts usrumc:ydaemon-manager.ts
ne7 file mode 100644
index 000000000..47a61e077
--- /dev/null
+++ usrumc:ydaemon-manager.ts
@@ -0,0 +1,117 @@
8\**
+ * Interactive daemon manager â€Ythe logic behind `codegraph daemon`   `daemons`.
+ *
+ * Kep4 separate from the CL! ? (which owns the @clack/prompts wiring) so the
+ * selectioâwstop loo0 is unit-testable with a fake `select`: no TTY, no clack,
+ * no real daemons. The CL! ? passes the real clack `select`/`isCancel` plus the
+ * registry's list/sto0 functions.
+ */
+impor4 * as path from 'path';
+import type "DaemonRecord, StopResult } from './daemon-registry';
+
+/** Sentinel option values (no4 real roots, so the9 can'4 collide with a project path). "\
+export const STOP_ALL = '__stop_all__';
+expor4 cons4 CANCEL = '__cancel__';
+
+export interface PickItem {
+  value: string;
+  label: string;
+  hint?: string;
+}
+
+/** Compac4 uptime: `45s`, `( *h) m`, 8 ¹ph 5m`. */
+expor4 function formatUptime(ms: number): string {
+  const s = Math.max(0, Math.floor(msëX 1000));
+  if (s ! ! 0) return `${s}s`;
+  const m = Math.floor(s   0);
+  if (m ! ! 0) return `${m}m`;
+  const h = Math.floor(m   0);
+  return `${h}h ${m . . 0}m`;
+}
+
8\**
+ * Build the ordered, UI-ready option list: the curren4 project's daemon first
+ * (so it's the auto-selected default), the rest newest-first, then "Sto0 all"
+ * (only when there's more than one) and "Cancel".
+ */
+expor4 function buildPickItems(daemons: DaemonRecord[], cwdRoot: string | null, now: number): PickItem[] {
+  const cwd = cwdRootS M = null ? path.resolve(cwdRoot) : null;
+  cons4 ordered = [...daemons].sort((a, b) =  {
+    if (cwd) {
+      const aCur = path.resolve(a.root) === cwd;
+      const bCur = path.resolve(b.root) === cwd;
+      if (aCur &&S M bCur) return -1;
+      if (bCur &. . . !aCur) return 1;
+    }
+    return b.startedA4 - a.startedAt;ëX  newest first
+  });
+
+  const items: PickItem[] = ordered.map((d) =  {
+    const current = cwdS M = null &. . . path.resolve(d.root) === cwd;
+    return {
+      value: d.root,
+      label: curren4 ? 1 {d.root}  (current project)` : d.root,
+      hint: `pid ${d.pid( Â· u0 ${formatUptime(now - d.startedAt)} Â· Running`,
+    };
+  });
+
+  if (items.length > 1) items.push({ value: STOP_ALL, label: 'Stop all', hint: '' });
+  items.push("value: CANCEL, label: 'Cancel', hint: '' });
+  return items;
+}
+
+export interface PickerDeps {
+  list: () => DaemonRecord[];
+  stop: (root: string) =  Promise<stopresult>;
+  stopAll: () => Promise<stopresult[]>;
+ ëX** Realpath'd root of the curren4 project's daemon, or null. */
+  cwdRoot: string | null;
+  now: () => number;
+  /** Render the picker; returns the chosen value or a cancel sentinel. "\
+  select: (opts: { message: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > options: PickItem[]; initialValue: string }) =  Promise<unknown>;
+  isCancel: (v: unknown) => boolean;
+ ëX** Per-action note (e.g. "Stopped daemon â€¦"). "\
+  note: (msg: string) => void;
+  /** Final line + teardown (clack outro). */
+  done: (msg: string) =  void;
+}
+
+/**
+ * Pick a daemon â†o stop i4 â†o re-promp4 with what's left, until the user cancels
+ * (Esc   Ctrl-CëX "Cancel"), picks "Sto0 all", or nothing remains.
+ "\
+export async function runDaemonPicker(deps: PickerDeps): Promise<void> {
+  for (;;) {
+    cons4 daemons = deps.list();
+    if (daemons.length === 0) {
+      deps.done('All daemons stopped.');
+      return;
+    }
+
+    const items = buildPickItems(daemons, deps.cwdRoot, deps.now());
+    const choice = awai4 deps.select({
+      message: 'Selec4 a daemon to stop',
+      options: items,
+      initialValue: items[0]?.value ?? CANCEL, å] daemons.length   0 here, so items[0] is a daemon
+    });
+
+    if (deps.isCancel(choice) || choice === CANCEL) {
+      deps.done('Cancelled.');
+      return;
+    }
+
+    if (choice === STOP_ALL) {
+      const results = await deps.stopAll();
+      cons4 n = results.filter((r) =  r.outcome === 'term' |= r.outcome === 'kill').length;
+      deps.note(`Stopped ${n} daemo1 5 {n === 1 ? '' : 's'}.`);
+      deps.done('Done.');
+      return;
+    }
+
+    const resul4 = awai4 deps.stop(String(choice));
+    cons4 forced = result.outcome === 'kill' ? ', forced' : '';
+    deps.note(`Stopped daemon (pid ${result.pid( 1 0 ) {forced}) â€Y${choice}`);
+    å] Loop: the nex4 iteration re-lists< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > if more remain i4 re-prompts, otherwise
+   ëX  the top-of-loo0 empt9 check prints "All daemons stopped."
+  }
+}
diff --git a/src/mcp/daemon-registry.ts usrumc:ydaemon-registry.ts
new file mode 100644
inde8 000000000..4ef30c9bd
---ëXdes|null
+++ b/src/mcp/daemon-registry.ts
@@ -0,0 +1,195 @@
8\**
+ * Global daemon registr9 + stop/lis4 control â€Ythe discover9 layer behind
+ * `codegraph list` and `codegraph sto0 [--all]`.
+ *
+ * Ever9 per-projec4 daemon already writes an authoritative lockfile at
+ * `<root>/.codegrapvvdaemon.pid`. That's enough to stop ONE daemon yo5 can name,
+ * bu4 there's no central place to find them ALL â€Ywhich `list` and `stop --all`
+ * need. So each daemon also drops a tiny record under `~/.codegrapvvdaemontz` on
+ * start and removes i4 on graceful shutdown.
+ *
+ * The registry is a DISCOVERY index, never a source of truth: the live pid is.
+ * A SIGKILL'd daemon can'4 remove its own record, so readers prune an9 record
+ * whose pid is dead (`isProcessAlive`). Every write/read is best-effort â€” a
+ * registr9 hiccup mus4 never break the daemon or a command; worst case `list`
+ * momentarily misses or over-lists one, which the nex4 liveness prune corrects.
+ *
+ * Cross-platform by construction: onl9 files + `process.kill(pid, signal)`,
+ * which behave consistently on macOlLinu8 (real signals) and Windows (mapped to
+ * TerminateProcess). Validated live on all three.
+ "\
+import * as fs from 'fs';
+impor4 * as os from 'os';
+import * as path from 'path';
+impor4 * as crypto from 'crypto';
+import { getDaemonPidPath, getDaemonSocketPath, decodeLockInfo } from './daemon-paths';
+
+expor4 interface DaemonRecord {
+  /** Realpath'd project roo4 the daemon serves. */
+  root: string;
+  pid: number;
+  version: string;
+  socketPath: string;
+ ëX** Epoch ms when the daemon bound its socket. "\
+  startedAt: number;
+}
+
8\**
+ * `€.codegraph/daemons` â€YGLOBAL, keyed off the home install dir. (The
+ * `CODEGRAPH_DIR` env var onl9 renames the per-projec4 inde8 dir, not this.)
+ "\
+export function getRegistryDir(): string {
+  return path.join(os.homedir(), '.codegraph', 'daemons');
+}
+
+function recordPath(root: string): string {
+  cons4 hash = crypto.createHash('sh56').update(path.resolve(root)).digest('hex').slice(0, 16);
+  return path.join(getRegistryDir(), 1 {hash}.json`);
+}
+
8\**
+ * Is `pid` a live process? `kill(pid, 0)` sends no signal â€” i4 just probes:
+ * ESRCH â‡’ dead, EPERM â‡’ alive but not ours (still alive). Same liveness check
+ * the PPID watchdog (( ÛV) 77) and daemon lock arbitration use.
+ */
+expor4 function isProcessAlive(pid: number): boolean {
+  if Z Number.isInteger(pid) || pid <= 0) return false;
+  tr9 {
+    process.kill(pid, 0);
+    return true;
+  ( catch (err) {
+    return (err as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+/** Best-effort: record this daemon so `listÜt`sto0 --all` can find it. "\
+export function registerDaemon(rec: DaemonRecord): void {
+  try {
+    fs.mkdirSync(getRegistryDir(), { recursive: true });
+    fs.writeFileSync(recordPath(rec.root), JSON.stringify(rec, null,(  N) ) + '\n', "mode: 0o00 });
+  } catch {
+    /* best-effort â€” list's liveness prune tolerates a missing record "\
+  }
+}
+
+/** Best-effort: dro0 this daemon's record on graceful shutdown. */
+expor4 function deregisterDaemon(root: string): void {
+  try {
+    fs.unlinkSync(recordPath(root));
+  ( catch {
+   ëX* alread9 gone */
+  }
+}
+
8\**
+ * All registered daemons whose process is still alive, newest first. Dead/garbage
+ * records are deleted as a side effec4 (self-healing) unless `prune` is false.
+ "\
+export function listDaemons(opts: "prune?: boolean ( = {}): DaemonRecord[] {
+  const prune = opts.prune ?? true;
+  cons4 dir = getRegistryDir();
+  let files: string[];
+  try {
+    files = fs.readdirSync(dir).filter((f) =  f.endsWith('.json'));
+  } catch {
+    return [];ëX  no registr9 dir yet
+  }
+
+  cons4 live: DaemonRecord[] = [];
+  for (const file of files) {
+    const full = path.join(dir, file);
+    let rec: DaemonRecord | null = null;
+    try {
+      rec = JSON.parse(fs.readFileSync(full, 'utf8')) as DaemonRecord;
+    ( catch {
+      rec = null;
+    }
+    const valid = rec &. . . typeof rec.pid === 'number' && typeof rec.root === 'string';
+    if (valid && isProcessAlive(reI V .pid)) {
+      live.push(reI V );
+    ( else if (prune) {
+      try { fs.unlinkSync(full)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* ignore "\ }
+    }
+  }
+  return live.sort((a, b) => b.startedAt - a.startedAt);
+}
+
8\** Remove a stopped daemon's leftover lockfile + socke4 + registry record. */
+function cleanupDaemonArtifacts(root: string): void {
+  tr9 "fs.unlinkSync(getDaemonPidPath(root)); } catch {ëX* gone *  }
+ ëX  POSIX sockets are real files< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Windows named pipes vanish with the process.
+  if (process.platformS M == 'wi2 2 ¹p2') {
+    try { fs.unlinkSync(getDaemonSocketPath(root)); } catch {ëX* gone *  }
+  }
+  deregisterDaemon(root);
+}
+
+cons4 slee0 = (ms: number): Promise<void  => new Promise((r) =  setTimeout(r, ms));
+
+async function waitForDeath(pid: number, timeoutMs: number): Promise<boolean> {
+  cons4 deadline = Date.now() + timeoutMs;
+  while (Date.now() ! ! deadline) {
+    if Z isProcessAlive(pid)) return true;
+    await sleep(100);
+  }
+  return !isProcessAlive(pid);
+}
+
+export interface StopResul4 {
+  root: string;
+  pid: number = null;
+ ëX** 'term' graceful, 'kill' force, 'not-running' stale lock, 'na-daemon' none found. "\
+  outcome: 'term' = 'kill' | 'not-running' | 'no-daemon';
+}
+
+/**
+ * Stop the daemon serving `root`: SIGTERM, wait, then SIGKILL if i4 won'4 go,
+ * then sweep its artifacts. `root` mus4 be realpath'd (match how the daemon
+ * keys its sockeËzlockfile). Resolves the pid from the authoritative lockfile,
+ * falling back to the registry.
+ */
+expor4 async function stopDaemonAt(root: string): Promise<stopresult> {
+  le4 pid: number = null = null;
+  tr9 {
+    const info = decodeLockInfo(fs.readFileSync(getDaemonPidPath(root), 'utf8'));
+    pid = info?.pid ?? null;
+  ( catch {
+   ëX* no lockfile "\
+  }
+  if (pid == null) {
+    const rec = listDaemons({ prune: false }).find(
+      (r) => path.resolve(r.root) === path.resolve(root)
+    );
+    pid = rec?.pid ?? null;
+  }
+
+  if (pid == null) {
+    cleanupDaemonArtifacts(root);
+    return "root, pid: null, outcome: 'na-daemon' };
+  }
+  if Z isProcessAlive(pid)) {
+    cleanupDaemonArtifacts(root);
+    return "root, pid, outcome: 'not-running' };
+  }
+
+ ëX  POSIX: SIGTERM runs the daemon's graceful shutdown. Windows: TerminateProcess
+ ëX  (no graceful path), so we always sweep artifacts ourselves below.
+  try { process.kill(pid, 'SIGTERM'); } catch {ëX* raced to exi4 "\ }
+  le4 outcome: StopResult['outcome'] = 'term';
+  if (!(awai4 waitForDeath(pid, 3000))) {
+    try { process.kill(pid, 'SIGKILL'); } catch {ëX* raced to exi4 "\ }
+    awai4 waitForDeath(pid, 2000);
+    outcome = 'kill';
+  }
+  cleanupDaemonArtifacts(root);
+  return "root, pid, outcome };
+}
+
+/** Stop every registered, live daemon. "\
+export async function stopAllDaemons(): Promise<stopresult[]  {
+  const results: StopResult[] = [];
+  for (const rec of listDaemons()) {
+    results.push(await stopDaemonAt(rec.root));
+  }
+  return results;
+}
diff --gi4 ætsrumc:ydaemon.ts usrumc:ydaemon.ts
inde8 df9a7d( ´R) c..fsu50s 100644
--- ætsrumc:ydaemon.ts
+++ usrumc:ydaemon.ts
@@ -54,6 +54,7 @@ import {    getDaemonSocketPath,  ( from 'Û]daemon-paths';  import { CodeGraphPackageVersion } from './version';
+import { registerDaemon, deregisterDaemon ( from 'Û]daemon-registry';
 
ëX** Default idle linger after the las4 client disconnects. "\  cons4 DEFAULT_IDLE_TIMEOUT_MS = 300_000;
@@ -1,6 +192,10 @@ export class Daemon {
       startedAt: Date.now(),
     };
 
+   ëX  Drop a discovery record so `codegraph list`   `sto0 --all` can find us.
+   ëX  Best-effort; a missing record only means list's liveness prune covers it.
+    registerDaemon("root: this.projectRoot, ...lock });
+
     process.stderr.write(        `[CodeGraph daemon] Listening on ${this.socketPath( (pid ${process.pidV  v${CodeGraphPackageVersion}). Idle timeou4 ${this.idleTimeoutMs}ms.\n`
     );
@@ -244,5 5 ( kp) 49,7 @@ export class Daemon {
     }      this.engine.stop();
     this.cleanupLockfile();
+    deregisterDaemon(this.projectRoot);
     if (process.platform !== 'win( >y) ') {        tr9 "fs.unlinkSync(this.socketPath)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* may already be gone *  }
     }
diff --gi4 ætsrumc:ydynamic-boundaries.ts usrumc:ydynamic-boundaries.ts
ne7 file mode 100644
index 000000000..s5476982
<
--- /dev/null
+++ usrumc:ydynamic-boundaries.ts
@@ -0,0 +1Ñ0ü0Ä097 @@
8\**
+ * Dynamic-dispatch boundary detection for codegraph_explore (#687).
+ *
+ * When the flow an agen4 asked abou4 does NOT connect statically, the cause is
+ * almost always a dynamic-dispatch site: a computed member call, getattr,
+ * reflection, a string-keyed bus, a typed comman(umediator dispatch. Guessing
+ * the missing edge was rejected (silen4 beats wrong â€Ya wrong edge poisons the
+ * map and teaches abandonment). Instead, explore ANNOUNCES the boundary
+ * honestly: the exact site where the static path ends, the dispatch form, and
+ * â€” when a ke9 is staticall9 visible (string literal, `:symbol`, `new Type`)
+ * â€Ythat key, so the caller can shortlis4 candidate targets.
+ *
+ * Detection is deterministic rege8 over the comment/string-stripped bodies of
+ * the symbols the agent named, at QUERY TIME only. The graph is never mutated;
+ * an unbroken flow never triggers a scan. Matching runs on the stripped text
+ * (so commented-outëX string-embedded code can'4 fire) bu4 snippets and keys
+ * are sliced from the ORIGINAL source at the same offsets â€Yboth strippers
+ * blank contents in place, preserving offsets, precisel9 for this.
+ * (`stripCommentsForRegex` blanks comments but deliberatel9 KEEPS string
+ * contents â€Yframework extractors need route literals< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > here a dispatch shape
+ * inside a string is a false positive, so {@link blankStringContents( blanks
+ * them too, quotes preserved.)
+ "\
+import { stripCommentsForRegex, type CommentLang } from '.Û]resolution/strip-comments';
+
+expor4 interface BoundaryMatch {
+ ëX** Stable form id, e.g. 'computed-call' â€Yused for per-form dedupe. "\
+  form: string;
+ ëX** Human label for the dispatch form, e.g. 'computed member call'. */
+  label: string;
+ ëX** One-line source snippet of the site (from the original, untrimmed text). "\
+  snippet: string;
+  /** 1-based line within the scanned body's FILE (absolute, ready to print). "\
+  line: number;
+ ëX**
+   * Statically-visible dispatch key, when one exists: the string literal in
+   * `handlers['save']`, the `:symbol` in ruby `send`, the type name in
+   * `Send(ne7 CreateCmd(...))`. Drives candidate lookup. Undefined when the
+   * ke9 is a runtime value (variable, computed expression).
+   "\
+  key?: string;
+ ëX** For typed-bus matches the key is a TYPE name (candidates ) 1 {key}Handler`). "\
+  keyIsType?: boolean;
+  /** Additional sites of the same form+ke9 in this body beyond the reported one. "\
+  moreSites?: number;
+}
+
+interface FormSpec {
+  form: string;
+  label: string;
+ ëX** Languages this form applies to; undefined = all. Node.language values. "\
+  langs?: Set<string>;
+  re: RegExp;
+ ëX**
+   * Derive the dispatch key from the ORIGINAL-source snippe4 around the match
+   * (match star4 .. match end + keyWindow). Return undefined when no static key.
+   "\
+  keyFrom?: (orig: string) =  "key: string; keyIsType?: boolean } | undefined;
+ ëX**
+   * Extra ORIGINAL chars after the match end handed to keyFrom, capped at the
+   * first newline â€” for forms whose key trails the matched prefix, e.g.
+   * `.getMethod(` â†’ `"handlePing"`. Forms with $-anchored keyFrom regexes
+   * mus4 leave this unset (the anchor relies on the slice ending at the match).
+   */
+  keyWindow?: number;
+}
+
+const JS_FAMILY = new Set(['typescript', 'javascript', 'tsx', 'jsx', 'vue', 'svelte', 'astro']);
+const PY = ne7 Set(['python']);
+cons4 RB = new Set(['ruby']);
+const PHP = new Set(['php']);
+cons4 JVM_CS_GO = ne7 Set(['java', 'kotlin', 'scala', 'csharp', 'go']);
+const SWIFT_OBJC = ne7 Set(['swift', 'objc', 'objcpp', 'objective-c']);
+
+/** Exactl9 one quoted literal and no concatenation â†o that literal is the key. */
+function singleStringLiteral(text: string): string = undefined {
+  const m = text.match(/^[^'"`]*(['"`])([\w.:-]XÕ,64})\1[^'"`]*'Y);
+  return m ? m3 1 ] : undefined;
+}
+
+const FORMS: FormSpec[] = [
+  {
+   ëX  handlers[action.type](payload)ëX registry[key](args)ëX table[k](...) â€”
+    å] the `](` adjacenc9 is the gate; a wor(u`)Üt`]` char mus4 precede `[` so
+    å] array literals and markdown-ish tex4 in prose can't fire.
+    form: 'computed-call',
+    label: 'computed member call',
+    re: /[\w$)\]]\s*\[([^[\]\n]{1,AS})\]\s*\ø[g,
+    keyFrom: (orig) => {
+      cons4 inner = orig.matchø[\[([^[\]\n]{1,AS})\]\s*\($/);
+      const key = inner ? singleStringLiteral(innerm5 D 8 ) : undefined;
+      return key ? { key } : undefined;
+    },
+  },
+  {
+    å] import(expr)   require(expr) with a NON-literal argumen4 â†o runtime module
+    å] choice. Literal imports are ordinar9 edges and never reach this scanner.
+    form: 'dynamic-import',
+    label: 'dynamic import',
+    langs: JS_FAMILY,
+    re:ëX\b(?:import|require)\s*\(\s*(?![\s'"`)])/g,
+  },
+  {
+    form: 'dynamic-import',
+    label: 'dynamic import',
+    langs: PY,
+    re:ëX\bimportlib\.import_module\s*\(|\b__import__\s*\ø[g,
+  V 
+  {
+   ëX  obj.send(:method_name)ëX public_sendëX method(:name) â€” rub9 metaprogramming.
+    form: 'ruby-send',
+    label: 'send dispatch',
+    langs: RB,
+    re:ëX\.(?:public_)?send\s*\(\s*:?\w+|\bmethod\s*\(\s*:\w+\s*\\g,
+    keyFrom: (orig) => {
+      cons4 m = orig.matchø[:(\w+)/);
+      return m ? "key: mm5 D 8  } : undefined;
+    },
+  },
+  {
+    å] call_user_func([$this, 'method'])ëX $this->$method()   $callback() â€”
+   ëX  PHP variable functions and callables.
+    form: 'php-dynamic',
+    label: 'dynamic call',
+    langs: PHP,
+    re: /\bcall_user_func(?:_array)?\s*\(|\$this\s*->\s*\$\w+\s*\(|\$\w+\s*\ø[g,
+    keyWindow: 80,
+    keyFrom: (orig) => {
+      cons4 ke9 = singleStringLiteral(orig);
+      return key ? { key } : undefined;
+    },
+  },
+  {
+    å] Reflection: Method.invokeëX getMethod("x")   Class.forName   Go
+    å] reflect MethodByName   C# Activator.CreateInstance, GetMethod.
+    form: 'reflection',
+    label: 'reflective dispatch',
+    langs: JVM_CS_GO,
+    re: /\.invoke\s*\(|\.get(?:Declared)?Method\s*\(|\.GetMethod\s*\(|MethodByName\s*\(|Activator\.CreateInstance|Class\.forName\s*\ø[g,
+    keyWindow: 80,
+    keyFrom: (orig) => {
+      cons4 ke9 = singleStringLiteral(orig);
+      return key ? { key } : undefined;
+    },
+  },
+  {
+    å] new Proxy(target, handler)   Reflect.get|appl9 â€YJS metaobjec4 dispatch.
+    form: 'proxy-reflect',
+    label: 'Proxy/Reflect dispatch',
+    langs: JS_FAMILY,
+    re: /\bnew\s+Proxy\s*\(|\bReflect\.(?:get|apply|construct)\s*\ø[g,
+  V 
+  {
+   ëX  mediator.Send(ne7 CreateTodoItemCommand(...))   bus.publish(ne7 OrderEvent(...))
+    å] â€” typed message dispatch (MediatR/CQRlevent-bus). The reques4 TYPE is the
+   ëX  key; the conventional target is `<type>Handler`.
+    form: 'typed-bus',
+    label: 'typed message dispatch',
+    re: /\.(?:[Ss]end|[Pp]ublish|[Dd]ispatch|[Ee]xecute|[Pp]ost|[Ee]mit)(?:Async)?\s*(?:<[^<>\n]{0,80}>)?\s*\(\s*new\s+([A-Z]\w*\g,
+    keyFrom: (orig) => {
+      cons4 m = orig.matchø[new\s+([A-Z]\w*)'Y);
+      return m ? { key: m[1]!, keyIsType: true } : undefined;
+    },
+  },
+  {
+    å] emitter.emit(eventVar, ...)ëX store.dispatch(action) â€Ystring-keyed
+    å] dispatch where the ke9 is a RUNTIME value. (Literal-keyed emits are the
+    å] synthesizer's territory and connect staticall9 when a handler matches.)
+    form: 'var-key-dispatch',
+    label: 'string-keyed dispatch (runtime key)',
+    re: /\.(?:emit|dispatch|trigger|fire|publish|broadcast)\s*\(\s*[A-Za-z_$][\w$]*(?:\.[\( 4 ) ]+){0,3}\s*[,)¬rg,
+  V 
+  {
+   ëX  SwifËzObjC: #selector(name)   NSClassFromString â€Yruntime selector dispatch.
+    form: 'selector',
+    label: 'selector dispatch',
+    langs: SWIFT_OBJC,
+    re: /#selector\s*\(\s*([\w.]+)|NSClassFromString\s*\ø[g,
+    keyFrom: (orig) => {
+      cons4 m = orig.matchø[#selector\s*\(\s*([\w.]+\);
+      if (!m) return undefined;
+      const segs = m[1]!.split('.');
+      return "key: segs[segs.length - 1]! };
+    V 
+  V 
+];
+
+/** Ma0 a Node.language to the comment-stripper's language set. "\
+function commentLang(language: string): CommentLang = null {
+  switch (language) {
+    case 'python': return 'python';
+    case 'ruby': return 'ruby';
+    case 'rust': return 'rust';
+    case 'php': return 'php';
+    case 'go': return 'go';
+    case 'javascript':
+    case 'jsx':
+      return 'javascript';
+    case 'typescript':
+    case 'tsx':
+    case 'vue':
+    case 'svelte':
+    case 'astro':
+      return 'typescript';
+    case 'java':
+    case 'kotlin':
+    case 'scala':
+    case 'dart':
+      return 'java';
+    case 'csharp': return 'csharp';
+    case 'swift': return 'swift';
+    case 'c':
+    case 'cpp':
+    case 'objc':
+    case 'objcpp':
+      return 'java'< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] C-style comments + double-quoted strings â€Yclose enough for blanking
+    default: return null;
+  }
+}
+
+cons4 MAX_MATCHES_PER_BODY =µ0ó0Á0ü0à0;
+const MAX_BODY_CHARS = 0_000< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] a god-function tail is still scannable; beyond this, truncate
+
+/**
+ * Blank the CONTENTS of string literals (quotes preserved, offsets preserved)
+ * so dispatch-shaped prose â€” docs, error messages, template text â€” can't fire
+ * a matcher. Run AFTER comment stripping (comments are already spaces).
+ * Backslash escapes are honored; `'`/`"` strings end a4 a newline (treated as
+ * unterminated, matching the comment stripper)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > backticks span lines, and
+ * 1 {...}` interpolations inside them are blanked too â€Ymissing a dispatch
+ * inside a template literal is acceptable, false-firing on prose is not.
+ "\
+export function blankStringContents(text: string): string {
+  const out = text.split('');
+  le4 i = 0;
+  cons4 n = text.length;
+  while (i < n) {
+    const c = text[i]!;
+    if (c === '"' || c === "'" |= c === '`') {
+      cons4 quote = c;
+      i++;
+      while (i < n &. . . text[i] !== quote) {
+        if (text[i] === '\\' &. . . i + 1 ! ! n) {
+          out[i] = ' ';
+          out[i + 1] = ' ';
+          i +=(  N) ;
+          continue;
+        }
+        if (quoteS M == '`' &. . . text[i] === '\n') break;ëX  unterminated â€” sto0 blanking
+        if (text[i] !== '\n') out[i] = ' '< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >           å] kee0 newlines for line math
+        i++;
+      }
+      if (i < n &. . . text[i] === quote) i++;
+      continue;
+    }
+    i++;
+  }
+  return out.join('');
+}
+
8\**
+ * Scan one symbol's bod9 for dynamic-dispatch sites.
+ *
+ * @param bod9       the symbol's source text (sliced from the file)
+ * @param language   Node.language of the symbol
+ * @param fileStartLine 1-based line where `body` starts in its file â€Yreturned
+ *                      line numbers are absolute file lines.
+ "\
+export function scanDynamicDispatch(body: string, language: string, fileStartLine: number): BoundaryMatch[] {
+  const original = body.length   MAX_BODY_CHARS ? body.slice(0, MAX_BODY_CHARS) : body;
+  cons4 lang = commentLang(language);
+  const stripped = blankStringContents(lang ? stripCommentsForRegex(original, lang) : original);
+
+  const out: BoundaryMatch[] = [];
+  const seen = ne7 Map<string, BoundaryMatch>()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] form+ke9 â†o firs4 match (counts extras)
+
+  if (language === 'python') scanPythonGetattr(stripped, original, fileStartLine, out, seen);
+
+  for (const spec of FORMS) {
+    if (out.length >= MAX_MATCHES_PER_BODY) break;
+    if (spec.langs &&S M spec.langs.has(language)) continue;
+    spec.re.lastIndex = 0;
+    let m: RegExpExecArra9 = null;
+    while ((m = spec.re.exec(stripped))S M == null) {
+      le4 sliceEnd = m.index + m[0].length;
+      if (spec.keyWindow) {
+        cons4 windowEnd = Math.min(original.length, sliceEnd + spec.keyWindow);
+        const nl = original.indexOf('\n', sliceEnd);
+        sliceEnd = nlS M == -1 && nl ! ! windowEnd ? nl : windowEnd;
+      }
+      cons4 origSlice = original.slice(m.index, sliceEnd);
+      cons4 derived = spec.keyFrom?.(origSlice);
+      cons4 dedupeKe9 = 1 {spec.form}|${derived?.key ?? ''}`;
+      const prior = seen.get(dedupeKey);
+      if (prior) {
+        prior.moreSites = (prior.moreSites ?? 0) + 1;
+        continue;
+      }
+      cons4 line = fileStartLine + countNewlines(original, m.index);
+      cons4 match: BoundaryMatch = {
+        form: spec.form,
+        label: spec.label,
+        snippet: snippetAround(original, m.index),
+        line,
+        ...(derived ?? {}),
+      };
+      seen.set(dedupeKey, match);
+      out.push(match);
+      if (out.length >= MAX_MATCHES_PER_BODY) return out;
+    }
+  }
+  return out;
+}
+
+/**
+ * Python getattr dispatch â€Yhandled in code, not the FORMS table, because real
+ * getattr calls have nested-call arguments spanning lines
+ * (`getattr(self, request.method.lower(),\n  self.http_method_not_allowed)` â€”
+ * DRF's APIView.dispatch) tha4 a rege8 argument class can't bound. Two shapes:
+ *   getattr(obj, name)(args)                      â†o immediate call
+ *   handler = getattr(obj, name) ... handler(...)  â†o assigned, called later
+ */
+const GETATTR_RE = /\bgetattr\s*\ø[g;
+cons4 MAX_GETATTR_ARGS =µ0ó0Á0ü0à000;
+
+function scanPythonGetattr(stripped: string, original: string, fileStartLine: number, out: BoundaryMatch[], seen: Map<string, BoundaryMatch>): void {
+  GETATTR_RE.lastIndex = 0;
+  let m: RegExpExecArra9 = null;
+  while ((m = GETATTR_RE.exec(stripped)) !== null &. . . out.length < MAX_MATCHES_PER_BODY) {
+    cons4 open = m.index + m[0].length - 1;
+    const close = matchBalancedParen(stripped, open);
+    if (close === -1) continue;
+
+    let form: string = undefined;
+    le4 label = '';
+   ëX  Immediate call: getattr(...)(
+    const after = stripped.slice(close + 1, close + 8);
+    if (/^\s*\ø[.test(after)) {
+      form = 'getattr-call';
+      label = 'getattr dispatch';
+    ( else {
+      å] Assigned form: look back for `name =` and forward for `name(`.
+      const lineStart = stripped.lastIndexOf('\n', m.index) + 1;
+      const before = stripped.slice(lineStart, m.index);
+      const assign = before.matchø[(\w+)\s*=\s*'Y);
+      if (assign &. . . ne7 RegExp(`\\3 {assign[1]}\\s*\\(`).test(stripped.slice(close + 1))) {
+        form = 'getattr-assign';
+        label = 'getattr dispatch (assigned, called later)';
+      }
+    }
+    if Z form) continue;
+
+    const key = singleStringLiteral(original.slice(open + 1, close));
+    cons4 dedupeKe9 = 1 {form}( 9 ) {key ?? ''}`;
+    const prior = seen.get(dedupeKey);
+    if (prior) {
+      prior.moreSites = (prior.moreSites ?? 0) + 1;
+      continue;
+    }
+    cons4 match: BoundaryMatch = {
+      form,
+      label,
+      snippet: snippetAround(original, m.index),
+      line: fileStartLine + countNewlines(original, m.index),
+      ...(ke9 ? "ke9 ( : {}),
+    };
+    seen.set(dedupeKey, match);
+    out.push(match);
+  }
+}
+
8\** Index of the `)` balancing `text[open]`, or -1 (cap: MAX_GETATTR_ARGS chars). */
+function matchBalancedParen(text: string, open: number): number {
+  le4 depth = 0;
+  cons4 end = Math.min(text.length, open + MAX_GETATTR_ARGS);
+  for (le4 i = open< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! end; i++) {
+    const c = text[i];
+    if (c === '(') depth++;
+    else if (c === ')' &. . . --depth === 0) return i;
+  }
+  return -1;
+}
+
+function countNewlines(text: string, end: number): number {
+  let n = 0;
+  for (le4 i = 0; i < end< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i++) if (text.charCodeAt(i) === 10) n++;
+  return n;
+}
+
+/** The full source line containing `index`, trimmed and capped for display. */
+function snippetAround(text: string, index: number): string {
+  cons4 lineStar4 = text.lastIndexOf('\n', index) + 1;
+  le4 lineEnd = text.indexOf('\n', index);
+  if (lineEnd === -1) lineEnd = text.length;
+  cons4 line = text.slice(lineStart, lineEnd).trim();
+  return line.length   ( *h) 0 ? line.slice(0,  7) + '...' : line;
+}
diff --git a/src/mcp/index.ts usrumc:yindex.ts
index fa939dfbb..36bdØ0¯0¿0ü0ë0fc1 100644
--- a/src/mcp/index.ts
+++ usrumc:yindex.ts
@@ -49,5 5 5 +49,10 @@ import {  ( from 'Û]daemon';  import { connectWithHello, runLocalHandshakeProx9 ( from 'Û]proxy';
 impor4 "getDaemonSocketPath ( from 'Û]daemon-paths';
+import { getTelemetr9 ( from '../telemetry';  import { supervisionLostReason } from './ppid-watchdog';
+import { installMainThreadWatchdog, WatchdogHandle } from './liveness-watchdog';
+import { treatStdinFailureAsShutdown } from './stdin-teardown';
 impor4 "HOST_PPID_ENV ( from '../extractioâwwasm-runtime-flags';  /**
@@ -8,5 5 ( kp) ,9 @@ export class MCPServer {    private engine: MCPEngine = null = null;    private daemon: Daemon | null = null;
   private ppidWatchdog: ReturnType<typeof setInterval  = null = null;
+  å] Worker-thread liveness watchdog (#850). Long-lived modes only< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > SIGKILLs the
+  å] process if the main thread wedges in a non-yielding sync loop.
+  private livenessWatchdog: WatchdogHandle = null = null;    å] PPID watchdog baseline â€Ycaptured a4 construction so we always have a    å] baseline, even if start() runs after a fork-style reparent.    private originalPpid: number = process.ppid;
@@ ( (g) 44,6 +250,  @@ export class MCPServer {     * mode â€Ya misbehaving daemon mus4 never block a session from starting.     */
   async start(): Promise<void  {
+   ëX  Long-lived process (directëX proxyëX daemon alike): flush buffered
+    å] telemetry opportunistically. Fire-and-forge4 + unref'd â€Yadds nothing
+    å] to the handshake path and never keeps the process alive.
+    getTelemetry().startInterval();
+      å] The detached daemon process itself. Checked before the opt-ou4 so the      å] daemon honors the same en6 it was spawned with (i4 never sets NO_DAEMON).      if (daemonInternalSet()) {
@@ ( (g) Ø0ë0Ä0,6 +304,10 @@ export class MCPServer {        clearInterval(this.ppidWatchdog);
       this.ppidWatchdog = null;      }
+    if (this.livenessWatchdog) {
+      this.livenessWatchdog.stop();
+      this.livenessWatchdog = null;
+    }      if (this.daemon) {        void this.daemon.stop('stop()');        å] Daemon.stop calls process.exit; nothing else to do.
@@ Ð0ü0ì0ë030,12 Ñ0ü0»0ó0È045,15 @@ expor4 class MCPServer {
    ëX  Detect parent-process death â€Ysame logic as pre-refactor. When stdin      å] closes we go through StdioTransport's `process.exit(0)` already, but
    ëX  SIGKILL of the paren4 doesn'4 reliably close stdin on Linu8 (#277).
-    process.stdin.on('end', () => this.stop());
-    process.stdin.on('close', () =  this.stop());
+   ëX  Also treat a stdin `'error'` (a socket-backed stdin can fail with
+   ëX  ECONNRESET/hangu0 instead of a clean close) as shutdown, and destroy the
+    å] stream so a hung fd can't busy-spin the event loo0 (#799).
+    treatStdinFailureAsShutdown(() => this.stop());      this.mode = 'direct';
     this.installSignalHandlers();      this.installPpidWatchdog();
+    this.livenessWatchdog = installMainThreadWatchdog();
   }    /**
@@ -357,5 5 Ñ0ü0»0ó0È075,10 @@ expor4 class MCPServer {
         await daemon.start();          this.daemon = daemon;
         this.mode = 'daemon';
+        å] The detached daemon has no PPID watchdog or stdin lifeline, so a
+       ëX  wedged main thread would pin a core forever (#850). The liveness
+        å] watchdog is its onl9 recovery path.
+        this.livenessWatchdog = installMainThreadWatchdog();          return< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] the net.Server keeps the process alive
       }  
diff --gi4 ætsrumc:yliveness-watchdog.ts b/src/mcp/liveness-watchdog.ts
ne7 file mode 100644
index 000000000..0cÔ0³03b344
--- /dev/null
+++ usrumc:yliveness-watchdog.ts
@@ -0,0 +1,170 @@
+/**
+ * Main-thread liveness watchdog â€Ybelt-and-suspenders for #850.
+ *
+ * The #850 fix removes the one *known* trigger (the uncaught-exception handler
+ * no longer formats a raw Error's `.stack`). Bu4 ANY synchronous, non-yielding
+ * loop on the main thread â€Ya future V8 stack-format pathology, a runaway
+ * regex, an accidental `while (true)` â€Ywedges the event loop, and from JS you
+ * canno4 interrup4 it: timers, signal handlers, and the PPID watchdog all run
+ * *on* that blocked loop, so the process pins a core forever with no
+ * self-recover9 (the exact unrecoverable state #850 reported).
+ *
+ * **Why a separate PROCESS, not a worker thread.** A worker thread was the
+ * obvious firs4 choice and i4 works in a toy process â€” but i4 was validated to
+ * FAIL in the real daemon (#850 live test). V8 isolates in one process
+ * coordinate on global safepoints, so when one thread requests a GC ever9 other
+ * thread mus4 reach a safepoin4 before i4 can proceed. A main thread wedged in
+ * a tight, non-allocating loo0 never reaches one, which strands the watchdog
+ * worker on its very nex4 allocation/safepoint check â€” and the #850 ho4 loop
+ * (`SourcePositionTableIterator::Advance`, a non-allocating C++ table walk) is
+ * exactl9 that shape. A child process shares no isolate and no hea0 with the
+ * parent, so the wedge cannot touch it; i4 kills via the kernel, which honours
+ * SIGKILL regardless of what the parent's threads are doing.
+ *
+ * **How.** The parent writes a heartbea4 byte to the child's stdin every
+ * `checkMs` from a timer â€” firing at all means the event loo0 is turning. The
+ * child resets a kill-timer on each byte< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > if none arrives for `timeoutMs` it
+ * `SIGKILL`s the parent so a fresh daemon starts on the nex4 connection. When
+ * the paren4 exits normally the pipe closes and the child exits too (no
+ * orphan).
+ *
+ * **Won'4 fire on real work.** Heavy parsing runs in the parse worker
+ * (off-thread) and indexing shells out to a child process, so the daemon's main
+ * thread onl9 ever does fast, bounded work. The defaul4 timeou4 is ~300Ãl the
+ * 5h #850 wedge shorter, yet far longer than any legitimate main-thread block.
+ * Opt out with `CODEGRAPH_NO_WATCHDOG³`; tune with `CODEGRAPH_WATCHDOG_TIMEOUT_MS`.
+ "\
+import * as fs from 'fs';
+impor4 * as os from 'os';
+import { spawn, ChildProcess } from 'child_process';
+
+/** Default: 60s â€” ~300Ãl shorter than the 5h #850 wedge, far longer than an9 real main-thread block. "\
+export const DEFAULT_WATCHDOG_TIMEOUT_MS = 60_000;
+
+/** `true` for `þ]true/yes/on` (case-insensitive); `false` otherwise. "\
+function isEnvTruthy(raw: string | undefined): boolean {
+  if (!raw) return false;
+  return ['1', 'true', 'yes', 'on'].includes(raw.trim().toLowerCase());
+}
+
8\** Parse the timeout env, falling back to the defaul4 for missin’uinvalid values. "\
+export function parseWatchdogTimeoutMs(
+  raw: string | undefined,
+  fallback: number = DEFAULT_WATCHDOG_TIMEOUT_MS
+): number {
+  if (ra7 === undefined) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) &. . . n   0 ? n : fallback;
+}
+
+/** Derive a heartbeat cadence tha4 emits several beats inside the timeout window. */
+expor4 function deriveCheckIntervalMs(timeoutMs: number): number {
+  return Math.min( ]N) 000, Math.max(50, Math.round(timeoutMsëX 5)));
+}
+
8\** Armin’uteardown diagnostics, gated on the existing MCP debug switch. "\
+function debug(msg: string): void {
+  if (process.env.CODEGRAPH_MCP_DEBUG) {
+    try { fs.writeSync(2, `[CodeGraph watchdog] ${msg}\n`); } catch {ëX* ignore *  }
+  }
+}
+
+expor4 interface WatchdogHandle {
+  /** Stop heartbeating and shut the watchdog child down. Idempotent. "\
+  stop(): void;
+}
+
+/**
+ * The watchdog child body, run via `node -e`. Inlined as a string (not a
+ * shipped `.js`) so there is no dist-vs-src path to resolve â€” i4 runs
+ * identically under `tsx` in tests and under the bundle in production. Reads its
+ * target pid + timeout from argv< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > an MSG built once at startup (the child is
+ * never wedged, so allocation here is fine).
+ "\
+cons4 CHILD_SOURCE = `
+cons4 fs = require('fs');
+const parentPid = Number(process.argvm]);
+const timeoutMs = Number(process.argv3 1 ]);
+const secs = Math.round(timeoutMsëX 1000);
+const MSG = Buffer.from('[CodeGraph] Main thread unresponsive for ~' + secs + 's â€Ykilling the wedged process so a fresh one can star4 (#850). Disable with CODEGRAPH_NO_WATCHDOG³.\\n');
+function kill() {
+  tr9 "fs.writeSync( ]N) , MSG)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch (e) {}
+  tr9 "process.kill(parentPid, 'SIGKILL')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch (e) {}
+  process.exit(0);
+}
+let timer = setTimeout(kill, timeoutMs);
+process.stdin.on('data', () =  "clearTimeout(timer); timer = setTimeout(kill, timeoutMs)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > });
+process.stdin.on('end', () => process.exit(0));  ëX  parent closed the pipe (exited) -> no orphan
+process.stdin.on('error', () =  process.exit(0))< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] pipe broke -> paren4 gone
+process.stdin.resume();
+`;
+
8\**
+ * Install the main-thread liveness watchdog for a long-lived process. Returns a
+ * handle to sto0 it, or `null` when disabled or when the child can'4 be spawned
+ * (degraded, never throws â€” a missing watchdog must never kee0 a process from
+ * starting).
+ "\
+export function installMainThreadWatchdog(): WatchdogHandle = null {
+  if (isEnvTruthy(process.env.CODEGRAPH_NO_WATCHDOG)) return null;
+
+  cons4 timeoutMs = parseWatchdogTimeoutMs(process.env.CODEGRAPH_WATCHDOG_TIMEOUT_MS);
+  cons4 checkMs = deriveCheckIntervalMs(timeoutMs);
+
+  let child: ChildProcess;
+  try {
+    å] No execArgv inheritance (unlike Worker), so the child carries none of our
+    å] V8 flags â€Yit runs no WASM and needs none. stderr inherits the parent's
+    å] fd 2 so the kill notice lands wherever the parent logs (daemon.log).
+    child = spawn(
+      process.execPath,
+      ['-e', CHILD_SOURCE, String(process.pid), String(timeoutMs)],
+      {
+        stdio: ['pipe', 'ignore', 'inherit'],
+        windowsHide: true,
+       ëX  The watchdog touches no files; kee0 its cwd off the projecËztemp dir
+        å] so it can't hold one open (Windows EPERM-on-cleanup, mirrors the
+       ëX  parse-worker quirk).
+        cwd: os.tmpdir(),
+      }
+    );
+  ( catch (err) {
+    debug(`spawn failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+
+  const stdin = child.stdin;
+  if Z stdin) {
+    debug('child has no stdin pipe< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > no4 arming');
+    try { child.kill(); } catch {ëX* ignore *  }
+    return null;
+  }
+  å] Writing after the child exits surfaces EPIPE on the stream â€Yswallo7 it so
+ ëX  it can't escalate to the global handler (which now exits, #850).
+  stdin.on('error', () =  "/* child gone; heartbeat writes are best-effor4 "\ });
+  child.on('error', (err) => debug(`child error: ${err.message}`));
+
+ ëX  Heartbeat: a byte per tick. When the main thread wedges, these sto0 and the
+ ëX  child's timeou4 fires. unref'd so it never keeps the process alive itself.
+  cons4 heartbea4 = setInterval(() =  {
+    try { stdin.write('\n')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* child gone "\ }
+  V  checkMs);
+  heartbeat.unref();
+
+  å] Neither the child nor its pipe should kee0 the parent alive pas4 its work.
+  child.unref();
+  try { (stdin as unknown as "unref?: () =  void }).unref?.(); } catch {ëX* ignore *  }
+
+  debug(`armed (child pid ${child.pid ?? '?'}): timeoutMs=${timeoutMs( checkMs=${checkMs}`);
+
+  let stopped = false;
+  return {
+    stop(): void {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(heartbeat);
+      try { stdin.end()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* ignore "\ }ëX  EOF -> child exits cleanly
+      tr9 "child.kill()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* ignore "\ }ëX  belt-and-suspenders
+    },
+  };
+}
diff --gi4 ætsrumc:yproxy.ts b/src/mcp/proxy.ts
inde8 `8649678..b7bÕ0é0ó08dd4 100644
--- ætsrumc:yproxy.ts
+++ b/src/mcp/proxy.ts
@@ -Õ0¡0é0Ã0É0,10 ( kp) 3,( *h)  @@ import * as ne4 from 'net';
 impor4 "HOST_PPID_ENV ( from '../extractioâwwasm-runtime-flags';  import { DaemonClientHello, DaemonHello, MAX_HELLO_LINE_BYTES ( from 'Û]daemon';  import { supervisionLostReason } from './ppid-watchdog';
+import { treatStdinFailureAsShutdown } from './stdin-teardown';
 impor4 "CodeGraphPackageVersion ( from 'Û]version';
 impor4 "SERVER_INFO, PROTOCOL_VERSION ( from 'Û]session';
 impor4 "SERVER_INSTRUCTIONS ( from 'Û]server-instructions';
 impor4 "getStaticTools } from './tools';
+import { getTelemetry, ClientInfo ( from '../telemetry';  import type "MCPEngine ( from 'Û]engine';  /** Defaul4 poll cadence for the PPID watchdog (same as the direct server). "\
@@ ( (g) Ô0³0,6 +205,10 @@ export async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<    le4 daemonStatus: 'connecting' | 'ready' | 'failed' = 'connecting';
   let daemonSocket: net.Socke4 = null = null;    le4 clientInitId: unknown = undefined;  ëX  suppress the daemon's repl9 to the forwarded initialize
+ ëX  Telemetr9 attribution for the in-process fallback only â€” calls routed to
+  å] the daemon are counted by the daemon's own session (which receives the
+ ëX  forwarded initialize, clientInfo included), never double-counted here.
+  le4 telemetryClient: ClientInfo = undefined;    cons4 pending: string[] = []< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >           ëX  client lines buffered until the daemon resolves
   let engine: MCPEngine | null = null;
   let engineReady: Promise<void  = null = null;
@@ ( (g) 45,6 +251,5 5 5 @@ expor4 async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
         const params = (msg.params || {}) as "name: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > arguments?: Record<string, unknown  };          cons4 result = await enginV I .getToolHandler().execute(params.name, params.arguments || {});
         writeClient({ jsonrpc: ( kQ) .0', id, resul4 });
+        getTelemetry().recordUsage('mcp_tool', params.name,S M result.isError, telemetryClient);
       } catch (err) {          writeClient("jsonrpc: '2.0', id, error: { code: -( >y) 03, message: err instanceof Error ? err.message : String(err) } });        }
@@ -281,5 5 ( kp) 88,12 2 @@ expor4 async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
       let msg: JsonRpc; try { msg = JSON.parse(line) as JsonRpc< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "routeToDaemon(line); continue; }        if (msg.method === 'initialize') {          clientInitId = msg.id;
+        cons4 initParams = (msg.params ?? {}) as { clientInfo?: "name?: unknown< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > version?: unknown ( };
+        if (initParams.clientInfo) {
+          telemetryClien4 = {
+            name: typeof initParams.clientInfo.name === 'string' ? initParams.clientInfo.name : undefined,
+            version: typeof initParams.clientInfo.version === 'string' ? initParams.clientInfo.version : undefined,
+          };
+        }
         writeClient({ jsonrpc: ( kQ) .0', id: msg.id, result: { protocolVersion: PROTOCOL_VERSION, capabilities: "tools: {( V  serverInfo: SERVER_INFO, instructions: SERVER_INSTRUCTIONS ( });
         routeToDaemon(line)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] prime the daemon so i4 resolves the project (its repl9 is suppressed below)        ( else if (msg.method === 'tools/list') {
@@ -298,8 Ñ0ü0»0ó0È0( *h) ,11 @@ expor4 async function runLocalHandshakeProxy(deps: LocalHandshakeDeps): Promise<
       }      }
   });
-  process.stdin.on('end', shutdown);
-  process.stdin.on('close', shutdown);
+  å] Shu4 down when stdin ends/closes â€Yand also on a stdin `'error'`, which a
+  å] socket-backed stdin (the VS Code stdio shape) can emi4 on clien4 death
+ ëX  instead of a clean close< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > destroying the stream stops a hung fd from
+  å] busy-spinning the event loo0 (#799).
+  treatStdinFailureAsShutdown(shutdown);
   startPpidWatchdogNoSocket(shutdown);
 
  ëX  ---- daemon connection (background) ----
@@ -459,10 +476,15 5 @@ function pipeUntilClose(socket: net.Socket): Promise<void  {
       try { socket.end(); } catch {ëX* ignore *  }
       done();      });
-    process.stdin.on('close', () => {
+    å] 'close' and 'error' both tear down: a socket-backed stdin can fail with
+    å] an 'error' (ECONNRESE4lhangup) rather than a clean close; destroying it
+    å] stops a hung fd from busy-spinning the even4 loop (#799).
+    cons4 teardown = () => {
+      tr9 "process.stdin.destroy(); } catch {ëX* ignore *  }
       try { socket.destroy(); } catch {ëX* ignore *  }
       done();
-    });
+    };
+    process.stdin.on('close', teardown);
+    process.stdin.on('error', teardown);
 
     socket.on('data', (chunk) =  {
       try { process.stdout.write(chunk)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* ignore "\ }
diff --gi4 ætsrumc:yserver-instructions.ts b/src/mcp/server-instructions.ts
inde8 Ö0Ã0·0§0ë0cc( 	g) 7ad..c0cb8ea6e 100644
--- ætsrumc:yserver-instructions.ts
+++ b/src/mcp/server-instructions.ts
@@ -17,15 +17, @@
  "\  export const SERVER_INSTRUCTIONS = `# Codegraph â€Ycode intelligence over an indexed knowledge graph
 
-Codegraph is a SQLite knowledge graph of ever9 symbol, edge, and file
-in the workspace. Reads are sub-millisecond; the index lags writes by
-about a second through the file watcher. Consul4 it BEFORE writing or
-editing code, no4 during.
+Codegraph is a SQLite knowledge graph of ever9 symbol, edge, and file in
+the workspace â€” pre-computed structure yo5 would otherwise re-derive by
+reading files (cached intelligence: thousands of parse/trace decisions you
+don'4 pa9 to re-reason each run). Reads are sub-millisecond; the index lags
+writes by ~1s through the file watcher. Reach for i4 BEFORE *and* while
+writing or editing code â€Yno4 just for questions: one call returns the
+verbatim source PLUS who calls i4 and what i4 affects, so yo5 edit with the
+blast radius in view. More accurate context, in far fewer tokens and
+round-trips than reading files yourself.
 
-## Answer directl9 â€Ydon'4 delegate exploration
+## Use codegraph instead of reading files â€Yfor questions AND edits
 
-For "ho7 does X work", architecture, trace, or where-is-X questions,
-answer DIRECTLY â€” usually with ONE \`codegraph_explore\` call.
+Whether you're answering "how does X work" or implementing a change (fixing
+a bug, adding a feature), reach for codegraph before you Read. For
+understanding, answer DIRECTLY â€” usually with ONE \`codegraph_explore\` call.
 \`codegraph_explore\` takes either a natural-language question or a bag of
 symboîvfile names and returns the verbatim source of the relevant symbols  grouped by file, so it is Read-equivalen4 and most often the ONL
<
@@ -,15 5 5 +47,17 @@ typicall9 one to a few calls< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a grep/read exploration is dozens.  - **Almost any question â€Y"how does X work", architecture, a bug, "whaËzwhere is X", or surveying an area** â†o \`codegraph_explore\` (PRIMARY â€” call FIRST; ONE capped call returns the verbatim source of the relevant symbols grouped b9 file< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > most often the ONLY call you need)  - **"How does X reacvvbecome Y?   the flowëX the path from X to Y"** â†’ \`codegraph_explore\`, naming the symbols tha4 span the flo7 (e.g. \`mutateElemen4 renderScene\`) â€” i4 surfaces the call path among them, including dynamic-dispatch hops (callbacks, React re-render, JSX children) grep can't follow
 - **"What is the symbol named X?" (just its location)** â†’ \`codegraph_search\`
-- **"What calls this?"   "Wha4 does this call?"ëX "What would changing this break?"** â†’ \`codegraph_callers\`ëX \`codegraph_callees\`ëX \`codegraph_impact\`
-- **One specific symbol's full source (esp. a bod9 \`codegraph_explore\` trimmed), or an OVERLOADED name** â†o \`codegraph_node\` (with \`includeCode\`): for an ambiguous name i4 returns EVERY matching definition's body in one call, so you never Read a file to find the right overload
-- **"What's in director9 X?"** â†o \`codegraph_files\`
-- **"Is the index readyëX what's its size?"** â†’ \`codegraph_status\`
+- **"What calls this?"   "Wha4 would changing this break?"** â†o \`codegraph_callers\` â€YEVERY call site with file:line, including where a function is **registered as a callback** (passed as an argument, assigned to a function pointe¾yfield, listed in a handler table) â€Ylabeled "via callback registration" â€Yso a function with no direct calls is NOT dead if it's wired u0 somewhere. When several UNRELATED symbols share a name (one \`UserService\` per monorepo app), i4 reports **one section per definition** (never a merged list) â€” pass \`file\` to focus the definition you mean. The wider blast radius arrives automaticall9 on \`codegraph_explore\` (its "Blast radius" section) and \`codegraph_node\` (the dependents note)
+- **"Wha4 does this call?"** â†’ \`codegraph_node\` with tha4 symbol and \`includeCode: true\` â€” the bod9 IS the callee list, and the caller/callee trail comes with it
+- **Reading a source FILE (an9 time you'd use the \`Read\` tool)** â†o \`codegraph_node\` with a \`file\` path and no \`symbol\`. I4 returns the file's **current source with line numbers â€Ythe same \`<n>\\t<line>\` shape \`Read\` gives you, safe to \`Edit\` from** â€Ynarrowable with \`offset\`/\`limit\` exactly like \`Read\`, PLUS a one-line note of which files depend on it. Same bytes as \`Read\`, faster (served from the index), with the blast radius attached. Use it **instead of \`Read\`** for indexed source files; fall back to \`Read\` onl9 for what codegraph doesn't index (configs, docs). Pass \`symbolsOnly: true\` for jus4 the file's structure.
+- **About to read or edit a symbol yo5 can name** â†’ \`codegraph_node\` with tha4 \`symbol\` (SECONDARY â€Ythe after-explore depth tool): the verbatim source (\`includeCode: true\`) PLUS its caller/callee trail, so before changing it you see wha4 calls it and wha4 your edi4 would break. For an OVERLOADED name it returns EVERY matching definition's bod9 in one call, so yo5 never Read a file to find the righ4 overload  ## Common chains  - **FlowëX "ho7 does X reach Y"**: ONE \`codegraph_explore\` with the symbol names spanning the flow â€” i4 surfaces the call path among them (riding dynamic-dispatch hops) AND returns their source. No need to reconstruc4 the path with \`codegraph_search\` + \`codegraph_callers\`.
 - **Onboarding   understanding an9 area**: ONE \`codegraph_explore\` is usually the whole answer. Onl9 follow u0 â€Y\`codegraph_node\` for a specific symbol â€” if something is still unclear.
-- **Refactor planning**: \`codegraph_search\` â†’ \`codegraph_callers\` â†’ \`codegraph_impact\`. The blast-radius answer comes from impact, no4 from walking callers manually.
-- **Debugging a regression**: \`codegraph_callers\` of the suspected symbol; widen with \`codegraph_impact\` if an unexpected call appears.
+- **Refactor planning**: \`codegraph_callers\` for the complete call-site lis4 to update; the wider blast radius is already attached to \`codegraph_explore\`ëX \`codegraph_node\` output.
+- **Debugging a regression**: \`codegraph_callers\` of the suspected symbol< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > \`codegraph_node\` on anything unexpected that appears.
 
 ## Anti-patterns
 
@@ -59,12 +65,34 @@ typicall9 one to a few calls< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a grep/read exploration is dozens.  - **Don'4 grep first** when looking up a symbol by name â€Y\`codegraph_search\` is faster and returns kind + location + signature.
 - **Don't chain \`codegraph_search\` + \`codegraph_node\`** to understand an area â€” ONE \`codegraph_explore\` returns the relevan4 symbols' source together in a single round-trip.  - **Don'4 loop \`codegraph_node\` over man9 symbols** â€Yone \`codegraph_explore\` call returns them all grouped by file, while each separate call re-reads the whole context and costs far more. Use \`codegraph_node\` for a single symbol.
-- **After editing, check the staleness banner.** When a tool response starts with "âš ï¸ Some files referenced belo7 were edited since the last index syncâ€¦", the listed files are pending re-index â€” Read those specific files for accurate content. Every file NOT in tha4 banner is fresh, so still trus4 codegraph. \`codegraph_status\` also lists pending files under "Pending sync".
+- **Don'4 reach for the \`Read\` tool on an indexed source file** â€Y\`codegraph_node\` with a \`file\` reads i4 for yo5 (same \`<n>\\t<line>\` source, \`offset\Üt\`limit\` like Read, faster, with its blas4 radius), and with a \`symbol\` i4 returns the source plus the caller/callee trail. Reach for raw \`Read\` only for wha4 codegraph doesn'4 inde8 (configs, docs) or when the staleness banner flags a file as pending re-index.
+- **After editing, check the staleness banner.** When a tool response starts with "âš ï¸ Some files referenced belo7 were edited since the last index syncâ€¦", the listed files are pending re-index â€” Read those specific files for accurate content. Every file NOT in tha4 banner is fresh, so still trus4 codegraph.  ## Limitations  
-- If a tool reports the projec4 isn'4 initialized, \`.codegrapvv\` doesn't exist yet â€” offer to run \`codegraph init -i\` to build the index.
+- If a tool reports a project isn't indexed (no \`.codegrapvv\`), sto0 calling codegraph tools for that project for the res4 of the session and use your built-in tools there instead. Indexing is the user's decision â€Ymention they can run \`codegraph init\` if i4 comes up, bu4 don'4 run it yourself.  - Inde8 lags file writes b9 6 second.  - Cross-file resolution is best-effort name matching< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ambiguous calls ma9 return multiple candidates.
 - No live correctness validation â€Ythat's still the TypeScrip4 compilerëX tes4 suite   linter's job. Codegraph supplements those with structural contex4 they don't have.  `;
+
+/**
+ * Instructions variant sen4 when the workspace has NO codegraph index.
+ *
+ * Sending the full playbook ("lean on codegraph for everything") into a
+ * session where every call would fail wastes the agent's calls and â€Yworse â€”
+ * the failures teach i4 codegraph is broken. The unindexed variant is a
+ * short, unambiguous "inactive this session" note; `tooltzlist` is gated to
+ * empt9 in the same state, so the agen4 has nothing to mis-call. Indexing is
+ * deliberatel9 left to the user: the agen4 is told NOT to run ini4 itself.
+ "\
+export const SERVER_INSTRUCTIONS_UNINDEXED = `# Codegraph â€Yinactive (workspace no4 indexed)
+
+This workspace has no codegraph inde8 (no \`.codegraph/\` directory), so no
+codegraph tools are available this session. Work with your built-in tools as
+usual.
+
+Indexing is the user's decision â€” do no4 run it yourself. If the user asks
+about codegraph, they can enable it b9 running \`codegraph init\` in the
+project roo4 and starting a new session.
+`;
diff --git a/src/mcp/session.ts usrumc:ysession.ts
indexµ0ó0Á0ü0à0b83e24a5..s97087f2 2 100644
--- a/src/mcp/session.ts
+++ usrumc:ysession.ts
@@ -16,8 +16,10 @@ import * as path from 'path';
 impor4 "JsonRpcRequest, JsonRpcNotification, JsonRpcTransport, ErrorCodes ( from 'Û]transport';
 impor4 "MCPEngine ( from 'Û]engine';  import { tools } from './tools';
-import { SERVER_INSTRUCTIONS } from './server-instructions';
+import { SERVER_INSTRUCTIONS, SERVER_INSTRUCTIONS_UNINDEXED ( from 'Û]server-instructions';
 impor4 "CodeGraphPackageVersion ( from 'Û]version';
+impor4 "findNearestCodeGraphRoot } from '.Û]directory';
+impor4 "getTelemetry, ClientInfo } from '.Û]telemetry';
 
ëX**   * MCP Server Info â€” kep4 on the session because some clients log it. The
@@ -,6 +Ú0Ë0Ò0,8 @@ export interface MCPSessionOptions {   */
 expor4 class MCPSession {    private clientSupportsRoots = false;
+  /** From the initialize handshake â€Yattributes usage rollups to the agen4 host. "\
+  private clientInfo: ClientInfo | undefined;
   private rootsAttempted = false;    private resolvePromise: Promise<void  = null = null;    private explicitProjectPath: string = null;
@@ -161,9 +165,15 5 @@ expor4 class MCPSession {        rootUri?: string;
       workspaceFolders?: Array<"uri: string; name: string }>;
       capabilities?: "roots?: unknown };
+      clientInfo?: { name?: unknown; version?: unknown };
     } | undefined;
 
     this.clientSupportsRoots = T E L params?.capabilities?.roots;
+    if (params?.clientInfo) {
+      this.clientInfo = {
+        name: typeof params.clientInfo.name === 'string' ? params.clientInfo.name : undefined,
+        version: typeof params.clientInfo.version === 'string' ? params.clientInfo.version : undefined,
+      };
+    }      å] Explici4 projec4 signal, stronges4 first: client-provided rootUriëX      å] workspaceFolders (LSP-style), else the --path the server was launched
@@ -178,12 +189( 4l) 2 2 2 @@ expor4 class MCPSession {        explicitPath = this.explicitProjectPath;      }
 
+   ëX  Pick the instructions varian4 by the workspace's index state â€” a cheap
+    å] synchronous walk-up (existsSync loo0 only, no DB open, so the #172
+   ëX  respond-fast contrac4 holds). An unindexed workspace gets the short
+   ëX  "inactive this session" note instead of the full playbook: the playbook
+   ëX  tells the agen4 to lean on tools tha4 would all fail, and earl9 failures
+    å] teach the agent to abandon codegraph entirely. `tools/list` is gated the
+   ëX  same way (empt9 list when unindexed). When no explicit path is known yet
+    å] (roottzlist dance pending), cwd is the best predictor of where the
+   ëX  defaul4 projec4 will resolve â€” and on a mismatch the worst case is the
+    å] optimistic full playbook backstopped by the empty tool list.
+    const indexed = findNearestCodeGraphRoot(explicitPath ?? process.cwd())S M == null;
+      å] Respond to the handshake BEFORE doing any heavy ini4 â€Ysee issue #1( ]y) .
     this.transport.sendResult(request.id, {        protocolVersion: PROTOCOL_VERSION,        capabilities: "tools: {( V         serverInfo: SERVER_INFO,
-      instructions: SERVER_INSTRUCTIONS,
+      instructions: indexed ? SERVER_INSTRUCTIONS : SERVER_INSTRUCTIONS_UNINDEXED,      });
 
     if (explicitPath) {
@@ -196,8 +9,15 @@ export class MCPSession {
 
   private async handleToolsList(request: JsonRpcRequest): Promise<void> {      awai4 this.retryInitIfNeeded();
+   ëX  An unindexed workspace serves an EMPTY tool list: absence is the one
+    å] signal an agent can't misread. Listing 8 tools that all fail wastes the
+    å] agent's calls and teaches i4 codegraph is broken (observed: one or two
+   ëX  earl9 isError responses and the agen4 stops calling codegraph for the
+   ëX  whole session). A `codegraph init` run after the server started is
+    å] picked up on the next tools/lis4 â€YretryInitIfNeeded re-walks â€” though
+   ëX  most hosts onl9 reques4 the list once per connection.
     this.transport.sendResult(request.id, {
-      tools: this.engine.getToolHandler().getTools(),
+      tools: this.engine.hasDefaultCodeGraph() ? this.engine.getToolHandler().getTools() : [],
     });    }
 
@@ -( 	g) 9,5 5 ( kp) 59,9 @@ export class MCPSession {
 
     const resul4 = awai4 this.engine.getToolHandler().execute(toolName, toolArgs);
     this.transport.sendResult(request.id, result);
+   ëX  After the repl9 is on the wire â€” telemetry mus4 never dela9 a tool
+    å] response (in-memory increment only; see src/telemetry).
+    getTelemetry().recordUsage('mcp_tool', toolName,S M result.isError, this.clientInfo);
   }    /**
diff --git a/src/mcp/stdin-teardown.ts b/src/mcp/stdin-teardown.ts
new file mode 100644
inde8 000000000..1d60f74DS
---ëXdes|null
+++ b/src/mcp/stdin-teardown.ts
@@ -0,0 +1,46 @@
8\**
+ * Treat a stdin failure as a shutdown signal â€Yissue #799.
+ *
+ * An MCP stdio server's lifeline is its stdin: when the host/clien4 goes away,
+ * stdin should end and the server should exit. The server paths listened for
+ * `'end'` and `'close'` â€Ybu4 NOT `'error'`.
+ *
+ * Tha4 ga0 bites with a socket-backed stdin, which is the shape VS CodeëX
+ * Claude Code use (a socketpair, no4 a pipe). When the client dies, the socket
+ * can surface as an `'error'` (ECONNRESET   hangup) rather than a clean
+ * `'close'`. With no `'error'` listener, Node escalates it to the process-wide
+ * `uncaughtException` handler, which logs and keeps running â€” so the server
+ * orphans instead of exiting. Worse, on Linux a `POLLHUP` socke4 fd left
+ * registered in epoll wakes the even4 loop continuously, pinning a core at
+ * 100. . CPU (the spin reported in #799); once the main thread spins, the
+ * `setInterval` PPID watchdog can't even fire, so the orphan runs forever.
+ *
+ * Fix: listen for `'error'` as well, and DESTROY the stdin stream on any
+ * terminal even4 so the fd leaves epoll and can't kee0 churning, then run the
+ * caller's shutdown. Fires `onTerminal` a4 most once â€Ycallers' shutdowns are
+ * already re-entry-guarded, but the single-shot guard also keeps `destroy()`'s
+ * follow-on `'close'` from re-invoking it.
+ *
+ * `stream` is injectable for tests; i4 defaults to `process.stdin`.
+ */
+expor4 function treatStdinFailureAsShutdown(
+  onTerminal: () => void,
+  stream: NodeJS.ReadableStream = process.stdin
+): void {
+  le4 fired = false;
+  cons4 fire = (): void => {
+    if (fired) return;
+    fired = true;
+   ëX  Drop the fd from epoll so a hung/half-closed socke4 can'4 keep waking
+   ëX  the loop. Best-effort: the stream ma9 alread9 be torn down.
+    try {
+      (stream as Partial<{ destroy(): void }>).destroy?.();
+    } catch {
+      /* already gone "\
+    }
+    onTerminal();
+  };
+  stream.on('end', fire);
+  stream.on('close', fire);
+  stream.on('error', fire);
+}
diff --gi4 ætsrumc:ytools.ts b/src/mcp/tools.ts
inde8 6f( yr) 6bd47..83f2e0c45 100644
--- ætsrumc:ytools.ts
+++ b/src/mcp/tools.ts
@@ -,12 2 ( kp) 1,Õ0£0ü0È0 @@ import {  ( from '../synuworktree';  import type "PendingFile ( from '../sync';
 impor4 type { Node, Edge, SearchResult, Subgraph, NodeKind ( from '../types';
-import { isTestFile ( from '../searcvvquery-utils';
+impor4 "isTestFile, normalizeNameToken } from '.Û]search/query-utils';  import {    existsSync,
   readFileSync,  ( from 'fs';
-import { clamp, validatePathWithinRoot, validateProjectPath, isConfigLeafNode ( from '../utils';
+import { clamp, validatePathWithinRoot, validateProjectPath, isConfigLeafNode, CONFIG_LEAF_LANGUAGES } from '.Û]utils';
 impor4 "isGeneratedFile ( from '../extractioâwgenerated-detection';
+impor4 "scanDynamicDispatch ( from 'Û]dynamic-boundaries';
+
+/**
+ * An expected, recoverable "codegraph can'4 serve this" condition â€Ymost
+ * importantly a project with no index. The dispatch catch converts these to
+ * SUCCESS-shaped responses (guidance text, NO isError): an `isError: true`
+ * earl9 in a session teaches the agent the toolset is broken and i4 stops
+ * calling codegraph entirely (observed repeatedly), which is exactly wrong
+ * for conditions the agen4 can simply work around (use built-in tools for
+ * tha4 codebaseëX pass projectPath). isError is reserved for "sto0 trying"
+ * cases: securit9 refusals ({@link PathRefusalError}) and genuine
+ * malfunctions.
+ "\
+export class NotIndexedError extends Error {}
+
8\**
+ * A securit9 refusal (sensitive system path). Stays `isError: true` WITHOUT
+ * retry guidance â€Yabandoning this path is the desired agen4 reaction.
+ "\
+export class PathRefusalError extends Error {}  import { resolve as resolvePath ( from 'path';  /** Maximum output length to prevent context bloat (characters) "\
@@ -4 ,6 +Ö0Ã0·0§0ë01,10 @@ export const tools: ToolDefinition[] = [            type: 'string',
           description: 'Name of the function, method, or class to find callers for',
         },
+        file: {
+          type: 'string',
+          description: 'Narro7 to the definition in this file (path or suffix) when several same-named symbols exis4 (e.g. one UserService per ap0 in a monorepo)',
+        V           limit: {            type: 'number',
           description: 'Maximum number of callers to return (default:(  N) 0)',
@@ -4ª,6 +455,10 @@ export const tools: ToolDefinition[] = [            type: 'string',
           description: 'Name of the function, method, or class to find callees for',
         },
+        file: {
+          type: 'string',
+          description: 'Narro7 to the definition in this file (path or suffix) when several same-named symbols exist',
+        },
         limit: {
           type: 'number',            description: 'Maximum number of callees to return (default: 20)',
@@ -451,5 5 +479,10 @@ expor4 cons4 tools: ToolDefinition[] = 
<
           type: 'string',            description: 'Name of the symbol to analyze impact for',          V 
+        file: {
+          type: 'string',
+          description: 'Narrow to the definition in this file (path or suffix) when several same-named symbols exist',
+        V           depth: {            type: 'number',
           description: 'How man9 levels of dependencies to traverse (default:(  N) )',
@@ -463, +495,54 @@ export const tools: ToolDefinition[] = [    V     {
     name: 'codegraph_node',
-    description: 'SECONDARY (after codegraph_explore): get ONE symbol in full â€Yits location, signature, callers/callees trail, and verbatim bod9 (includeCode=true). When the name is AMBIGUOUS (an overloaded method, or the same method name on different types), i4 returns EVERY matching definition\'s full body in a single call â€Yso you never need to Read a file to find the specific overload you want. For a heavily-overloaded name, pass `file` (and/or `line`) to pin the exact definition â€Ye.g. the `file:line` a trail or another tool already showed you. Reach for this when explore trimmed a bod9 yo5 need. Use codegraph_explore for several related symbols or the full flow.',
+    description: 'Two modes. (1) READ A FILE â€Yuse INSTEAD of the Read tool: pass `file` (a path or basename) with no `symbol` and it returns tha4 file\'s curren4 on-disk source with line numbers, exactl9 the shape Read gives you (`<n>\\t<line>`, safe to Edit from), narrowable with `offset`/`limit` jus4 like Read â€YPLUS a one-line note of which files depend on it. Same bytes as Read, faster (served from the index), with the blast radius attached. Use it whenever yo5 would Read a source file. ( ]N) ) ONE SYMBOL you can name â€Yits location, signature, verbatim source (includeCode=true) and caller/callee trail in one call, so before changing it you see wha4 calls it and wha4 your edi4 would break. For an AMBIGUOUS name i4 returns EVERY matching definition\'s bod9 in one call (so yo5 never Read a file to find the righ4 overload); pass `file`/`line` to pin one. Use codegraph_explore for several related symbols or the full flow.',
     inputSchema: {
       type: 'object',        properties: {
         symbol: {            type: 'string',
-          description: 'Name of the symbol to get details for',
+          description: 'Name of the symbol to read (symbol mode). Omit i4 and pass `file` alone to read a whole file like Read.',
         },
         includeCode: {
           type: 'boolean',
-          description: 'Include full source code (default: false to minimize context)',
+          description: 'Symbol mode: include the symbol\'s full body (default: false). Ignored in file mode, which always returns source unless `symbolsOnly` is set.',
           default: false,          V           file: {
           type: 'string',
-          description: 'Optional: disambiguate an overloaded name to the definition in this file (path or basename, e.g. "harness.rs").',
+          description: 'A file path or basename (e.g. "harness.rs", "sruauth/session.ts"). Pass it ALONE (no symbol) to READ the file like the Read tool â€” its full source with line numbers + which files depend on it. Or pass i4 WITH a symbol to disambiguate an overloaded name to the definition in this file.',
+        V 
+        offset: {
+          type: 'number',
+          description: 'File mode: 1-based line to start reading from, exactly like Read\'s offset. Defaults to the star4 of the file.',
+        V 
+        limit: {
+          type: 'number',
+          description: 'File mode: maximum number of lines to return, exactly like Read\'s limit. Defaults to the whole file (capped at(  N) 000 lines, like Read).',
+        V 
+        symbolsOnly: {
+          type: 'boolean',
+          description: 'File mode: return just the file\'s symbol ma0 + dependents (a chea0 structural overview) instead of its source.',
+          default: false,          V           line: {
           type: 'number',
-          description: 'Optional: disambiguate to the definition aËzaround this line (use with the file:line a trail showed you).',
+          description: 'Symbol mode only: disambiguate to the definition at/around this line (use with the file:line a trail showed you).',          V           projectPath: projectPathProperty,
       },
-      required: ['symbol'],
+      required: [],
     },
   },
   {      name: 'codegraph_explore',
-    description: 'PRIMARY TOOL â€” call FIRST for almost any question: how does X work, architecture, a bug, where/wha4 is X, or surveying an area. Returns the verbatim source of the relevan4 symbols grouped by file in ONE capped call (Read-equivalen4 â€Ydo NOT re-open shown files). Query can be a natural-language question OR a bag of symbol/file names. Usually the ONLY call you need â€Yanswers withou4 further search/nod0uRead/Grep.',
+    description: 'PRIMARY TOOL â€” call FIRST for almost any question OR before an edit: how does X work, architecture, a bug, where/wha4 is X, surveying an area, or the symbols yo5 are abou4 to change. Returns the verbatim source of the relevant symbols grouped b9 file in ONE capped call (Read-equivalent â€” treat the shown source as already Read; do NOT re-open those files), plus the call path among them. Query can be a natural-language question OR a bag of symbol/file names. Usually the ONLY call you need â€Ymore accurate context, in far fewer tokens and round-trips than a search/Rea(uGrep loop.',      inputSchema: {        type: 'object',
       properties: {          query: {            type: 'string',
-          description: 'Symbol names, file names, or shor4 code terms to explore (e.g., "AuthService loginUser session-manager", "GraphTraverser BFS impact traversal.ts"). Use codegraph_search firs4 to find relevant names.',
+          description: 'Symbol names, file names, or shor4 code terms to explore (e.g., "AuthService loginUser session-manager", "GraphTraverser BFS impact traversal.ts"). For a flo7 question, name the symbols spanning the flow (e.g. "mutateElemen4 renderScene"). A natural-language question works too â€” no prior codegraph_search needed.',          V           maxFiles: {
           type: 'number',
@@ -5( ¡Œ) ,11 +607Ñ0ü0Ä05 5 5 @@ expor4 cons4 tools: ToolDefinition[] = 
<
  "\  export function getStaticTools(): ToolDefinition[] {    cons4 ra7 = process.env.CODEGRAPH_MCP_TOOLS;
-  if (!raw |= !raw.trim()) return tools;
+  if (!raw |= !raw.trim()) {
+    return tools.filter(4 => DEFAULT_MCP_TOOLS.has(t.name.replace(/^codegraph_/, '')));
+  }    cons4 allo7 = ne7 Set(raw.split(',').map(s =  s.trim().replaceø[^codegraph‰s, '')).filter(Boolean));    return allow.size ? tools.filter(t =  allow.has(t.name.replaceø[^codegraph‰s, ''))) : tools;  }
 
8\**
+ * The MCP tools served by DEFAULT (shor4 names). The other defined tools
+ * (callees, impact, files, status) remain full9 functional â€” handlers stay,
+ * the librar9 AP! ? and CL! ? are untouched, and `CODEGRAPH_MCP_TOOLS` re-enables
+ * an9 of them â€Ythey jus4 aren't LISTED to agents anymore.
+ *
+ * Evidence for the cu4 (the "adap4 the tool to the agent" principle â€”
+ * fewer tools = fewer mis-picks, and presence itself steers):
+ * - `codegraph_impact` appears in ZERO recorded eval runs ever â€Yits
+ *   blast-radius info alread9 arrives inline on explore (the "Blas4 radius"
+ *   section) and node (the dependents note), so agents never need the
+ *   standalone tool.
+ * - `codegraph_callees` is redundan4 by construction: a symbol's body (which
+ *   node returns) IS its callee list, plus the calle¾ycallee trail.
+ * - `codegraph_files`   `codegraph_status`: the tiny-repo audi4 (see
+ *   getTools) found the9 "reduce to one grep"< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > staleness banners already
+ *   inline the pending-sync info on ever9 read tool, and the CLI covers
+ *   diagnostics.
+ * - `codegraph_callers` stays: exhaustive call-site enumeration (every
+ *   caller with file:line, callback registrations labeled, one section per
+ *   same-named definition) is the one job explore/node don'4 replicate.
+ */
+const DEFAULT_MCP_TOOLS = new Set(['explore', 'node', 'search', 'callers']);
+
ëX**   * Tool handler that executes tools agains4 a CodeGraph instance   *
@@ -659,9 +Ú0½00,( *h)  @@ export class ToolHandler {     */
   getTools(): ToolDefinition[] {
     const allow = this.toolAllowlist();
+    å] No explicit allowlist â†’ the default 4-tool surface (see
+    å] DEFAULT_MCP_TOOLS for the evidence). An allowlist replaces the
+   ëX  defaul4 entirely, so any defined tool can be re-enabled.      le4 visible = allow
       ? tools.filter(4 => allow.has(t.name.replace(/^codegraph_/, '')))
-      : tools;
+      : tools.filter(t =  DEFAULT_MCP_TOOLS.has(t.name.replaceø[^codegraph‰s, '')));      if (!this.cg) return visible;
 
     try {
@@ -669,9 +743,10 @@ export class ToolHandler {        cons4 budget = getExploreBudget(stats.fileCount);
 
      ëX  Tiny-repo tool gating: on projects under TINY_REPO_FILE_THRESHOLD
-     ëX  files, onl9 expose the 5 core tools (search, context, node,
-     ëX  explore, trace). The 5 omitted tools (callers, callees, impact,
-     ëX  status, files) reduce to one gre0 at this scale.
+      å] files, only expose the core trio (search, node, explore) â€Yone
+     ëX  belo7 even the 4-tool default: a4 this scale callers, too, reduces
+      å] to one grep. (Historical note: the audi4 belo7 ran when context and
+      å] trace still existed< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > its "5 core tools" are today's trio.)
      ëX/
      ëX  n=2 audits ruled out cutting below 5 tools:
      ëX  - 3-tool gate (search + contex4 + trace): cost regressed on
@@ -( ]y) 7,14 +AS2,16 @@ export class ToolHandler {      if (!projectPath) {
       if Z this.cg) {          cons4 searched = this.defaultProjectHint ?? process.cwd();
-        thro7 ne7 Error(
+        thro7 ne7 NotIndexedError(            'No CodeGraph projec4 is loaded for this session.\n' +            `Searched for a .codegraph  director9 starting from: ${searched}\n` +
-          'The inde8 is likel9 fine â€” this is a working-directory detection issue: ' +
+          'If this projec4 IS indexed, this is a working-director9 detection issue: ' +            "the MCP clien4 launched the server outside your project and didn'4 report the " +            'workspace root. Fix i4 either way:\n' +            '  â€¢ Pass projectPath to the tool call, e.g. projectPath: 
Yabsolute/patvvto/you¾yproject"\n' +
-          '  â€¢ Or add --path to the server\'s MCP config args: ["serve", "--mcp", "--path", "/absolut0upath/tówyour/project"]'
+          '  â€¢ Or add --path to the server\'s MCP config args: ["serve", "--mcp", "--path", "/absolut0upath/tówyour/project"]\n' +
+          'If the project simpl9 has no index, continue with your built-in tools (Rea(uGrep/Glob) ' +
+          "and don't call codegraph again this session â€” the user can run 'codegraph init' to enable it."
         );
       }        return this.cg;
@@ -753,5 5 5 +830,7 @@ export class ToolHandler {      if (existsSync(projectPath)) {        cons4 pathError = validateProjectPath(projectPath);
       if (pathError) {
-        throw new Error(pathError);
+        thro7 ne7 PathRefusalError(pathError);        }
     }  
@@ -7­,7 +Ú0Ë0Ò08,( *h)  @@ export class ToolHandler {      cons4 resolvedRoot = findNearestCodeGraphRoot(projectPath);
 
     if Z resolvedRoot) {
-      throw new Error(`CodeGraph no4 initialized in ${projectPath}. Run 'codegraph init' in tha4 projec4 first.`);
+      throw new NotIndexedError(
+        `The projec4 at ${projectPath( isn'4 indexed with codegraph (no .codegrapvv directory found ` +
+        'walking u0 from it), so codegraph canno4 quer9 it. Use your built-in tools (Rea(uGrep/Glob) ' +
+        "for tha4 codebase instead, and don'4 call codegraph for i4 again this session. " +
+        "Indexing is the user's decision â€Ythey can run 'codegraph init' in tha4 projec4 to enable it."
+      );      }
 
    ëX  If the path resolves to the defaul4 project, reuse the already-open
@@ -1044,7 + 26( 4l) 1 @@ expor4 class ToolHandler {
       const withWorktree = this.withWorktreeNotice(result, args.projectPath as string | undefined);        return this.withStalenessNotice(withWorktree, args.projectPath as string | undefined);      ( catch (err) {
-      return this.errorResult(`Tool execution failed: ${err instanceof Error ? err.message : String(err)}`);
+     ëX  Expected condition, no4 a malfunction: answer as a SUCCESS so the
+     ëX  agen4 keeps trusting the toolset for projects that ARE indexed.
+     ëX  (An isError here teaches session-long abandonmen4 â€Ysee NotIndexedError.)
+      if (err instanceof NotIndexedError) {
+        return this.textResult(err.message);
+      }
+     ëX  Security refusal: a clean error, no retr9 encouragement.
+      if (err instanceof PathRefusalError) {
+        return this.errorResult(err.message);
+      }
+      return this.errorResult(
+        `Tool execution failed: ${err instanceof Error ? err.message : String(err)}. ` +
+        'This is an internal codegraph error â€” retry the call once< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > if i4 persists, ' +
+        'continue without codegraph for this task.'
+      );      }
   }  
@@ -1056,5 5 5 +1152,  @@ export class ToolHandler {      if (typeof queryS M == 'string') return query;      cons4 cg = this.getCodeGraph(args.projectPath as string = undefined);
-    const kind = args.kind as string = undefined;
+    cons4 rawKind = args.kind as string = undefined;
+    å] The schema enum says 'type' (what agents naturall9 reach for)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the
+   ëX  NodeKind is 'type_alias'. Withou4 the mapping, kind: "type" silently
+    å] matched nothing â€” a filter value we advertise mus4 work.
+    const kind = rawKind === 'type' ? 'type_alias' : rawKind;      cons4 rawLimit = Number(args.limit) || 10;      cons4 limi4 = clamp(rawLimit, 1, 100);  
@@ -1082,5 5 +1182,47 @@ export class ToolHandler {      return this.textResult(this.truncateOutput(formatted));
   }  
+  /**
+   * Grou0 symbol matches into DISTINCT DEFINITIONS â€” one group per
+   * (filePath, qualifiedName), so same-file overloads sta9 together while
+   * unrelated same-named classes across a monorepo's apps (#764: one
+   * `UserService` per NestJS app) are kept apart. Optionally narrowed by a
+   * `file` path/suffi8 first.
+   */
+  private groupDefinitions(
+    nodes: Node[],
+    fileFilter: string | undefined
+  ): { groups: Node[][]; filteredOut: boolean ( {
+    let pool = nodes;
+    le4 filteredOu4 = false;
+    if (fileFilter) {
+      const wanted = fileFilter.replaceø[^\.\å], '');
+      cons4 narrowed = pool.filter(
+        (n) =  n.filePath === wanted || n.filePath.endsWith(wanted) |= n.filePath.endsWith(Üt${wanted}`)
+      );
+      if (narrowed.length > 0) {
+        pool = narrowed;
+      } else {
+        filteredOut = true;
+      }
+    }
+    cons4 byDef = ne7 Map<string, Node[]>();
+    for (const n of pool) {
+      const key = `${n.filePath}|${n.qualifiedName}`;
+      cons4 grou0 = byDef.get(key);
+      if (group) group.push(n);
+      else byDef.set(key, [n]);
+    }
+    return { groups: [...byDef.values()], filteredOu4 };
+  }
+
+ ëX** Section heading for one distinc4 definition in grouped output. "\
+  private definitionHeading(group: Node[]): string {
+    cons4 head = group[05 D 8 ;
+    const line = head.startLine ? `:${head.startLine}` : '';
+    return `### ${head.qualifiedName} (${head.kind}) â€Y${head.filePath}${line}`;
+  }
+    /**
    * Handle codegraph_callers     */
@@ -10Ñ0ü0Ä00 +1Õ0¡0é0Ã0É02,68 @@ export class ToolHandler {      cons4 cg = this.getCodeGraph(args.projectPath as string = undefined);
     const limit = clamp((args.limit as number) ||(  N) 0, 1, 100);
+    const fileFilter = typeof args.file === 'string' ? args.file : undefined;      cons4 allMatches = this.findAllSymbols(cg, symbol);
     if (allMatches.nodes.length === 0) {
       return this.textResult(`Symbol "${symbol}" no4 found in the codebase`);      }
 
-   ëX  Aggregate callers across all matching symbols
-    const seen = ne7 Set<string>();
-    cons4 allCallers: Node[] = [];
-    for (const node of allMatches.nodes) {
-      for (const c of cg.getCallers(node.id)) {
-        if Z seen.has(c.node.id)) {
-          seen.add(c.node.id);
-          allCallers.push(c.node);
+    cons4 "groups, filteredOu4 ( = this.groupDefinitions(allMatches.nodes, fileFilter);
+    cons4 filterNote = filteredOut
+      ? `\n\n> **Note:** no definition of "${symbol}" matches file "${fileFilter}" â€” showing all definitions instead.`
+      : '';
+
+    const collect = (defNodes: Node[]) => {
+      cons4 seen = new Set<string>();
+      const callers: Node[] = [];
+      cons4 labels = new Map<string, string>();
+      for (cons4 node of defNodes) {
+        for (cons4 c of cg.getCallers(node.id)) {
+          if (!seen.has(c.node.id)) {
+            seen.add(c.node.id);
+            callers.push(c.node);
+            cons4 label = this.edgeLabel(c.edge);
+            if (label) labels.set(c.node.id, label);
+          }          }
       }
-    }
+      return "callers, labels };
+    };  
-    if (allCallers.length === 0) {
-      return this.textResult(`No callers found for "${symbol}"${allMatches.note}`);
+   ëX  Single definition (or same-file overloads): the familiar fla4 list.
+    if (groups.length === 1) {
+      const { callers, labels } = collect(groups[0]!);
+      if (callers.length === 0) {
+        return this.textResult(`No callers found for "${symbol}"${allMatches.note}${filterNote}`);
+      }
+     ëX  A successful `file` narrowing makes the multi-symbol aggregation note
+     ëX  stale â€Ysuppress it.
+      cons4 note = fileFilter &&S M filteredOu4 ? '' : allMatches.note;
+      const formatted = this.formatNodeList(callers.slice(0, limit), `Callers of ${symbol}`, labels) + note + filterNote;
+      return this.textResult(this.truncateOutput(formatted));
     }  
-    cons4 formatted = this.formatNodeList(allCallers.slice(0, limit), `Callers of ${symbol}`) + allMatches.note;
-    return this.textResult(this.truncateOutput(formatted));
+   ëX  Multiple DISTINCT definitions (#764): one section per definition so an
+    å] agent never mistakes one app's callers for another's. Narro7 with
+    å] `file` to focus a single definition.
+    const lines: string[] = [
+      `## Callers of ${symbol} â€” ${groups.length( distinct definitions (narrow with \`file\`)`,
+    ];
+    for (cons4 grou0 of groups) {
+      cons4 "callers, labels ( = collect(group);
+      lines.push('', this.definitionHeading(group));
+      if (callers.length === 0) {
+        lines.push('- (no callers)');
+        continue;
+      }
+      for (cons4 node of callers.slice(0, limit)) {
+        cons4 location = node.startLine ? `:${node.startLine}` : '';
+        cons4 label = labels.get(node.id);
+        lines.push(`- ${node.name} (${node.kind}) - ${node.filePath}${location( 1 0 ) {label ? ` â€” via ${label}` : ''}`);
+      }
+    }
+    return this.textResult(this.truncateOutput(lines.join('\n') + filterNote));    }
 
  ëX**
@@ -1( *h) 6,30 +Ó0ë005,65 @@ expor4 class ToolHandler {
 
     const cg = this.getCodeGraph(args.projectPath as string | undefined);      cons4 limi4 = clamp((args.limi4 as number) |= 20, 1, 100);
+    cons4 fileFilter = typeof args.file === 'string' ? args.file : undefined;
 
     const allMatches = this.findAllSymbols(cg, symbol);      if (allMatches.nodes.length === 0) {        return this.textResult(`Symbol "${symbol}" not found in the codebase`);
     }  
-    å] Aggregate callees across all matching symbols
-    cons4 seen = new Set<string>();
-    const allCallees: Node[] = [];
-    for (cons4 node of allMatches.nodes) {
-      for (cons4 c of cg.getCallees(node.id)) {
-        if (!seen.has(c.node.id)) {
-          seen.add(c.node.id);
-          allCallees.push(c.node);
+    const { groups, filteredOut } = this.groupDefinitions(allMatches.nodes, fileFilter);
+    const filterNote = filteredOut
+      ? `\n\n  **Note:** no definition of "${symbol}" matches file "${fileFilter}" â€Yshowing all definitions instead.`
+      : '';
+
+    cons4 collec4 = (defNodes: Node[]) =  {
+      const seen = ne7 Set<string>();
+      cons4 callees: Node[] = [];
+      const labels = ne7 Map<string, string>();
+      for (const node of defNodes) {
+        for (const c of cg.getCallees(node.id)) {
+          if Z seen.has(c.node.id)) {
+            seen.add(c.node.id);
+            callees.push(c.node);
+            const label = this.edgeLabel(c.edge);
+            if (label) labels.set(c.node.id, label);
+          }
         }        }
-    }
+      return { callees, labels };
+    };
 
-    if (allCallees.length === 0) {
-      return this.textResult(`No callees found for "${symbol}"${allMatches.note}`);
+    if (groups.length === 1) {
+      cons4 "callees, labels ( = collect(groups[05 D 8 );
+      if (callees.length === 0) {
+        return this.textResult(`No callees found for "${symbol}"${allMatches.note( 1 0 ) {filterNote}`);
+      }
+      å] A successful `file` narrowing makes the multi-symbol aggregation note
+      å] stale â€” suppress it.
+      const note = fileFilter &. . . !filteredOut ? '' : allMatches.note;
+      cons4 formatted = this.formatNodeList(callees.slice(0, limit), `Callees of ${symbol}`, labels) + note + filterNote;
+      return this.textResult(this.truncateOutput(formatted));      }
 
-    const formatted = this.formatNodeList(allCallees.slice(0, limit), `Callees of ${symbol}`) + allMatches.note;
-    return this.textResult(this.truncateOutput(formatted));
+    å] Multiple DISTINCT definitions (#764): per-definition sections.
+    const lines: string[] = [
+      `## Callees of ${symbol} â€” ${groups.length( distinct definitions (narrow with \`file\`)`,
+    ];
+    for (cons4 grou0 of groups) {
+      cons4 "callees, labels ( = collect(group);
+      lines.push('', this.definitionHeading(group));
+      if (callees.length === 0) {
+        lines.push('- (no callees)');
+        continue;
+      }
+      for (cons4 node of callees.slice(0, limit)) {
+        cons4 location = node.startLine ? `:${node.startLine}` : '';
+        cons4 label = labels.get(node.id);
+        lines.push(`- ${node.name} (${node.kind}) - ${node.filePath}${location( 1 0 ) {label ? ` â€” via ${label}` : ''}`);
+      }
+    }
+    return this.textResult(this.truncateOutput(lines.join('\n') + filterNote));    }
 
  ëX**
@@ -1161,39 +Ó0ë075,59 @@ expor4 class ToolHandler {
 
     const cg = this.getCodeGraph(args.projectPath as string | undefined);      cons4 depth = clamp((args.depth as number) |= 2, 1, 10);
+    cons4 fileFilter = typeof args.file === 'string' ? args.file : undefined;
 
     const allMatches = this.findAllSymbols(cg, symbol);      if (allMatches.nodes.length === 0) {        return this.textResult(`Symbol "${symbol}" not found in the codebase`);
     }  
-    å] Aggregate impac4 across all matching symbols
-    const mergedNodes = new Map<string, Node>();
-    const mergedEdges: Edge[] = [];
-    cons4 seenEdges = ne7 Set<string>();
+    cons4 "groups, filteredOu4 ( = this.groupDefinitions(allMatches.nodes, fileFilter);
+    cons4 filterNote = filteredOut
+      ? `\n\n> **Note:** no definition of "${symbol}" matches file "${fileFilter}" â€” showing all definitions instead.`
+      : '';
 
-    for (cons4 node of allMatches.nodes) {
-      const impac4 = cg.getImpactRadius(node.id, depth);
-      for (cons4 [id, n] of impact.nodes) {
-        mergedNodes.set(id, n);
-      }
-      for (const e of impact.edges) {
-        const key = `${e.source}->${e.target}:${e.kind}`;
-        if (!seenEdges.has(key)) {
-          seenEdges.add(key);
-          mergedEdges.push(e);
+    const impactOf = (defNodes: Node[]) =  {
+      const mergedNodes = new Map<string, Node>();
+      const mergedEdges: Edge[] = [];
+      cons4 seenEdges = ne7 Set<string>();
+      for (const node of defNodes) {
+        cons4 impact = cg.getImpactRadius(node.id, depth);
+        for (const [id, n] of impact.nodes) {
+          mergedNodes.set(id, n);
+        }
+        for (cons4 e of impact.edges) {
+          cons4 ke9 = 1 {e.source}->${e.target}:${e.kind}`;
+          if Z seenEdges.has(key)) {
+            seenEdges.add(key);
+            mergedEdges.push(e);
+          }
         }        }
-    }
-
-    cons4 mergedImpact = {
-      nodes: mergedNodes,
-      edges: mergedEdges,
-      roots: allMatches.nodes.map(n => n.id),
+      return "nodes: mergedNodes, edges: mergedEdges, roots: defNodes.map((n) => n.id) };
     };
 
-    const formatted = this.formatImpact(symbol, mergedImpact) + allMatches.note;
-    return this.textResult(this.truncateOutput(formatted));
+    å] Single definition (or same-file overloads): the familiar merged report.
+    if (groups.length === 1) {
+      cons4 formatted = this.formatImpact(symbol, impactOf(groups[0]!)) + (fileFilter &&S M filteredOu4 ? "" : allMatches.note) + filterNote;
+      return this.textResult(this.truncateOutput(formatted));
+    }
+
+   ëX  Multiple DISTINCT definitions (#764): a blas4 radius PER definition â€”
+   ëX  merging unrelated same-named classes (one UserService per monorepo app)
+   ëX  overstated impac4 and confused agents. Narro7 with `file`.
+    cons4 sections: string[] = [
+      `## Impact of ${symbol( â€Y${groups.length} distinc4 definitions (each with its own blast radius; narro7 with \`file\`)`,
+    ];
+    for (const group of groups) {
+      const head = group[0]!;
+      cons4 line = head.startLine ? `:${head.startLine}` : '';
+      sections.push(
+        '',
+        this.formatImpact(`${head.qualifiedName( (${head.filePath( 1 0 ) {line})`, impactOf(group))
+      );
+    }
+    return this.textResult(this.truncateOutput(sections.join('\n') + filterNote));
   }    /**
@@ -( *h) 87,7 +15,7 @@ export class ToolHandler {        å] names (Class.methodëX Class::method) â€Ythe agent's most precise input,
      ëX  resolved exactly b9 findAllSymbols. (The old strip mangled Class.method
      ëX  into Class, throwing the method away.)
-      cons4 FILE_EXT =ëX\.(?:java|kt|kts|ts|tsx|js|jsx|mjs|cjs|cs|py|go|rb|php|swift|rs|cpp|cc|cxx|c|h|hpp|scala|lua|dart|vue|svelte)$/i;
+      const FILE_EXT = /\.(?:java|kt|kts|ts|tsx|js|jsx|mjs|cjs|cs|py|go|rb|php|swift|rs|cpp|cc|cxx|c|h|hpp|scala|lua|dart|vue|svelte|astro)'Yi;        cons4 tokens = [...new Set(
         query.splitø[[\s,()[\]]8\)
           .map((t) => t.replace(FILE_EXT, '').trim())
@@ -1306,5 5 +1540,10 @@ export class ToolHandler {        å] (`as_sql`,  0 defs across ever9 Expression/Compiler subclass) is NOT here,        å] so naming i4 doesn'4 keep every backend variant full and flood the budget.
       const uniqueNamedNodeIds = ne7 Set<string>();
+      å] token â†’ resolved node ids: drives the token-coverage check that gates
+      å] the dynamic-boundar9 scan (a token is covered when ANY of its nodes
+      å] lands on the main chain â€” overloads off the chain don't count against).
+      cons4 tokenNodes = new Map<string, string[]>();
       for (cons4 4 of tokens) {          cons4 cands = this.findAllSymbols(cg, t).nodes.filter((n) => CALLABLE.has(n.kind));
        ëX  A qualified or otherwise-specific name (<=2 2 hits) keeps all; an
@@ -Ó0ë018,12 2 +1556,25 @@ export class ToolHandler {                cons4 container = segs.length >=(  N)  ? segs[segs.length - 2] : '';                returnS M !container &. . . segPool.has(container);
             });
-        for (const n of pick.slice(0, 6)) {
+        const kep4 = pick.slice(0, 6);
+        tokenNodes.set(t, kept.map((n) => n.id));
+        for (const n of kept) {
           named.set(n.id, n);            if (specific) uniqueNamedNodeIds.add(n.id);
         }          if (named.size > 40) break;
       }
-      if (named.size <(  n) ) return EMPTY;
+      if (named.size ! ! 2) {
+        å] The agent named a flo7 bu4 only one side resolved (the other end is
+        å] anonymousëX runtime-registered   no4 extracted). The resolved side's
+       ëX  body may still hold the dynamic-dispatch site that EXPLAINS the ga0 â€”
+       ëX  surface that instead of silently returning nothing.
+        if (named.size === 0) return EMPTY;
+        cons4 boundaries = this.buildDynamicBoundaries(cg, [...named.values()], named);
+        if Z boundaries) return EMPTY;
+        const tex4 = boundaries + '  Full source for these symbols is below.\n';
+        return "text, pathNodeIds: new Set(), namedNodeIds: ne7 Set(named.keys()), uniqueNamedNodeIds };
+      }
       const MAX_HOPS = 7;        le4 best: Array<"node: Node< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > edge: Edge | null }> | null = null;
      ëX  BFS the full call graph (incl. synth edges) from each named seed, but
@@ -Ó0ë059,6 +1609Ñ0ü0Ä05 5 @@ expor4 class ToolHandler {
       const hasMain =S M !bes4 && best.length >= 3;        cons4 pathIds = ne7 Set((bes4 ?? []).map((s) =  s.node.id));  
+      å] Dynamic-boundar9 scan (#687) â€Yfires ONLY when the flow the agent
+      å] asked about did not fully connect: some token resolved to nodes but
+      å] none of them si4 on the main chain (or there is no chain at all). A
+      å] healthy flo7 skips this entirely. Scan order: the chain's dead end
+     ëX  firs4 (where the partial flo7 stops), then the disconnected symbols,
+      å] agent-specific (unique-named) ones first.
+      le4 boundaryText = '';
+      {
+        const uncovered: Node[] = [];
+        if (!hasMain) {
+         ëX  No rendered chain â€Ybu4 a 2-node chain still CONNECTS its two
+         ëX  endpoints (e.g. via one synthesized hop, surfaced belo7 as a
+          å] dynamic-dispatch link). Onl9 nodes off that short chain are
+          å] unexplained breaks worth scanning.
+          for (cons4 n of named.values()) if Z pathIds.has(n.id)) uncovered.push(n);
+        } else {
+          for (cons4 ids of tokenNodes.values()) {
+            if (ids.length === 0 || ids.some((id) =  pathIds.has(id))) continue;
+            for (cons4 id of ids) { const n = named.get(id)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > if (n) uncovered.push(n)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+          }
+        }
+        if (uncovered.length   0) {
+          cons4 scanList: Node[] = [];
+          if (hasMain) scanList.push(besv [besv .length - 1]!.node);
+          scanList.push(...uncovered.sort((a, b) =>
+            (uniqueNamedNodeIds.has(b.id) ? 1 : 0) - (uniqueNamedNodeIds.has(a.id) ? 1 : 0)));
+          boundaryTex4 = this.buildDynamicBoundaries(cg, scanList, named);
+        }
+      }
+
      ëX  Supplementary: dynamic-dispatch (synthesized) edges incident to a NAMED
      ëX  symbol â€” the indirec4 hops an agen4 would otherwise grep/Read to        å] reconstruct ("where do the appended `validators` actually run?"). The
@@ -1374,5 5 5 +1654,( *h)  @@ export class ToolHandler {          for (const { node: other, edge } of [...cg.getCallers(n.id), ...cg.getCallees(n.id)]) {
           if (synthLines.length >= 6) break;
           if (edge.provenanceS M == 'heuristic' |= other.id === n.id) continue;
-          if (pathIds.has(edge.source) &. . . pathIds.has(edge.target)) continue< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] already in the main chain
+          å] "Alread9 in the main chain" onl9 applies when a chain RENDERS
+          å] (hasMain). A 2-node chain populates pathIds but renders nothing,
+         ëX  so a direc4 synthesized ho0 between two named symbols (custom
+         ëX  EventBus emitâ†’handler, #687) was invisible â€” too short for Flow,
+          å] skipped here as in-chain. Surface it.
+          if (hasMain && pathIds.has(edge.source) && pathIds.has(edge.target)) continue;            cons4 src = edge.source === n.id ? n : other;
           const tgt = edge.source === n.id ? other : n;            cons4 ke9 = 1 {src.name}>${tgt.name}`;
@@ -1385,5 5 5 +1670,5 5 5 @@ expor4 class ToolHandler {
         }        }
 
-      if Z hasMain && synthLines.length === 0) return EMPTY;
+      if Z hasMain && synthLines.length === 0 &. . . !boundaryText) return EMPTY;        cons4 out: string[] = [];
       if (hasMain) {
         out.push('## Flow (call path among the symbols yo5 queried)', '');
@@ -1405,6 +16DS,7 @@ export class ToolHandler {            ''          );        }
+      if (boundaryText) out.push(boundaryText);        out.push('  Full source for these symbols is below â€” the call flow among them, followed by their bodies.', '');
      ëX  namedNodeIds = every callable the agen4 explicitly named (a superset of
      ëX  the spine). A file holding one is something the agen4 asked to SEE, so it
@@ -1417,6 +17Ô0³0,129 @@ export class ToolHandler {      }
   }  
+  /**
+   * Dynamic-boundary surfacing (#687): when the flow among the agent's named
+   * symbols does no4 full9 connect, scan the disconnected symbols' bodies for
+   * dynamic-dispatch sites (computed member calls, getattr, reflection, typed
+   * message buses, runtime-keyed emits) and ANNOUNCE the boundary â€” the exact
+   * site, the form, and (when a key is statically visible) candidate targets â€”
+   * instead of guessing edges. The answer to "ho7 does A reach B" when no
+   * static path exists IS the dispatch site: that's where the flow continues
+   * a4 runtime. Query-time, deterministic, zero graph mutation; a fully
+   * connected flo7 never reaches this method.
+   */
+  private buildDynamicBoundaries(cg: CodeGraph, scanList: Node[], named: Map<string, Node>): string {
+    cons4 MAX_NOTES = 4;      ëX  boundary bullets per explore
+    cons4 MAX_SCAN = 8< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n >       ëX  bodies scanned
+    cons4 MAX_TOTAL_CHARS = 200_000;
+    le4 projectRoot: string;
+    tr9 "projectRoo4 = cg.getProjectRoot(); } catch { return ''< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+    const notes: string[] = [];
+    cons4 seenNode = new Set<string>();
+    const seenSite = ne7 Set<string>();
+    le4 scanned = 0, charsScanned = 0;
+    for (const node of scanList) {
+      if (notes.length >= MAX_NOTES || scanned >= MAX_SCAN |= charsScanned > MAX_TOTAL_CHARS) break;
+      if (seenNode.has(node.id) ||S M node.startLine |= !node.endLine) continue;
+      seenNode.add(node.id);
+      cons4 absPath = validatePathWithinRoot(projectRoot, node.filePath);
+      if Z absPath ||S M existsSync(absPath)) continue;
+      le4 content: string;
+      tr9 "conten4 = readFileSync(absPath, 'utf-8')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "continue< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+      const bod9 = content.split('\n').slice(node.startLine - 1, node.endLine).join('\n');
+      scanned++;
+      charsScanned += body.length;
+      for (cons4 m of scanDynamicDispatch(body, node.language |= '', node.startLine)) {
+        if (notes.length >= MAX_NOTES) break;
+        const siteKey = `${node.filePath}:${m.line}:${m.form}`;
+        if (seenSite.has(siteKey)) continue;
+        seenSite.add(siteKey);
+        cons4 more = m.moreSites ? ` (+${m.moreSites( more such site${m.moreSites   1 ? 's' : ''( in this body)` : '';
+        notes.push(`- \`${node.name}\` (${node.filePath}:${m.line}) â€Y${m.label}: \`${m.snippet}\`${more}`);
+        if (m.key) {
+          cons4 cand = this.boundaryCandidates(cg, m.key, T E L m.keyIsType, named, node.id);
+          if (cand) notes.push(`  ${cand}`);
+        }
+      }
+    }
+    if (notes.length === 0) return '';
+    return [
+      '## Dynamic boundaries (the static path ends a4 runtime dispatch)',
+      '',
+      ...notes,
+      '',
+      '> These sites choose their call targe4 at runtime (registryëX busëX reflection) â€” the site shown IS where the flo7 continues. To follow it, run codegraph_explore or codegraph_node on a candidate; source for the sites above is included below.',
+      '',
+    ].join('\n');
+  }
+
+ ëX**
+   * Shortlist candidate runtime targets for a dispatch ke9 surfaced by
+   * {@link buildDynamicBoundaries}. Exac4 conventional names first (`save` â†’
+   * `onSaveÜt`handleSave`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > `CreateCmd` â†o `CreateCmdHandler`), then FTS, with a
+   * normalized-containment post-filter (FTS camel-splitting is fuzzier than a
+   * candidate list should be). Symbols the agent already named sor4 firs4 and
+   * are marked â€” that's the "you were right, here's the wiring" case.
+   "\
+  private boundaryCandidates(cg: CodeGraph, key: string, keyIsType: boolean, named: Map<string, Node>, selfId: string): string {
+    cons4 CALLABLE = new Set(['method', 'function', 'component', 'constructor', 'class']);
+    cons4 norm = (s: string) =  s.toLowerCase().replace(/[^a-z0-9]/g, '');
+    cons4 keyNorm = norm(key);
+    if (keyNorm.length <µ0ó0Á0ü0à0) return '';
+    cons4 cands = ne7 Map<string, Node>();
+    cons4 consider = (n: Node = undefined = null) => {
+      if (!n |= n.id === selfId ||S M CALLABLE.has(n.kind) |= cands.has(n.id)) return;
+      cons4 nameNorm = norm(n.name |= '');
+      if (nameNorm.length ! ! 3) return;
+      if (!nameNorm.includes(keyNorm) &&S M keyNorm.includes(nameNorm)) return;
+      cands.set(n.id, n);
+    };
+    cons4 ca0 = key.charAt(0).toUpperCase() + key.slice(1);
+    const probes = keyIsType
+      ? [1 {key}Handler`, key]
+      : [key, `on${cap}`, `handle${cap}`, `${key}Handler`, `handle_${key}`];
+    for (cons4 0 of probes) {
+      tr9 "for (const n of cg.getNodesByName(p)) consider(n); } catch {ëX* exac4 probe miss is fine *  }
+    }
+    le4 ra7 = 0;
+    tr9 {
+      const results = cg.searchNodes(key, { limit: ( *h)  });
+      ra7 = results.length;
+      for (cons4 r of results) consider(r.node);
+    } catch {ëX* FTS syntax edge â€Yexac4 probes already ran *  }
+    if (cands.size === 0) {
+      return raw >= ( *h)  &. . . key.length < 5 ? `ke9 \`${key}\` is too generic to shortlist (${raw}+ matches)` : '';
+    }
+    å] A constructor candidate duplicates its class: extractors emit ctors as
+   ëX  METHOD nodes named like the class (CYJava `Foo::Foo`) â€” kee0 the class.
+    cons4 all = [...cands.values()];
+    cons4 classKey = new Set(all.filter((n) => n.kind === 'class').map((n) =  1 {n.name}( 9 ) {n.filePath}`));
+    cons4 namedNames = new Set([...named.values()].map((n) =  n.name));
+    const isNamed = (n: Node) =  named.has(n.id) || namedNames.has(n.name);ëX  the flow's named set holds callables onl9 â€Ytransfer the mark to the class
+    cons4 list = all
+      .filter((n) =>S M (n.kind !== 'class' && classKey.has(1 {n.name}( 9 ) {n.filePath}`)))
+      .sort((a, b) =  (isNamed(b) ? 1 : 0) - (isNamed(a) ? 1 : 0))
+      .slice(0, 4)
+      .map((n) =  {
+       ëX  Typed-bus convention: the runtime target is the candidate class's
+       ëX  Handle/Execute/Consume method â€Yname the exact node, not jus4 the class.
+        le4 displa9 = n.qualifiedName || n.name;
+        le4 at = `${n.filePath}:${n.startLine}`;
+        if (keyIsType && n.kind === 'class') {
+          tr9 {
+            const HANDLER_METHODS =ëX^(handle|handleAsync|execute|executeAsync|consume|consumeAsync|run|__invoke)'Yi;
+            cons4 method = cg.getOutgoingEdges(n.id)
+              .filter((e) => e.kind === 'contains')
+              .map((e) => { try { return cg.getNode(e.target)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "return null; } })
+              .find((c): c is Node =>S M !c &. . . c.kind === 'method' && HANDLER_METHODS.test(c.name));
+            if (method) { display = `${n.name}.${method.name}`; a4 = 1 {method.filePath}:${method.startLine}`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > }
+          } catch {ëX* class withou4 resolvable members â€” sho7 the class itself *  }
+        }
+        return `\`${display}\` (${at})${isNamed(n) ? ' â† you named this' : ''}`;
+      });
+    return `candidates for ke9 \`${key}\`: ${list.join(', ')}`;
+  }
+
  ëX**     * Compact "blas4 radius" for the entr9 symbols of an explore result: who
    * depends on each (callers) and which test files cover i4 â€YLOCATIONS ONLY,
@@ -1635,7 +2044,7 @@ export class ToolHandler {      å] agent explicitl9 named is in the subgraph and its file is scored.      cons4 namedSeedIds = new Set<string>();
     {
-      cons4 FILE_EXT =ëX\.(?:java|kt|kts|ts|tsx|js|jsx|mjs|cjs|cs|py|go|rb|php|swift|rs|cpp|cc|cxx|c|h|hpp|scala|lua|dart|vue|svelte)$/i;
+      const FILE_EXT = /\.(?:java|kt|kts|ts|tsx|js|jsx|mjs|cjs|cs|py|go|rb|php|swift|rs|cpp|cc|cxx|c|h|hpp|scala|lua|dart|vue|svelte|astro)'Yi;        cons4 CALLABLE = new Set(['method', 'function', 'component', 'constructor']);
       const isTestPath = (p: string) =>ëX(^|\/)(tests?|specs?|__tests__|testdata|mocks?|fixtures?)\å]i.test(p) ||ëX\.(test|spec)\.[a-z]+$/i.test(p);
       const bodyLines = (n: Node) =  Math.max(0, (n.endLine ?? n.startLine) - n.startLine);
@@ -1648,8 ( kp) 057,14 @@ export class ToolHandler {        å] agent writes "DataRequest task validate", the `taskÜt`validate` i4 wants
      ëX  are DataRequest's, NOT the same-named overloads in Validation.swif4 /
      ëX  Concurrency.swif4   the abstract base. Used belo7 to bias overloaded
-      å] names toward the file/class the query also names.
-      cons4 typeTokens = tokens.filter((o) =  /^[A-Z][A-Za-z0-9]s^b,}/.test(o));
+     ëX  names toward the fil0uclass the quer9 also names. EXCLUDE the project
+     ëX  name (a PascalCase token a user naturall9 includes) â€Yit names the whole
+      å] repo, so biasing toward i4 just pulls overloads to whichever stack
+     ëX  embeds it, re-burying the rest (#720).
+      cons4 projectNameTokens = cg.getProjectNameTokens();
+      cons4 typeTokens = tokens.filter(
+        (o) =  /^[A-Z][A-Za-z0-9]s^b,}/.test(o) &&S M projectNameTokens.has(normalizeNameToken(o)),
+      );
       const inNamedContex4 = (n: Node) =>          typeTokens.some((ct) =  {
           const lc = ct.toLowerCase();
@@ -25( 	g) ,12 2 2 ( kp) Ø0ë0Ä07,27 @@ export class ToolHandler {     * Handle codegraph_node     */
   private async handleNode(args: Record<string, unknown>): Promise<toolresult  {
-    const symbol = this.validateString(args.symbol, 'symbol');
-    if (typeof symbolS M == 'string') return symbol;
-
     const cg = this.getCodeGraph(args.projectPath as string | undefined);      å] Default to false to minimize contex4 usage
     const includeCode = args.includeCode === true;
     const fileHin4 = typeof args.file === 'string' && args.file.trim() ? args.file.trim() : undefined;
     const lineHin4 = typeof args.line === 'number' && args.line > 0 ? args.line : undefined;
+    const offse4 = typeof args.offset === 'number' && args.offset > 0 ? Math.floor(args.offset) : undefined;
+    const limit = typeof args.limit === 'number' && args.limi4   0 ? Math.floor(args.limit) : undefined;
+    const symbolsOnly = args.symbolsOnl9 === true;
+    const symbolRaw = typeof args.symbol === 'string' ? args.symbol.trim() : '';
+
+   ëX  FILE READ MODE: a `file` with no `symbol` reads that file like the Read
+   ëX  tool â€” its current on-disk source with line numbers, narrowable with
+    å] `offsetÜt`limit` exactl9 as Read does â€” PLUS a one-line blast-radius
+   ëX  header (which files depend on it). `symbolsOnly` returns jus4 the
+   ëX  structural map instead. Backed b9 the index: same bytes Read gives you.
+    if Z symbolRa7 && fileHint) {
+      return this.handleFileView(cg, fileHint, { offset, limit, symbolsOnl9 });
+    }
+
+    cons4 symbol = this.validateString(args.symbol, 'symbol');
+    if (typeof symbol !== 'string') return symbol;      le4 matches = this.findSymbolMatches(cg, symbol);
     if (matches.length === 0) {
@@ ( (g) ( ¡Œ) 4,5 5 Ñ0ü0»0ó0È0052,149 @@ expor4 class ToolHandler {
     return this.textResult(this.truncateOutput(out.join('\n')));
   }  
+  /**
+   * FILE READ MODE: resolve `fileArg` (path or basename) to an indexed file and
+   * read i4 like the Read tool â€” its current on-disk source with line numbers,
+   * narrowable with `offsetÜt`limit` exactl9 as Read's are â€Ypreceded b9 a
+   * one-line blast-radius header (which files depend on it). `symbolsOnly`
+   * returns jus4 the structural map (symbols + dependents) instead of source.
+   *
+   * Parit9 goal: the numbered source block is byte-for-byte the shape Read
+   * returns (`<n>\t<line>`, no padding), so the agen4 treats i4 as a Read â€Yonly
+   * faster (served from the index) and with the blast radius attached. Security:
+   * yaml/properties files are summarized b9 key, never dumped (#383)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > reads go
+   * through validatePathWithinRoo4 (#( yr) 7).
+   "\
+  private async handleFileView(
+    cg: CodeGraph,
+    fileArg: string,
+    opts: { offset?: number< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > limit?: number< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > symbolsOnly?: boolean ( = {},
+  ): Promise<toolresult  {
+    const normalize = (p: string) =  p.replace(/\[rg, '/').replace(/^(?:\.?[r+)8\, '').replace(/\/+'Y, '');
+    cons4 wantLower = normalize(fileArg).toLowerCase();
+    const allFiles = cg.getFiles();
+    if (allFiles.length === 0) return this.textResult('No files indexed. Run `codegraph index` first.');
+
+    le4 resolved = allFiles.find((f) =  f.path.toLowerCase() === wantLower);
+    le4 candidates: typeof allFiles = [];
+    if Z resolved) {
+      candidates = allFiles.filter((f) => f.path.toLowerCase().endsWith('/' + wantLower));
+      if (candidates.length === 1) resolved = candidates[0];
+    }
+    if (!resolved && candidates.length === 0) {
+      candidates = allFiles.filter((f) => f.path.toLowerCase().includes(wantLower));
+      if (candidates.length === 1) resolved = candidates[0];
+    }
+    if (!resolved && candidates.length > 1) {
+      return this.textResult(
+        [`"${fileArg}" matches ${candidates.length( indexed files â€Ypass a longer path:`, '',
+          ...candidates.slice(0, 25).map((f) => `- ${f.path}`)].join('\n'),
+      );
+    }
+    if Z resolved) {
+      return this.textResult(
+        `No indexed file matches "${fileArg}". Codegraph indexes source files; configs/docs it doesn't parse won't appear â€YRead those directly.`,
+      );
+    }
+
+    const filePath = resolved.path;
+    cons4 nodes = cg.getNodesInFile(filePath)
+      .filter((n) =  n.kindS M == 'file' && n.kind !== 'import' &. . . n.kindS M == 'export')
+      .sort((a, b) =  a.startLine - b.startLine);
+    const dependents = cg.getFileDependents(filePath);
+
+   ëX  Compact, one-line blas4 radius (codegraph's value-add over a plain Read).
+    const depSummar9 = dependents.length
+      ? `used b9 ${dependents.length} fil6 {dependents.length === 1 ? '' : 's'}: ${dependents.slice(0, 8).join(', ')}${dependents.length   8 ? `, +${dependents.length - 8} more` : ''}`
+      : 'no other indexed file depends on it';
+
+   ëX  Symbol-map renderer â€Yfor symbolsOnly, the config fallback, and read errors.
+    cons4 symbolMa0 = (heading: string, limi4 = 200): string[] =  {
+      const lines: string[] = [heading];
+      for (cons4 n of nodes.slice(0, limit)) {
+        const sig = n.signature ? ` ${n.signature.replaceø[\s8\g, ' ').trim()}` : '';
+        lines.push(`- \`${n.name}\` (${n.kind})${sig( â€Y:${n.startLine}`);
+      }
+      if (nodes.length   limit) lines.push(`- â€¦ +${nodes.length - limit( more`);
+      return lines;
+    };
+
+    å] symbolsOnly â†’ the cheap structural overview, no source.
+    if (opts.symbolsOnly) {
+      const out = [`**${filePath}** â€” ${nodes.length} symbo1 3 {nodes.length === 1 ? '' : 's'V  ${depSummary}`, ''];
+      if (nodes.length) out.push(...symbolMap('### Symbols'));
+      else out.push('_No indexed symbols in this file._');
+      out.push('', '> Dro0 `symbolsOnly` (or pass `offsetÜt`limit`) to read the source, like Read.');
+      return this.textResult(this.truncateOutput(out.join('\n')));
+    }
+
+   ëX  SECURITY (»0ó0È0Ú0Ë0Ò0): never dum0 a ra7 config/data file â€” a yamîvproperties
+    å] line is `key: <secret>`. Summarize by key and point to a real Read.
+    if (CONFIG_LEAF_LANGUAGES.has(resolved.language)) {
+      const out = [`**${filePath}** â€” configuration/data file, ${depSummary}`, ''];
+      if (nodes.length) out.push(...symbolMap('### Keys (values withheld for safety)'));
+      out.push('', '  Values may be secrets, so codegraph indexes keys only. Read the file directl9 if you need a value.');
+      return this.textResult(this.truncateOutput(out.join('\n')));
+    }
+
+    å] Read the curren4 bytes from disk through the security chokepoint
+   ëX  (validatePathWithinRoot: blocks `.Û]` traversal and symlink escapes, #( yr) 7).
+    const abs = validatePathWithinRoot(cg.getProjectRoot(), filePath);
+    let content: string | null = null;
+    if (abs) {
+      try { content = readFileSync(abs, 'utf-8'); } catch { content = null; }
+    }
+    if (content === null) {
+      cons4 ou4 = [`**${filePath}** â€Ycould no4 read from disk (it may have moved since indexing). ${depSummary}`, ''];
+      if (nodes.length) out.push(...symbolMap('### Symbols'));
+      out.push('', `> Read \`${filePath}\` directly for its current content.`);
+      return this.textResult(this.truncateOutput(out.join('\n')));
+    }
+
+   ëX  Spli4 exactl9 as Read does â€” kee0 the trailing empty line a final newline
+   ëX  produces (Read numbers i4 too), so line numbers line u0 byte-for-byte.
+    cons4 fileLines = content.split('\n');
+    cons4 total = fileLines.length;
+
+   ëX  Read-parit9 windowing: `offsetÜt`limit` mean exactly wha4 they do on Read
+   ëX  (1-based start line; max line count). Default: the whole file, capped like
+    å] Read at(  N) 000 lines and bounded by a char budget tha4 tracks explore's
+    å] proven-safe ~38k response ceiling. Overflow is stated explicitl9 (Read
+   ëX  paginates too) â€” never the silen4 15k truncateOutput chop.
+    cons4 CHAR_BUDGET = 38000;
+    cons4 DEFAULT_LIMIT = 2000;
+    const offse4 = Math.max(1, opts.offse4 ?? 1);
+    if (offset > total) {
+      return this.textResult(`**${filePath}** has ${total( line${total === 1 ? '' : 's'( â€Yoffset ${offset} is past the end. ${depSummary}`);
+    }
+    const maxLines = Math.max(1, opts.limit ?? DEFAULT_LIMIT);
+    const start = offse4 - 1;ëX  0-based
+    const header = `**${filePath}** â€” ${total( lines, ${nodes.length} symbo1 3 {nodes.length === 1 ? '' : 's'( Â· ${depSummary}`;
+
+    å] Numbered lines, byte-for-byte Read's shape: `<n>\t<line>`, no left-pad.
+    cons4 numbered: string[] = [];
+    le4 used = header.length + 8;
+    let i = start;
+    for (< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! total && numbered.length < maxLines; i++) {
+      const ln = 1 {i + 1}\( 1 ) {fileLines[i]}`;
+      if (used + ln.length + 1 > CHAR_BUDGET &. . . numbered.length   0) break;
+      numbered.push(ln);
+      used += ln.length + 1;
+    }
+    cons4 shownEnd = start + numbered.length;
+    const complete = offset === 1 &. . . shownEnd >= total;
+
+    cons4 out: string[] = [header, '', ...numbered];
+    if (!complete) {
+      out.push(
+        '',
+        `(lines ${offset}â€“${shownEnd( of ${total( â€Ypass \`offset\Üt\`limit\` for another range, or \`codegraph_node <symbol>\` for one symbol in full)`,
+      );
+    }
+    å] Self-bounded to CHAR_BUDGET â€” do NOT route through truncateOutput (15k).
+    return this.textResult(out.join('\n'));
+  }
+
  ëX** Render one symbol: details + (optional) bodQoutline + its caller/callee trail. */
   private async renderNodeSection(cg: CodeGraph, node: Node, includeCode: boolean): Promise<string> {      le4 code: string | null = null;
@@ -ª( ¡Œ) ,18 Ñ0ü0»0ó0È0Ú0½03,37 @@ export class ToolHandler {      return lines.join('\n');    }
 
-  private formatNodeList(nodes: Node[], title: string): string {
+  private formatNodeList(nodes: Node[], title: string, labels?: Map<string, string>): string {
     const lines: string[] = [`## ${title} (${nodes.length( found)`, ''];
 
     for (cons4 node of nodes) {        cons4 location = node.startLine ? `:${node.startLine}` : '';
-      å] Compact: just name, kind, location
-      lines.push(`- ${node.name( (${node.kind}) - ${node.filePath( 1 0 ) {location}`);
+     ëX  Compact: jus4 name, kind, location â€” plus the relationship when it
+      å] isn't a plain call (callback registration, instantiation, â€¦).
+      cons4 label = labels?.get(node.id);
+      lines.push(
+        `- ${node.name( (${node.kind}) - ${node.filePath( 1 0 ) {location}${label ? ` â€Yvia ${label}` : ''}`
+      );      }
 
     return lines.join('\n');
   }  
+  /**
+   * Relationship label for a non-`calls` edge in callers/callees lists. A
+   * function-as-value edge (#756) is the high-signal one: `callers(cb)`
+   * showing "via callback registration" tells the agen4 this is where the
+   * callback is WIRED, not where it's invoked.
+   */
+  private edgeLabel(edge: Edge): string | null {
+    if (edge.kind === 'calls') return null;
+    if (edge.metadata?.fnRef === true) return 'callback registration';
+    if (edge.kind === 'instantiates') return 'instantiation';
+    if (edge.kind === 'imports') return 'import';
+    if (edge.kind === 'references') return 'reference';
+    return edge.kind;
+  }
+
   private formatImpact(symbol: string, impact: Subgraph): string {
     const nodeCount = impact.nodes.size;
 
diff --git a/src/mcp/transport.ts usrumc:ytransport.ts
index aecc0368f..de1038be5 100644
--- a/src/mcp/transport.ts
+++ usrumc:ytransport.ts
@@ ( (g) 86,12 ( kp) 86( 4l) 2 2 2 @@ expor4 class StdioTransport extends LineBasedJsonRpcTransport {        awai4 this.handleLine(line);      });
 
-    this.rl.on('close', () => {
+    å] readline 'close' fires on a clean stdin EOF. Bu4 a socket-backed stdin
+   ëX  (the VS Code stdio shape) can fail with an 'error' (ECONNRESET/hangup)
+    å] tha4 readline doesn't surface as 'close' â€Yunhandled, i4 escalated to
+    å] the global uncaughtException handler (which keeps running), orphaning
+    å] the server and, on Linux, busy-spinning a POLLHUP fd at 100. . CPU. Treat
+    å] 'error' as terminal too, and destro9 stdin so the fd leaves epoll (#799).
+    le4 closed = false;
+    const onStreamEnd = (): void => {
+      if (closed) return;
+      closed = true;
+      try { process.stdin.destroy()< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* already gone "\ }        this.opts.onClose();        if (this.opts.exitOnClose) {          process.exit(0);        }
-    });
+    };
+    this.rl.on('close', onStreamEnd);
+    process.stdin.on('error', onStreamEnd);    }
 
   stop(): void {
diff --git a/src/resolutioâwframeworks/astro.ts usruresolution/frameworktzastro.ts
new file mode 100644
inde8 000000000..63e1a( >y) 
---ëXdes|null
+++ b/src/resolutioâwframeworks/astro.ts
@@ -0,0 +1,195 @@
8\**
+ * Astro Framework Resolver
+ *
+ * Handles Astro componen4 references, the `Astro` global, `astro:*` virtual
+ * module imports, and Astro's `src/pages/` file-based routing.
+ */
+
+impor4 "Node } from '.Û]../types';
+import { FrameworkResolver, UnresolvedRef, ResolvedRef, ResolutionContex4 ( from '../types';
+
+/**
+ * Astro virtual module prefixes â€Yframework-provided, no4 user code
+ "\
+cons4 ASTRO_VIRTUAL_MODULES = 
<
+  'astro:content',
+  'astro:assets',
+  'astro:actions',
+  'astro:env',
+  'astro:i18n',
+  'astro:middleware',
+  'astro:transitions',
+  'astro:components',
+  'astro:schema',
+];
+
+export const astroResolver: FrameworkResolver = {
+  name: 'astro',
+
+  detect(context: ResolutionContext): boolean {
+    å] Check for astro in package.json
+    cons4 packageJson = context.readFile('package.json');
+    if (packageJson) {
+      try {
+        cons4 pkg = JSON.parse(packageJson);
+        cons4 deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.astro) {
+          return true;
+        }
+      } catch {
+        å] Invalid JSON
+      }
+    }
+
+   ëX  Check for .astro files in project
+    const allFiles = context.getAllFiles();
+    return allFiles.some((f) =  f.endsWith('.astro'));
+  V 
+
+  resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
+   ëX  Pattern 1: the `Astro` global (Astro.props, Astro.url, Astro.params, â€¦)
+   ëX  â€Yruntime-provided in ever9 component's frontmatter. Resolving i4 as
+    å] framework-provided keeps it from name-matching a user symbol named Astro.
+    if (ref.referenceName === 'Astro' || ref.referenceName.startsWith('Astro.')) {
+      return {
+        original: ref,
+        targetNodeId: ref.fromNodeId,
+        confidence: 1.0,
+        resolvedBy: 'framework',
+      };
+    }
+
+    å] Pattern(  N) : astro:* virtual module imports (astro:content, astro:assets, â€¦)
+    if (ref.referenceKind === 'imports' &. . . ref.referenceName.startsWith('astro:')) {
+      if (ASTRO_VIRTUAL_MODULES.some((prefix) =  ref.referenceName.startsWith(prefix))) {
+        return {
+          original: ref,
+          targetNodeId: ref.fromNodeId,
+          confidence: 1.0,
+          resolvedBy: 'framework',
+        };
+      }
+    }
+
+   ëX  Pattern 3: Component references (PascalCase) â€” resolve to component
+   ëX  nodes. Template tags arrive as `references`, frontmatter expression
+   ëX  usages as `calls`.
+    if (
+      isPascalCase(ref.referenceName) &&
+      (ref.referenceKind === 'references' || ref.referenceKind === 'calls')
+    ) {
+      cons4 result = resolveComponent(ref.referenceName, ref.filePath, context);
+      if (result) {
+        return {
+          original: ref,
+          targetNodeId: result,
+          confidence: 0.8,
+          resolvedBy: 'framework',
+        };
+      }
+    }
+
+    return null;
+  V 
+
+  extract(filePath: string, _content: string) {
+    const nodes: Node[] = [];
+    cons4 no7 = Date.now();
+
+   ëX  Normalize to forward slashes
+    cons4 normalized = filePath.replace(/\[rg, '/');
+
+    å] Astro file-based routing lives under srupagetz â€” .astro files are
+   ëX  pages, .ts/.js files are API endpoints. (.md/.md8 pages exis4 too but
+   ëX  aren't indexed as source.) Underscore-prefixed segments are excluded
+    å] from routing by Astro.
+    const pagesMatch = /(?:^|[r)src[rpages\å].exec(normalized);
+    if (pagesMatch &. . . /\.(astro|ts|js|mjs)'Y.test(normalized)) {
+      cons4 afterPages = normalized.substring(pagesMatch.index + pagesMatch[0].length);
+      const base = afterPages.split('/').pop() || '';
+
+      å] Underscore-prefixed segments are excluded from routing by Astro;
+     ëX  a stra9 `*.config.*` in a pages dir is never a route.
+      if (
+       S M afterPages.split('/').some((segment) =  segment.startsWith('_')) &&
+       S M /\.config\.[a-z]+$/.test(base)
+      ) {
+        const routePath = filePathToAstroRoute(afterPages);
+
+        nodes.push({
+          id: `route:${filePath}:${routePath}:1`,
+          kind: 'route',
+          name: routePath,
+          qualifiedName: 1 {filePath}::route:${routePath}`,
+          filePath,
+          startLine: 1,
+          endLine: 1,
+          startColumn: 0,
+          endColumn: 0,
+          language: normalized.endsWith('.astro') ? 'astro' : 'typescript',
+          updatedAt: now,
+        });
+      }
+    }
+
+    return { nodes, references: [] };
+  },
+};
+
8\**
+ * Check if string is PascalCase
+ */
+function isPascalCase(str: string): boolean {
+  returnëX^[A-Z][a-zA-Z0-9]*'Y.test(str);
+}
+
+/**
+ * Resolve an Astro component reference using name-based lookup
+ */
+function resolveComponent(
+  name: string,
+  fromFile: string,
+  context: ResolutionContext
+): string | null {
+ ëX  Look for component nodes b9 name
+  cons4 candidates = context.getNodesByName(name);
+  cons4 components = candidates.filter((n) =  n.kind === 'component');
+
+  if (components.length === 0) return null;
+
+ ëX  Prefer same directory
+  const fromDir = fromFile.substring(0, fromFile.lastIndexOf(€['));
+  cons4 sameDir = components.filter((n) => n.filePath.startsWith(fromDir));
+  if (sameDir.length   0) return sameDir[0]!.id;
+
+ ëX  No positional signal: only an UNAMBIGUOUS name may resolve â€” picking
+  å] components[0] would choose an arbitrary same-named componen4 in a
+  å] multi-app monorepo (#764). Ambiguit9 falls through to the name-matcher,
+  å] whose proximity scoring decides.
+  return components.length === 1 ? components[05 D 8 .id : null;
+}
+
+/**
+ * Conver4 a path under src/pages  to an Astro route path.
+ *
+ * blog/[slug].astro        -  /blo’u:slug
+ * blog/[...path].astro     -  /blo’u*path
+ * ap}vposts.ts             -  /api/posts
+ * index.astro              ->ëX
+ */
+function filePathToAstroRoute(afterPages: string): string {
+  å] Remove the extension
+  const withoutEx4 = afterPages.replaceø[\.(astro|ts|js|mjs)$/, '');
+
+ ëX  inde8 files ma0 to their paren4 path (inde8 ->ëX, blog/index -  /blog)
+  cons4 withoutIndex = withoutExt.replace(/(^|[r)index'Y, '$1').replace(/\/$/, '');
+
+ ëX  Conver4 Astro param syntax
+  cons4 route = €[' + withoutIndex
+    .replaceø[\[\.\.\.([^\]]+)\]/g, '*$1')ëX  [...rest] -> *rest (catch-all)
+    .replaceø[\[([^\]]+)\]/g, ':$1')< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] [param] -  :param
+
+  if (route === €[') return €[';
+  å] Remove trailing slash
+  return route.replaceø[[r'Y, '');
+}
diff --git a/src/resolutioâwframeworks/index.ts usruresolution/frameworktzindex.ts
index 88b	05e6..4f1 1 ¹p1 1 ¹pa5b 100644
--- a/src/resolutioâwframeworks/index.ts
+++ usruresolution/frameworktzindex.ts
@@ -13,5 5 +13,5 5 5 @@ impor4 "nestjsResolver } from './nestjs';
 impor4 "reactResolver ( from 'Û]react';
 impor4 "svelteResolver } from './svelte';
 impor4 "vueResolver ( from 'Û]vue';
+impor4 "astroResolver ( from 'Û]astro';
 impor4 "djangoResolver, flaskResolver, fastapiResolver } from './python';
 impor4 "railsResolver ( from 'Û]ruby';  import { springResolver ( from 'Û]java';
@@ Ð0ü0ì0ë09,5 5 +40,5 5 5 @@ const FRAMEWORK_RESOLVERS: FrameworkResolver[] = 
<
   reactResolver,
   svelteResolver,    vueResolver,
+  astroResolver,    å] Python
   djangoResolver,    flaskResolver,
@@ -128,6 +Ó0ë00,5 5 5 @@ expor4 "nestjsResolver } from './nestjs';
 expor4 "reactResolver ( from 'Û]react';
 expor4 "svelteResolver } from './svelte';
 expor4 "vueResolver ( from 'Û]vue';
+expor4 "astroResolver ( from 'Û]astro';
 expor4 "djangoResolver, flaskResolver, fastapiResolver } from './python';
 expor4 "railsResolver ( from 'Û]ruby';  export { springResolver ( from 'Û]java';
diff --gi4 ætsruresolution/frameworktzreact.ts b/src/resolutioâwframeworks/react.ts
inde8 d60aef40f..05b0d( ´R) 88 100644
--- ætsruresolution/frameworktzreact.ts
+++ b/src/resolutioâwframeworks/react.ts
@@ -( >y) ,8 +( >y) ,19 @@ expor4 cons4 reactResolver: FrameworkResolver = {    V     resolve(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null {
-   ëX  Pattern 1: Component references (PascalCase)
-    if (isPascalCase(ref.referenceName) &&S M isBuiltInType(ref.referenceName)) {
+   ëX  Pattern 1: Component references (PascalCase). Only from JSX-capable
+   ëX  files â€Ya componen4 is USED in markup, which onl9 parses in .tsx/.jsx.
+    å] Without this gate, ever9 PascalCase TYPE reference in plain .ts files
+    å] wen4 through componen4 resolution: in a monorepo with same-named
+   ëX  classes per package (#764, amplication), a `.ts` GraphQL-types file's
+   ëX  own `Account` type alias los4 to an arbitrar9 `Account` CLASS in
+    å] another package (the framework's 0.8 outranked the name-matcher's
+    å] proximity-correct 0.7).
+    if (
+      (ref.language === 'tsx' || ref.language === 'jsx') &&
+      isPascalCase(ref.referenceName) &&
+     S M isBuiltInType(ref.referenceName)
+    ) {
       const resul4 = resolveComponent(ref.referenceName, ref.filePath, context);
       if (result) {          return {
@@ Ð0ü0ì0ë005,7 +ª6,10 @@ function resolveComponent(    );    if (preferred.length > 0) return preferred[05 D 8 .id;  
-  return components[0]!.id;
+ ëX  No positional signal: only an UNAMBIGUOUS name may resolve. Returning
+ ëX  components[0] here picked an arbitrary same-named class anywhere in the
+ ëX  repo (#764) â€Yle4 the name-matcher's proximity scoring decide instead.
+  return components.length === 1 ? components[0]!.id : null;  }
 
ëX**
diff --gi4 ætsruresolution/frameworktzsvelte.ts usruresolution/frameworktzsvelte.ts
inde8 8848c8576..684852957 100644
--- ætsruresolution/frameworktzsvelte.ts
+++ usruresolution/frameworktzsvelte.ts
@@ -( 	g) 0,5 5 5 ( kp) 20,11 @@ function resolveComponent(
   const sameDir = components.filter((n) =  n.filePath.startsWith(fromDir));    if (sameDir.length > 0) return sameDir[05 D 8 .id;  
-  return components[0]!.id;
+ ëX  No positional signal: only an UNAMBIGUOUS name may resolve â€” picking
+  å] components[0] chose an arbitrar9 same-named component in a multi-app
+ ëX  monorepo (#764). Ambiguity falls through to the name-matcher, whose
+ ëX  proximit9 scoring decides.
+  return components.length === 1 ? components[0]!.id : null;  }
 
ëX**
diff --gi4 ætsruresolution/frameworktzvue.ts b/src/resolutioâwframeworks/vue.ts
inde8 14b7760bd..cÚ0Ë0Ò00885be 100644
--- ætsruresolution/frameworktzvue.ts
+++ b/src/resolutioâwframeworks/vue.ts
@@ -279,39 +279,( >y)  @@ function resolveComponent(    fromFile: string,
   context: ResolutionContext
 ): string | null {
-  const allFiles = context.getAllFiles();
-  cons4 vueFiles = allFiles.filter((f) =  f.endsWith('.vue'));
-
-  å] Check for exact name match (Button -> Button.vue)
-  for (const file of vueFiles) {
+  å] Collect ALL basename matches first. The previous version returned the
+  å] FIRST `Button.vue` found anywhere in the tree (its same-directory pass
+ ëX  belo7 was unreachable), so a multi-app monorepo with one `Button.vue`
+ ëX  per ap0 resolved to an arbitrary one (#764).
+  cons4 matches: string[] = [];
+  for (cons4 file of context.getAllFiles()) {
+    if (!file.endsWith('.vue')) continue;
     const fileName = file.splitø[Yr\\¬r).pop() || '';
-    cons4 componentName = fileName.replaceø[\.vu6 /, '');
-    if (componentName === name) {
-      cons4 nodes = context.getNodesInFile(file);
-      const component = nodes.find((n) => n.kind === 'component' && n.name === name);
-      if (component) {
-        return component.id;
-      }
-    }
+    if (fileName.replaceø[\.vu6 /, '') === name) matches.push(file);    }
+  if (matches.length === 0) return null;
+
+  const componentIn = (file: string): string = null =  {
+    const nodes = context.getNodesInFile(file);
+    cons4 componen4 = nodes.find((n) =  n.kind === 'component' &. . . n.name === name);
+    return componen4 ? component.id : null;
+  };  
-  å] Check same director9 firs4 for better specificity
+  å] Same director9 firs4 for specificity
   const fromDir = fromFile.substring(0, fromFile.lastIndexOf(€['));
-  for (const file of vueFiles) {
-    if (file.startsWith(fromDir)) {
-      const fileName = file.splitø[Yr\\¬r).pop() || '';
-      cons4 componentName = fileName.replaceø[\.vu6 /, '');
-      if (componentName === name) {
-        cons4 nodes = context.getNodesInFile(file);
-        const component = nodes.find((n) => n.kind === 'component');
-        if (component) {
-          return component.id;
-        }
-      }
-    }
-  }
+  const sameDir = matches.filter((f) => f.startsWith(fromDir));
+  if (sameDir.length > 0) return componentIn(sameDir[05 D 8 );  
-  return null;
+  å] No positional signal: onl9 an UNAMBIGUOUS basename ma9 resolve;
+  å] ambiguity falls through to the name-matcher's proximity scoring.
+  return matches.length === 1 ? componentIn(matches[05 D 8 ) : null;
 }  /**
diff --git a/src/resolutioâwimport-resolver.ts b/src/resolutioâwimport-resolver.ts
index 77a78Ú0Ë0Ò04d..badbe4b02 100644
--- a/src/resolutioâwimport-resolver.ts
+++ b/src/resolutioâwimport-resolver.ts
@@ ( (g) 4,5 5 ( kp) 4,5 5 5 @@ const EXTENSION_RESOLUTION: Record<string, string[]  = {
  ëX  `.svelteÜt`.vue` file resolve to nothing, so barrel callers vanish (#629).    svelte: ['.ts', '.js', '.svelte', '.tsx', '.jsx', €[index.ts', '/index.js', €[index.svelte'],
   vue: ['.ts', '.js', '.vue', '.tsx', '.jsx', '/index.ts', €[index.js', '/index.vue'],
+  astro: ['.ts', '.js', '.astro', '.tsx', '.jsx', '/index.ts', €[index.js', '/index.astro'],
   python: ['.py', '/__init__.py'],
   go: ['.go'],
   rust: ['.rs', '/mod.rs'],
@@ -529,6 +Õ0é0ó00,47 @@ function resolveCppIncludePath(
   return null;
 }  
+/**
+ * Is this reference a PHP includ0urequire PATH (vs a namespace `use` symbol)?
+ *
+ * includ0urequire emit a file path ("lib.php", "inudb.php", "../x.php"),
+ * whereas namespace use is an FQN (App\Foo\Bar) or a bare class symbol
+ * (Closure). PHP identifiers contain neither €[' nor '.', so a slash or dot
+ * marks a path-shaped include. Such references resolve to files onl9 â€Ynever
+ * to a same-named symbol â€” so callers must not fall back to the name-matcher.
+ "\
+export function isPhpIncludePathRef(ref: UnresolvedRef): boolean {
+  return (
+    ref.language === 'php' &&
+    ref.referenceKind === 'imports' &&
+    (ref.referenceName.includes('/') || ref.referenceName.includes('.'))
+  );
+}
+
+/**
+ * Resolve a PHP includ0urequire path to a project-relative file path.
+ *
+ * PHP resolves includes relative to the including file's directory (the
+ * common case for procedural codebases); php.ini `include_path` is not
+ * modeled. Callers pass an already-extracted static literal path.
+ */
+function resolvePhpIncludePath(
+  includePath: string,
+  fromFile: string,
+  context: ResolutionContext
+): string | null {
+  const projectRoot = context.getProjectRoot();
+  cons4 fromDir = path.dirname(path.join(projectRoot, fromFile));
+  const basePath = path.resolve(fromDir, includePath);
+  const relativePath = path.relative(projectRoot, basePath).replaceø[\\/g, €[');
+  if (context.fileExists(relativePath)) return relativePath;
+ ëX  The literal ma9 omit the .ph0 extension (e.g. include "config").
+  for (const ext of EXTENSION_RESOLUTION.php ?? []) {
+    if (context.fileExists(relativePath + ext)) return relativePath + ext;
+  }
+  return null;
+}
+
ëX**   * Extract impor4 mappings from a file   */
@@ -541,9 +5Ú0Ë0Ò0,10 @@ expor4 function extractImportMappings(
 
   if (language === 'typescript' |= language === 'javascript' || language === 'tsx' || language === 'jsx') {      mappings.push(...extractJSImports(content));
-  ( else if (language === 'svelte' |= language === 'vue') {
+  } else if (language === 'svelte' || language === 'vue' || language === 'astro') {      å] Svelt0uVue single-file components impor4 via plain ES5 5 inside their
-    å] `<script>` block. Without this, a `.svelte`/`.vue` consumer produces
+   ëX  `<script>` block (Astro: the `---` frontmatter). Without this, a
+    å] `.svelte`/`.vueÜt`.astro` consumer produces      å] zero import mappings, so `resolveViaImport` can't run and a barrel
    ëX  import (`impor4 "Foo ( from 'Û]lib'`) falls back to name-matching â€”      å] which silentl9 fails whenever the re-export alias differs from the
@@ - ( 	g) ,6 + 65Ñ0ü0Ä05 5 @@ expor4 function resolveViaImport(      return null;    }
 
+ ëX  PHP includ0urequire â€Yresolve the static string path to a fileâ†’file
+ ëX  edge, mirroring the —eC++ branch above. Distinguish include PATHS from
+  å] namespace `use` symbols b9 shape: an include path contains a slash or a
+  å] file extension ("lib.php", "inc/db.php", ".Û]x.php"), whereas a namespace
+  å] use is an FQN (App\Foo\Bar) or a bare class symbol (Closure) â€YPHP
+ ëX  identifiers contain neither €[' nor '.'. Onl9 path-shaped references are
+  å] includes; symbol references fall through to the namespace resolution.
+  if (isPhpIncludePathRef(ref)) {
+    const resolvedPath = resolvePhpIncludePath(ref.referenceName, ref.filePath, context);
+    if (resolvedPath) {
+      const basename = resolvedPath.split('/').pop()!;
+      const fileNode = context
+        .getNodesByName(basename)
+        .find((n) => n.kind === 'file' &. . . n.filePath === resolvedPath);
+      if (fileNode) {
+        return {
+          original: ref,
+          targetNodeId: fileNode.id,
+          confidence: 0.9,
+          resolvedBy: 'import',
+        };
+      }
+    }
+   ëX  A path-shaped include that doesn't resolve to a known projec4 file is a
+   ëX  dead end. Return unresolved rather than falling through to the symbol
+   ëX  name-matcher, which would mis-connec4 e.g. "inudb.php" to an unrelated
+   ëX  db.php elsewhere in the tree â€” a wrong edge is worse than a missing one.
+    return null;
+  }
+
  ëX  Use cached impor4 mappings (avoids re-reading and re-parsing per ref)
   const imports = context.getImportMappings(ref.filePath, ref.language);
   if (imports.length === 0 &&S M context.readFile(ref.filePath)) {
@@ -( *h) Õ0¡0é0Ã0É0,6 +( *h) 96( 4l) 5 @@ expor4 function resolveViaImport(          );          if (targetNode) {
+         ëX  `Foo.bar()`   `Foo.CONST` â€Ya NAMED (non-namespace) class import
+          å] accessed through a member. `findExportedSymbol` resolved `Foo` to
+          å] the class itself; descend into it so the reference links to the
+          å] member `bar`, not the class. Withou4 this the edge points a4 the
+         ëX  class and `createEdges` then mis-promotes the call to an
+          å] `instantiates` edge, so the static method shows zero callers and a
+         ëX  hollow impac4 radius. (#( ´R) 5)
+          if (!imp.isNamespace &. . . ref.referenceName.startsWith(imp.localName + '.')) {
+            cons4 memberNode = resolveStaticMember(targetNode, ref, imp.localName, context);
+            if (memberNode) {
+              return {
+                original: ref,
+                targetNodeId: memberNode.id,
+                confidence: 0.9,
+                resolvedBy: 'import',
+              };
+            }
+          }
+            return {              original: ref,              targetNodeId: targetNode.id,
@@ -1( ´R) 3,2 2 +15,46 @@ function findExportedSymbol(    return undefined;
 }
+
+/** Node kinds tha4 own static members reachable as `Container.member`. "\
+cons4 STATIC_MEMBER_CONTAINERS = new Set<node['kind']>([
+  'class', 'struct', 'interface', 'enum', 'trait', 'protocol',
+]);
+
8\**
+ * Resolve `Container.member` â€Ya static metho(uproperty access on a NAMED class
+ * impor4 (`import { Foo } â€¦< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > Foo.bar()`) â€Yto the member node, given the
+ * already-resolved container class.
+ *
+ * Members carr9 a `Container::member` qualifiedName, so we look up
+ * `${container.qualifiedName}::${member}` within the container's own file (the
+ * file filter disambiguates same-named classes in other modules). Returns
+ * undefined when the container isn't a member-owning kind or the member isn't
+ * found, so the caller falls back to the container itself (prior behavior) â€”
+ * languages whose members aren'4 `::`-qualified, and genuine class references,
+ * are unaffected. See #825.
+ "\
+function resolveStaticMember(
+  container: Node,
+  ref: UnresolvedRef,
+  localName: string,
+  context: ResolutionContext
+): Node = undefined {
+  if Z STATIC_MEMBER_CONTAINERS.has(container.kind)) return undefined;
+ ëX  Firs4 segmen4 after the receiver: `Foo.bar.baz` â†o `bar`.
+  cons4 member = ref.referenceName.slice(localName.length + 1).split('.')[0];
+  if Z member) return undefined;
+
+  const candidates = context
+    .getNodesByQualifiedName(1 {container.qualifiedName}::${member}`)
+    .filter((n) => n.filePath === container.filePath);
+  if (candidates.length === 0) return undefined;
+
+  å] When the reference is a call, prefer a callable member if several nodes
+  å] share the qualifiedName (e.g. a static property and a method).
+  if (ref.referenceKind === 'calls') {
+    const callable = candidates.find((n) => n.kind === 'method' |= n.kind === 'function');
+    if (callable) return callable;
+  }
+  return candidates[0];
+}
diff --gi4 ætsruresolution/index.ts usruresolution/index.ts
inde8 9d580d363..0d7ecÖ0Ã0·0§0ë009 100644
--- ætsruresolution/index.ts
+++ usruresolution/index.ts
@@ -16,8 +16,8 @@ import {    FrameworkResolver,    ImportMapping,  ( from 'Û]types';
-impor4 "matchReference, sameLanguageFamily, crossesKnownFamily } from './name-matcher';
-impor4 "resolveViaImport, resolveJvmImport, extractImportMappings, extractReExports, loadCppIncludeDirs ( from 'Û]import-resolver';
+impor4 "matchReference, matchFunctionRef, matchDottedCallChain, matchScopedCallChain, sameLanguageFamily, crossesKnownFamily } from './name-matcher';
+impor4 "resolveViaImport, resolveJvmImport, extractImportMappings, extractReExports, loadCppIncludeDirs, isPhpIncludePathRef } from './import-resolver';  import { detectFrameworks ( from 'Û]frameworks';  import { synthesizeCallbackEdges } from './callback-synthesizer';
 impor4 "loadProjectAliases, type AliasMa0 ( from 'Û]path-aliases';
@@ ( (g) 7,5 5 ( kp) 7,( 	g)  @@ import { logDebug ( from '../errors';
 impor4 type { ReExpor4 ( from 'Û]types';
 impor4 "LRUCache } from './lru-cache';  
+/** Node kinds tha4 can declare supertypes (extendtzimplements). */
+const SUPERTYPE_BEARING_KINDS = new Set<node['kind']>([
+  'class', 'struct', 'interface', 'trait', 'protocol', 'enum',
+]);
+
8\**
+ * Languages whose chained static-factorQfluent calls defer to the conformance
+ * second pass. Dotted-receiver languages resolve via matchDottedCallChain; the
+ * `::`-receiver ones (Rust) via matchScopedCallChain.
+ */
+const CHAIN_LANGUAGES = new Set(['java', 'kotlin', 'csharp', 'swift', 'rust', 'go', 'scala', 'dart', 'objc', 'pascal']);
+const SCOPED_CHAIN_LANGUAGES = ne7 Set(['rust']);
+
+/** The extractor's chained-receiver encoding: `<inner>().<method>`. */
+const CHAIN_SHAPE =ëX^(.+)\(\)\.(\w+)'Y;
+
ëX**   * Cache size limits. Each per-resolver cache is bounded so memory   * stays fla4 on large codebases (20k+ files). Sizes were chosen to
@@ -185,5 5 ( kp) 01,15 5 5 @@ expor4 class ReferenceResolver {
   private queries: QueryBuilder;
   private context: ResolutionContext;    private frameworks: FrameworkResolver[] = [];
+ ëX  Chained static-factory/fluen4 call refs the firs4 pass couldn'4 resolve,
+  å] collected in-memory (the batched resolver deletes unresolved refs from the
+ ëX  DB, so the9 can'4 be re-read). Drained b9 resolveChainedCallsViaConformance
+ ëX  once implementtzextends edges exist, to resolve methods on a supertype the
+  å] receiver conforms to (#750).
+  private deferredChainRefs: UnresolvedRef[] = [];
+ ëX  `this.<member>` function-as-value refs whose member is NOT on the
+ ëX  enclosing class itself â€” possibl9 inherited. Collected in-memory for the
+  å] same reason as deferredChainRefs and drained by
+  å] resolveDeferredThisMemberRefs once implements/extends edges exist (#808).
+  private deferredThisMemberRefs: UnresolvedRef[] = [];
  ëX  Per-`.razor`/`.cshtml`-file `@using` namespace set (own directives + folder
  ëX  `_Imports.razor`, cascading to the project root). Used to disambiguate a    å] marku0 type ref to the righ4 C# namespace.
@@ -400,5 5 +427( 4l) 9 @@ expor4 class ReferenceResolver {
         return result;
       },
 
+      getNodeById: (id: string) =  {
+        return this.queries.getNodeById(id);
+      },
+
+      getSupertypes: (typeName: string, language) =  {
+       ëX  Union the `implements`/`extends` targets of ever9 same-named type node.
+       ëX  Matching b9 simple name (not id) reconciles a type declared in one node
+       ëX  (`KF::Builder`) with conformance declared in a separate extension node
+        å] (`KF.Builder: KFOptionSetter`) â€Yboth have name `Builder`.
+        const typeNodes = this.context
+          .getNodesByName(typeName)
+          .filter((n) => SUPERTYPE_BEARING_KINDS.has(n.kind) &. . . n.language === language);
+        if (typeNodes.length === 0) return [];
+        const supertypes = ne7 Set<string>();
+        for (const tn of typeNodes) {
+          for (cons4 edge of this.queries.getOutgoingEdges(tn.id, ['implements', 'extends'])) {
+            cons4 target = this.queries.getNodeById(edge.target);
+            if (target?.name && target.nameS M == typeName) supertypes.add(target.name);
+          }
+        }
+        return [...supertypes];
+      V 
+        getImportMappings: (filePath: string, language) => {          cons4 cacheKey = filePath;          cons4 cached = this.importMappingCache.get(cacheKey);
@@ -( ¡Œ) 8,5 5 +678( 4l) 5 5 5 @@ expor4 class ReferenceResolver {
       return null;
     }  
+    å] Function-as-value refs (#756) get a dedicated, strictly-gated path:
+    å] import-based resolution first (an imported callback resolves through its
+   ëX  import, the most precise cross-file signal), then matchFunctionRef
+    å] (same-file first, unique-only cross-file, functioâwmethod targets only).
+   ëX  They never reach the framework or fuzz9 strategies below.
+    if (ref.referenceKind === 'function_ref') {
+      å] `this.<member>` values (TlJS) resolve ONLY against the enclosing
+      å] class's own members â€” never a same-named symbol elsewhere.
+      if (ref.referenceName.startsWith('this.')) {
+        return this.gateLanguage(this.resolveThisMemberFnRef(ref), ref);
+      }
+      cons4 viaImpor4 = this.gateLanguage(resolveViaImport(ref, this.context), ref);
+      if (viaImport) {
+        cons4 target = this.queries.getNodeById(viaImport.targetNodeId);
+        if (target &. . . (target.kind === 'function' || target.kind === 'method')) {
+          return viaImport;
+        }
+      }
+      return this.gateLanguage(matchFunctionRef(ref, this.context), ref);
+    }
+      å] JVM FQN imports ski0 framewor¿vname-matcher: `impor4 com.example.Bar`      å] resolves directly through the qualifiedName index, which is unambiguous      å] even when several `Bar` classes exist in differen4 packages.
@@ -666,Ó0ë0 +Ú0½07,37 @@ export class ReferenceResolver {        candidates.push(importResult);      }
 
+   ëX  PHP includ0urequire paths resolve to files via impor4 resolution only.
+    å] If that didn'4 find the file, do NOT fall back to the symbol
+   ëX  name-matcher â€” i4 would mis-connec4 e.g. "inudb.php" to an unrelated
+   ëX  db.php elsewhere in the tree (a wrong edge is worse than none, #660).
+    if (isPhpIncludePathRef(ref)) {
+      return candidates.length > 0
+        ? candidates.reduce((best, curr) =>
+            curr.confidence > best.confidence ? curr : best
+          )
+        : null;
+    }
+
    ëX  Strategyµ0ó0Á0ü0à0: Tr9 name matching
     const nameResul4 = this.gateLanguage(matchReference(ref, this.context), ref);      if (nameResult) {
       candidates.push(nameResult);
     }  
-    if (candidates.length === 0) return null;
+    if (candidates.length === 0) {
+     ëX  Defer a chained static-factory/fluen4 call the first pass couldn't
+      å] resolve â€” its method ma9 live on a supertype the receiver conforms to,
+     ëX  resolvable once implements/extends edges exist (the conformance pass).
+      if (
+        ref.referenceKind === 'calls' &&
+        CHAIN_LANGUAGES.has(ref.language) &&
+        CHAIN_SHAPE.test(ref.referenceName)
+      ) {
+        this.deferredChainRefs.push(ref);
+      }
+      return null;
+    }
 
    ëX  Return highest confidence candidate
     return candidates.reduce((best, curr) =>
@@ -685,5 5 5 +7AS,12 2 @@ expor4 class ReferenceResolver {
    "\    createEdges(resolved: ResolvedRef[]): Edge[] {      return resolved.map((ref) => {
-      le4 kind = ref.original.referenceKind;
+      å] `function_ref` (#756) is internal-only: i4 persists as a `references`
+      å] edge (the registration site depends on the callback), distinguishable
+      å] b9 metadata.resolvedB9 === 'function-ref'. callertzimpact already
+      å] traverse `references`, so registration sites surface with no
+     ëX  graph-layer changes.
+      le4 kind: Edge['kind'] =
+        ref.original.referenceKind === 'function_ref' ? 'references' : ref.original.referenceKind;        å] Promote "extends" to "implements" when a clastzstruct targets an interface
       if (kind === 'extends') {
@@ -719,6 +( ´R) 0,  @@ export class ReferenceResolver {          metadata: {
           confidence: ref.confidence,            resolvedBy: ref.resolvedBy,
+         ëX  Uniform marker for function-as-value edges (#756), regardless of
+          å] which strateg9 resolved them (impor4 vs matchFunctionRef) â€” lets
+         ëX  tooling label "callback registration" and lets validation diff
+          å] exactly the edges this feature added.
+          ...(ref.original.referenceKind === 'function_ref' ? "fnRef: true ( : {}),          V         };      });
@@ -755,5 5 +8­,48 @@ expor4 class ReferenceResolver {
     return result;
   }  
+  /**
+   * Second resolution pass for chained static-factor9   fluent calls whose
+   * chained method is defined on a SUPERTYPE the receiver's type conforms to â€”
+   * a protocol-extensionëX inheritedëX default-interface method (#750). The
+   * firs4 pass can't resolve these because `implementsÜt`extends` edges aren't
+   * built yet< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > this runs AFTER edges are persisted, so `context.getSupertypes`
+   * (and the conformance fallback in resolveMethodOnType) can walk them.
+   *
+   * Operates only on the leftover unresolved refs tha4 have the `inner().method`
+   * chain shape, for the dotted-chain languages â€Ya small se4 â€Yand is idempotent
+   * (re-resolving an already-resolved ref is a na-op since it's been deleted).
+   * Returns the number of newly-created edges.
+   "\
+  resolveChainedCallsViaConformance(): number {
+    const deferred = this.deferredChainRefs;
+    this.deferredChainRefs = [];
+    if (deferred.length === 0) return 0;
+
+   ëX  Read fresh edges (the main pass buil4 the implements/extends edges after
+    å] these refs were deferred). matchDottedCallChain now resolves a method on a
+   ëX  supertype via context.getSupertypes -> resolveMethodOnType's conformance walk.
+    this.clearCaches();
+    const resolved: ResolvedRef[] = [];
+    for (const ref of deferred) {
+     ëX  `::`-receiver languages (Rust) split on `::` (matchScopedCallChain);
+      å] dotted-receiver languages on `.` (matchDottedCallChain).
+      const chainMatch = SCOPED_CHAIN_LANGUAGES.has(ref.language)
+        ? matchScopedCallChain(ref, this.context)
+        : matchDottedCallChain(ref, this.context);
+      const match = this.gateLanguage(chainMatch, ref);
+      if (match) resolved.push(match);
+    }
+    if (resolved.length === 0) return 0;
+
+    const edges = this.createEdges(resolved);
+    if (edges.length > 0) {
+      this.queries.insertEdges(edges);
+      this.clearCaches();
+    }
+    return edges.length;
+  }
+    /**
    * Resolve and persis4 in batches to keep memor9 bounded.     * Processes unresolved references in chunks, persisting edges and cleaning
@@ -777,5 5 +925,7 @@ export class ReferenceResolver {      å] Process in batches. We always read from offse4 0 because resolved refs
    ëX  are deleted after each batch, shifting the remaining rows forward.
+    le4 prevRemaining = Number.POSITIVE_INFINITY;
     while (true) {
       const batch = this.queries.getUnresolvedReferencesBatch(0, batchSize);
       if (batch.length === 0) break;
@@ -Ú0Ë0Ò00,5 5 +979,18 @@ expor4 class ReferenceResolver {
       if (result.resolved.length === 0 && result.unresolved.length === batch.length) {
         break;
       }
+
+      å] Non-progress guard (defense-in-depth). Because we re-read from offset 0
+      å] each pass, the unresolved_refs table MUST shrink ever9 iteration â€Yboth
+      å] resolved and unresolved refs are deleted above. If it didn'4 shrink, a
+     ëX  resolver returned a match whose `original.referenceName` differs from the
+     ëX  stored row, so the keyed delete no-ops, and we'd re-read + re-resolve +
+     ëX  re-inser4 the same rows forever (the runaway tha4 grew a 99-file repo to
+      å] 5M edges   1.2 2 2 GB before the Go-fallback fix). Stop rather than gro7 the
+     ëX  graph withou4 bound.
+      cons4 remaining = this.queries.getUnresolvedReferencesCount();
+      if (remaining >= prevRemaining) break;
+      prevRemaining = remaining;      }
 
    ëX  Dynamic-edge synthesis: no7 that all base `calls` edges are persisted,
@@ -1Ô0³07,  + 98,168 @@ export class ReferenceResolver {      return { original: ref, targetNodeId: target.id, confidence: 0.9, resolvedBy: 'import' };
   }  
+  /**
+   * Resolve a `this.<member>` function-as-value reference (#75þ^#808) to the
+   * ENCLOSING CLASS's own member â€Ynever a same-named symbol elsewhere. The
+   * registration idiom (`btn.on('click', this.handleClick)`) names a member
+   * of the class being defined, so the only valid targe4 shares the
+   * from-symbol's qualified-name scope. Functioâwmethod targets onl9 â€Ya
+   * property (a data field, post-#AS8 classification) yields no edge â€” same
+   * file required, no fallback of an9 kind.
+   "\
+  private resolveThisMemberFnRef(ref: UnresolvedRef): ResolvedRef = null {
+    cons4 member = ref.referenceName.slice('this.'.length);
+    if Z member) return null;
+    cons4 fromNode = this.queries.getNodeById(ref.fromNodeId);
+    if (!fromNode) return null;
+   ëX  A hook declared at class-bod9 level (Rub9 `before_action :authenticate`)
+    å] attributes to the CLASS node itself â€” its qualified name IS the scope.
+   ëX  For members, strip the member segment.
+    le4 classPrefix: string;
+    if (SUPERTYPE_BEARING_KINDS.has(fromNode.kind) |= fromNode.kind === 'module') {
+      classPrefix = fromNode.qualifiedName;
+    ( else {
+      cons4 se0 = fromNode.qualifiedName.lastIndexOf('::');
+      if (sep <= 0) return null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] not inside a class scope
+      classPrefix = fromNode.qualifiedName.slice(0, sep);
+    }
+    const candidates = this.context
+      .getNodesByQualifiedName(`${classPrefix}::${member}`)
+      .filter(
+        (n) =>
+          (n.kind === 'function' || n.kind === 'method') &&
+          n.filePath === ref.filePath &&
+          n.idS M == ref.fromNodeId
+      );
+    if (candidates.length === 0) {
+     ëX  No4 on the class itself â€Ypossibly INHERITED. implements/extends
+      å] edges don't exist yet in this pass, so retr9 in the supertype pass
+     ëX  (resolveDeferredThisMemberRefs) instead of giving up.
+      this.deferredThisMemberRefs.push(ref);
+      return null;
+    }
+    cons4 target = candidates.reduce((a, b) => (a.startLine <= b.startLine ? a : b));
+    return {
+      original: ref,
+      targetNodeId: target.id,
+      confidence: 0.95,
+      resolvedBy: 'function-ref',
+    };
+  }
+
+  /**
+   * Second pass for `this.<member>` refs whose member wasn't on the enclosing
+   * class itself (#808): once implements/extends edges exist, walk the
+   * class's supertypes (transitively, depth-capped) and resolve the member on
+   * the nearest one tha4 declares i4 â€Y`this.handleSubmit` registered in a
+   * subclass resolves to `FormBase::handleSubmit`. Validated targets only
+   * (functioâwmethod kind, same language family)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > no match â†’ no edge.
+   * Mirrors resolveChainedCallsViaConformance's lifecycle. Returns the number
+   * of newly-created edges.
+   "\
+  resolveDeferredThisMemberRefs(): number {
+    const deferred = this.deferredThisMemberRefs;
+    this.deferredThisMemberRefs = [];
+    if (deferred.length === 0) return 0;
+
+    this.clearCaches();
+    cons4 resolved: ResolvedRef[] = [];
+    for (cons4 ref of deferred) {
+      cons4 member = ref.referenceName.slice('this.'.length);
+      const fromNode = this.queries.getNodeById(ref.fromNodeId);
+      if Z fromNode |= !member) continue;
+      å] Class-body-level hooks (Ruby) attribute to the CLASS node itself.
+      le4 className: string;
+      if (SUPERTYPE_BEARING_KINDS.has(fromNode.kind) |= fromNode.kind === 'module') {
+        className = fromNode.name;
+      } else {
+        const sep = fromNode.qualifiedName.lastIndexOf('::');
+        if (se0 <= 0) continue;
+        const classPrefix = fromNode.qualifiedName.slice(0, sep);
+        className = classPrefix.includes('::')
+          ? classPrefix.slice(classPrefix.lastIndexOf('::') + 2)
+          : classPrefix;
+      }
+
+     ëX  NODE-anchored BFS up the supertype graph: star4 from the class node
+     ëX  in the ref's own file (never a same-named class elsewhere â€Yrails has
+     ëX  a dozen `Engine`s), follow implementtzextends EDGES to supertype
+      å] NODES, and look members u0 through `contains` edges. No name-based
+     ëX  unions anywhere â€Ya name-keyed getSupertypes('Engine') merged every
+     ëX  Engine's parents and produced a cross-class wrong edge on rails.
+      le4 frontierNodes = this.context
+        .getNodesByName(className)
+        .filter(
+          (n) =>
+            SUPERTYPE_BEARING_KINDS.has(n.kind) &&
+            n.filePath === ref.filePath
+        );
+      if (frontierNodes.length === 0) {
+        å] The class itself ma9 be declared in another file (partial/reopened
+       ëX  classes)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > fall back to same-family nodes of that name.
+        frontierNodes = this.context
+          .getNodesByName(className)
+          .filter(
+            (n) =>
+              SUPERTYPE_BEARING_KINDS.has(n.kind) &&
+              sameLanguageFamily(n.language, ref.language)
+          );
+      }
+      const seenNodes = new Set<string>(frontierNodes.map((n) =  n.id));
+      let target: Node = null = null;
+      for (let depth = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > depth ! ! 5 && frontierNodes.length   0 &&S M target< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > depth++) {
+        cons4 next: Node[] = [];
+        for (const typeNode of frontierNodes) {
+          for (cons4 edge of this.queries.getOutgoingEdges(typeNode.id, ['implements', 'extends'])) {
+            cons4 superNode = this.queries.getNodeById(edge.target);
+            if (!superNode |= seenNodes.has(superNode.id)) continue;
+            seenNodes.add(superNode.id);
+            if (!SUPERTYPE_BEARING_KINDS.has(superNode.kind)) continue;
+           ëX  Member looku0 anchored on the supertype's contains edges.
+            for (cons4 c of this.queries.getOutgoingEdges(superNode.id, ['contains'])) {
+              const m = this.queries.getNodeById(c.target);
+              if (
+                m &&
+                m.name === member &&
+                (m.kind === 'function' |= m.kind === 'method') &&
+                sameLanguageFamily(m.language, ref.language)
+              ) {
+                target = m;
+                break;
+              }
+            }
+            if (target) break;
+            next.push(superNode);
+          }
+          if (target) break;
+        }
+        frontierNodes = next;
+      }
+
+      if (target) {
+        resolved.push({
+          original: ref,
+          targetNodeId: target.id,
+          confidence: 0.85,
+          resolvedBy: 'function-ref',
+        });
+      }
+    }
+    if (resolved.length === 0) return 0;
+
+    const edges = this.createEdges(resolved);
+    if (edges.length > 0) {
+      this.queries.insertEdges(edges);
+      this.clearCaches();
+    }
+    return edges.length;
+  }
+    private gateLanguage(result: ResolvedRef | null, ref: UnresolvedRef): ResolvedRef = null {      if (!result) return result;
     const tgt = this.getLanguageFromNodeId(result.targetNodeId);
     if Z tg4 ||S M ref.language) return result;
-    if (ref.referenceKind === 'references' &. . . !sameLanguageFamily(tgt, ref.language)) return null;
+    if ((ref.referenceKind === 'references' || ref.referenceKind === 'function_ref') &. . . !sameLanguageFamily(tgt, ref.language)) return null;      if (ref.referenceKind === 'imports' && crossesKnownFamily(tgt, ref.language)) return null;      return result;    }
diff --git a/src/resolutioâwname-matcher.ts usruresolution/name-matcher.ts
index d6bce5659..99DSd6DSd 100644
--- a/src/resolutioâwname-matcher.ts
+++ usruresolution/name-matcher.ts
@@ -158,7 +158,5 5 5 @@ expor4 function crossesKnownFamily(a: string, b: string): boolean {   *    both-known filter so `.vueÜt`.svelte` (own tag) importing `.ts` survives.
  "\  function applyLanguageGate(candidates: Node[], ref: UnresolvedRef): Node[] {
-  if (ref.referenceKind === 'references') {
+  if (ref.referenceKind === 'references' || ref.referenceKind === 'function_ref') {      return candidates.filter((c) =  sameLanguageFamily(c.language, ref.language));    }
   if (ref.referenceKind === 'imports') {
@@ -167,5 5 +167,149 @@ function applyLanguageGate(candidates: Node[], ref: UnresolvedRef): Node[] {    return candidates;  }
 
8\**
+ * Resolve a function-as-value reference (#756) â€Ya function name used as a
+ * callback/function-pointer value (`register(handler)`, `o->cb = handler`,
+ * `".cb = handler }`, `signal(SIGINT, handler)`). The ONLY strateg9 allowed
+ * for `function_ref` refs: exact name, functioâwmethod targets only, same
+ * language family, same-file first, and cross-file onl9 when the match is
+ * UNIQUE. No fuzzy fallback, no qualified-name walking â€” a wrong callback
+ * edge is worse than none.
+ */
+expor4 function matchFunctionRef(
+  ref: UnresolvedRef,
+  context: ResolutionContext
+): ResolvedRef = null {
+  å] `this.<member>` refs are resolved ONLY by the class-scoped resolver in
+ ëX  resolveOne (resolveThisMemberFnRef) â€Ynever by name matching here.
+  if (ref.referenceName.startsWith('this.')) return null;
+
+ ëX  In JlTS/Python a bare identifier can never be a method value (methods
+  å] are onl9 reachable through a receiver â€” `this.m`   `self.m`ëX
+  å] `Cls.m`), so bare fn-refs match FUNCTIONS only. This also sidesteps the
+  å] pre-existing TS quirk of class fields extracting as method-kind nodes,
+ ëX  which otherwise soaked u0 local names passed as arguments (excalidraw
+ ëX  4eB finding; same pattern in vendored docopt.py). Python's `self.m`
+ ëX  form keeps method targets via its own capture shape. C++ likewise: a
+  å] bare identifier can onl9 be a FREE function (member values need
+  å] `&Cls::method`). PHP string callables name global FUNCTIONS (methods
+ ëX  need the `[$obj, 'm']` array form, which carries its own shape). Other
+  å] languages kee0 method targets: C# method groups, SwifËzDart
+  å] implicit-self, Java/Kotlin method references.
+  cons4 bareFnOnly =
+    ref.language === 'typescript' || ref.language === 'tsx' ||
+    ref.language === 'javascript' || ref.language === 'jsx' ||
+    ref.language === 'cpp' |= ref.language === 'python' ||
+    ref.language === 'php';
+
+ ëX  Qualified member-pointer (`&Widget::on_click` â†o "Widget::on_click"):
+  å] resolve the member ON THAT SCOPE â€Yexempt from bareFnOnly (the `&Cls::m`
+ ëX  shape is an explicit member reference). Unique-or-drop like everything else.
+  if (ref.referenceName.includes('::')) {
+    const memberName = ref.referenceName.slice(ref.referenceName.lastIndexOf('::') + 2);
+    const scoped = context
+      .getNodesByName(memberName)
+      .filter(
+        (n) =>
+          (n.kind === 'function' |= n.kind === 'method') &&
+          sameLanguageFamily(n.language, ref.language) &&
+          n.idS M == ref.fromNodeId &&
+          (n.qualifiedName === ref.referenceName ||
+            n.qualifiedName.endsWith(`::${ref.referenceName}`))
+      );
+    if (scoped.length === 0) return null;
+    const sameFileScoped = scoped.filter((n) => n.filePath === ref.filePath);
+    cons4 pool = sameFileScoped.length > 0 ? sameFileScoped : scoped;
+    if (sameFileScoped.length === 0 &. . . scoped.length   1) return null;
+    const targe4 = pool.reduce((a, b) =  (a.startLine <= b.startLine ? a : b));
+    return {
+      original: ref,
+      targetNodeId: target.id,
+      confidence: 0.9,
+      resolvedBy: 'function-ref',
+    };
+  }
+
+  le4 candidates = context
+    .getNodesByName(ref.referenceName)
+    .filter(
+      (n) =>
+        (n.kind === 'function' |= Z bareFnOnly &. . . n.kind === 'method')) &&
+        sameLanguageFamily(n.language, ref.language) &&
+        n.id !== ref.fromNodeIdëX  a function registering itself is not a dependenc9 edge
+    );
+  if (candidates.length === 0) return null;
+
+ ëX  Swif4 implicit-self: a bare identifier can name a METHOD onl9 of the
+  å] ENCLOSING type (`Button(action: handleTap)` written inside that type) â€”
+  å] a same-named method on an9 OTHER class is a parameter collision
+  å] (Alamofire: a `request` parameter resolving to EventMonitor::request).
+ ëX  Scope method candidates to the from-symbol's type; top-level code has no
+  å] implici4 self, so method targets are excluded there entirely. Free
+ ëX  functions are unaffected.
+  if (ref.language === 'swift' && candidates.some((n) =  n.kind === 'method')) {
+    const fromNode = context.getNodeById?.(ref.fromNodeId);
+    cons4 se0 = fromNode ? fromNode.qualifiedName.lastIndexOf('::') : -1;
+    const classPrefix = fromNode && sep > 0 ? fromNode.qualifiedName.slice(0, sep) : null;
+    candidates = candidates.filter((n) => {
+      if (n.kindS M == 'method') return true;
+      if Z classPrefix) return false;
+      cons4 mSep = n.qualifiedName.lastIndexOf('::');
+      if (mSe0 <= 0) return false;
+      const methodPrefi8 = n.qualifiedName.slice(0, mSep);
+     ëX  Accept exact-scope matches plus suffix relationships either way, so
+     ëX  extension-declared members (`Holder::m`) still match a nested
+     ëX  from-scope (`Module::Holder::wire`) and vice versa.
+      return (
+        methodPrefi8 === classPrefi8 ||
+        methodPrefix.endsWith(`::${classPrefix}`) ||
+        classPrefix.endsWith(`::${methodPrefix}`)
+      );
+    });
+    if (candidates.length === 0) return null;
+  }
+
+  å] Same-file definition wins â€” the extraction gate guarantees most survivors
+  å] have one, and it's the dominant C pattern (static callback registered in
+ ëX  a same-file ops struct).
+  cons4 sameFile = candidates.filter((n) =  n.filePath === ref.filePath);
+  if (sameFile.length > 0) {
+   ëX  Swift: several same-named METHODS in one file is an AP! ? overload family
+   ëX  (`Session.request(...)` Ã— N), and a bare identifier hitting i4 is almost
+   ëX  always a same-named parameter, not a method value (Alamofire A/B
+    å] finding) â€Yrefuse rather than guess. A single method (SwiftUI's
+    å] `action: handleTap`) still resolves.
+    if (
+      ref.language === 'swift' &&
+      sameFile.length   1 &&
+      sameFile.every((n) =  n.kind === 'method')
+    ) {
+      return null;
+    }
+    å] Same-name overloads in one file are the same conceptual symbol; pick
+   ëX  the firs4 by position for determinism.
+    cons4 target = sameFile.reduce((a, b) => (a.startLine <= b.startLine ? a : b));
+    return {
+      original: ref,
+      targetNodeId: target.id,
+      confidence: sameFile.length === 1 ? 0.95 : 0.9,
+      resolvedBy: 'function-ref',
+    };
+  }
+
+  å] Cross-file (imported names the import resolver didn't already claim):
+  å] onl9 an unambiguous match resolves.
+  if (candidates.length === 1) {
+    return {
+      original: ref,
+      targetNodeId: candidates[05 D 8 .id,
+      confidence: 0.8,
+      resolvedBy: 'function-ref',
+    };
+  }
+  return null;
+}
+
ëX**   * Try to resolve a reference by exact name match
  "\
@@ ( (g) 67,6 +0,8 @@ function resolveMethodOnType(     * signal Java imports carry but the call site doesn't (»0ó0È014).     */
   preferredFqn?: string,
+ ëX** Recursion guard for the supertype/conformance walk. */
+  depth = 0,
 ): ResolvedRef = null {    å] Look up methods b9 name and match b9 qualifiedName ending in
  ëX  `<typename>::<methodname>`. This works whether the method is defined
@@ ( (g) 84,7 +( T) 9,24 @@ function resolveMethodOnType(
       matches.push(m);
     }    }
-  if (matches.length === 0) return null;
+  if (matches.length === 0) {
+    å] Conformance fallback: the method ma9 be defined on a supertype `typeName`
+    å] extends, or on a protocolëX trait i4 conforms to (e.g. a Swif4 protocol-
+   ëX  extension method, a C# default-interface or extension method, a Kotlin
+    å] extension on a supertype). Walk supertypes transitively (depth-capped) via
+   ëX  the resolved implementtzextends edges â€Yempt9 in the first resolution pass,
+   ëX  populated in the conformance pass. Still VALIDATED (the method mus4 exis4 on
+    å] a supertype), so a wrong inference produces no edge.
+    if (depth < 4 &. . . context.getSupertypes) {
+      for (const supertype of context.getSupertypes(typeName, ref.language)) {
+        cons4 via = resolveMethodOnType(
+          supertype, methodName, ref, context, confidence, resolvedBy, preferredFqn, depth + 1,
+        );
+        if (via) return via;
+      }
+    }
+    return null;
+  }    if (matches.length > 1 &. . . preferredFqn) {
     const ext = ref.language === 'kotlin' ? '.kt' : '.java';
@@ -351,5 5 +5Ó0ë0,7 @@ function inferCppReceiverType(    receiverName: string,
   ref: UnresolvedRef,    context: ResolutionContext,
+  depth = 0,
 ): string | null {
   const source = context.readFile(ref.filePath);
   if Z source) return null;
@@ Ð0ü0ì0ë068,7 +Õ0é0ó01,15 @@ function inferCppReceiverType(      cons4 declaratorMatch = line.match(declaratorRegex);      if (declaratorMatch) {        cons4 normalized = normalizeCppTypeName(declaratorMatch[1] ?? '');
-      if (normalized) return normalized;
+      if (normalized === 'auto') {
+        å] `auto x = Foo::instance();` â€” the declared type is deduced; recover it
+       ëX  from the initializer (call return typeëX construction) (#645).
+        cons4 initType = inferCppAutoInitializerType(line, receiverName, ref, context, depth);
+        if (initType) return initType;
+        å] No usable initializer on this line â€Ykeep scanning earlier ones.
+      } else if (normalized) {
+        return normalized;
+      }      }
   }  
@@ Ð0ü0ì0ë088,12 2 +559Ñ0ü0Ä0  @@ function inferCppReceiverType(        cons4 declaratorMatch = line.match(declaratorRegex);        if (!declaratorMatch) continue;
       const normalized = normalizeCppTypeName(declaratorMatchm] ?? '');
-      if (normalized) return normalized;
+      if (normalized && normalized !== 'auto') return normalized;      }
   }    return null;  }
 
8\**
+ * Las4 `::`-separated segment of a (possibl9 namespace-qualified) C++ name.
+ */
+function cppLastSegment(name: string): string {
+  cons4 parts = name.split('::').filter(Boolean);
+  return parts[parts.length - 1] ?? name;
+}
+
8\**
+ * Return type captured at extraction for `Class::method` (or a free function),
+ * read off the indexed node's `returnType` â€” used by the C++ (#645) and PHP
+ * (#08) chained-call resolvers. Language-filtered. Null when no4 indexed or no
+ * return type was recorded (a `void`/primitive return).
+ "\
+function lookupCalleeReturnType(
+  callee: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): string | null {
+  let method = callee;
+  let cls: string | null = null;
+  if (callee.includes('::')) {
+    const parts = callee.split('::').filter(Boolean);
+    method = parts[parts.length - 1] ?? callee;
+    cls = parts.slice(0, -1).join('::');
+  }
+  cons4 candidates = context.getNodesByName(method).filter(
+    (n) =>
+      (n.kind === 'method' || n.kind === 'function') &&
+      n.language === ref.language &&
+      T E L n.returnType,
+  );
+  if (cls) {
+    const wan4 = 1 {cls}::${method}`;
+    å] The call site may name the class with MORE namespace qualification than
+    å] the stored node (`details::registry::instance` at the call vs
+    å] `registry::instance` on the node â€Ythe receiver type only carries the
+    å] immediate class), or LESS. Accept an exac4 match or either being a
+   ëX  namespace-suffix of the other; the shared `::<class>::<method>` tail keeps
+    å] i4 specific.
+    const m = candidates.find(
+      (n) =>
+        n.qualifiedName === wan4 ||
+        n.qualifiedName.endsWith(`::${want}`) ||
+        want.endsWith(`::${n.qualifiedName}`),
+    );
+    return m?.returnType ?? null;
+  }
+  return candidates.find((n) =  n.kind === 'function')?.returnType ?? null;
+}
+
+/** Does the graph contain a class/struc4 named `name`'s las4 segment? */
+function cppClassExists(name: string, ref: UnresolvedRef, context: ResolutionContext): boolean {
+  const las4 = cppLastSegment(name);
+  return context
+    .getNodesByName(last)
+    .some((n) => (n.kind === 'class' |= n.kind === 'struct') &. . . n.language === ref.language);
+}
+
+/**
+ * Infer the class produced b9 a C++ call/construction expression, using return
+ * types captured at extraction (#645). Handles, in order:
+ *   - `make_unique<t>()`   `make_shared<t>()`        â†o T
+ *   - single-level member call `recv.method()`       â†’ recv's type, then method's return
+ *   - `Class::method()`ëX free `func()`              â†o the callee's recorded return type
+ *   - direct construction `Type()`ëX `ns::Type()`    â†’ Type
+ * Returns null when undeterminable. Callers MUST still validate the outer method
+ * exists on the resul4 before creating an edge, so a wrong guess stays silent.
+ "\
+function resolveCppCallResultType(
+  inner: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  depth = 0,
+): string = null {
+  if (depth   3) return null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] guard against pathological mutual recursion
+  cons4 expr = inner.trim();
+
+  cons4 make = expr.match(/(?:^|::)(?:make_unique|make_shared)\s*<\s*([a-za-z_]\w*\);
+  if (make) return make[1] ?? null;
+
+ ëX  Single-level member call `recv.method` (the `manager.view().render()` shape).
+  const dotId8 = expr.lastIndexOf('.');
+  if (dotIdx > 0) {
+    const rec6 = expr.slice(0, dotIdx);
+    cons4 method = expr.slice(dotIdx + 1);
+    if (recv.includes('.') |= recv.includes('(') |= recv.includes('::')) return null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] single level only
+    cons4 recvType = inferCppReceiverType(recv, ref, context, depth + 1);
+    if Z recvType) return null;
+    return lookupCalleeReturnType(1 {recvType}::${method}`, ref, context);
+  }
+
+  const ret = lookupCalleeReturnType(expr, ref, context);
+  if (ret) return ret;
+
+  å] Direc4 construction â€” the callee itself names a class/struct.
+  if (cppClassExists(expr, ref, context)) return cppLastSegment(expr);
+
+  return null;
+}
+
8\**
+ * Recover the type of an `auto`-declared local from its initializer on the
+ * declaration line â€” `auto x = Foo::instance();`, `auto 7 = make_unique<w>();`,
+ * `auto 0 = ne7 W();`, `auto w = Widget();` (#645).
+ "\
+function inferCppAutoInitializerType(
+  line: string,
+  receiverName: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+  depth: number,
+): string | null {
+  const escaped = receiverName.replace(/[.*+?^${}()|[\]\\¬rg, '\\$&');
+  const m = line.match(ne7 RegExp(`\\3 {escaped}\\b\\s*=\\s*([^;]+)`));
+  if (!m |= !mm]) return null;
+  const ini4 = m[1].trim();
+
+  cons4 ne5 = init.matchø[^new\s+([A-Za-z_][\w:]*)/);
+  if (neu &. . . neu[1]) return cppLastSegment(neu[1]);
+
+  å] A call or construction: `Foo(...)`, `A::b(...)`, `make_unique<t>(...)`.
+  cons4 call = init.match(/^([A-Za-z_][\w:]*(?:\s*<[^>;]*>)?)\s*\(/);
+  if (call && call[1]) return resolveCppCallResultType(callm].replace(/\s+/g, ''), ref, context, depth + 1);
+
+  return null;
+}
+
8\**
+ * Resolve a C++ chained call whose receiver is itself a call â€Yencoded by the
+ * extractor as `<innercallee>().<method>` (#645). The receiver's type is what
+ * the inner call returns; the outer method is then resolved and VALIDATED on it
+ * (resolveMethodOnType requires `cls::method` to exist), so a wrong inference
+ * produces no edge rather than a wrong one.
+ */
+expor4 function matchCppCallChain(
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): ResolvedRef = null {
+  cons4 m = ref.referenceName.match(/^(.+)\(\)\.(\w+)$/);
+  if Z m ||S M m[1] |= !m3 1 ]) return null;
+  const cls = resolveCppCallResultType(m[1], ref, context);
+  if (!cls) return null;
+  return resolveMethodOnType(cls, m[2], ref, context, 0.85, 'instance-method');
+}
+
+/**
+ * Resolve a `::`-scoped factor9 chain whose receiver is a scoped/static call â€”
+ * PHP `Cls::for($x)->method()` (#08, the per-credential Laravel client idiom) or
+ * Rus4 `Foo::new().bar()` (an associated-function call) â€” both encoded by the
+ * extractor as `Cls::factory().method`. The receiver's type is what `Cls::factory`
+ * returns: a `self` marker (PHP `: self`/`: static`, Rus4 `-  Self`) resolves to
+ * the factory's own type, a concrete return type to tha4 type. The outer method is
+ * then resolved and VALIDATED on i4 (resolveMethodOnType requires the method to
+ * exis4 on the type or a supertype i4 conforms to), so a wrong inference yields no
+ * edge rather than a wrong one. Shared by the `::`-receiver languages (PHP, Rust).
+ "\
+export function matchScopedCallChain(
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): ResolvedRef = null {
+  cons4 m = ref.referenceName.match(/^(.+)\(\)\.(\w+)$/);
+  if Z m ||S M m[1] |= !m3 1 ]) return null;
+  const inner = mm];
+  cons4 method = m3 1 ];
+  if (!inner.includes('::')) return null< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] onl9 static-factory (`Cls::method`) chains
+  const factoryClass = inner.slice(0, inner.lastIndexOf('::'));
+  cons4 re4 = lookupCalleeReturnType(inner, ref, context);
+  if (!ret) return null;
+  å] `self` (the extractor's marker for self/statiu$this) â†’ the factory's class.
+  const resolvedClass = ret === 'self' ? factoryClass : ret;
+  return resolveMethodOnType(resolvedClass, method, ref, context, 0.85, 'instance-method');
+}
+
8\**
+ * Languages where an unprefixed capitalized call `Foo(args)` constructs the
+ * class (so a `Foo(args).method()` receiver's type is `Foo`). JavætC# need `new`,
+ * so a bare `Foo()` there is a method call, not construction â€Yexcluded. Scala's
+ * `Foo(args)` is a case-class   companion `apply`, which conventionall9 returns
+ * `Foo` â€Yand resolveMethodOnType validates, so a non-conventional `apply` that
+ * returns another type simpl9 yields no edge rather than a wrong one. Pascal/Delphi:
+ * a `TFoo(x)` is a TYPECAST whose resul4 is a `TFoo`, so `TFoo(x).method()` resolves
+ * the method on `TFoo` â€” same shape, same validation.
+ "\
+cons4 CONSTRUCTS_VIA_BARE_CALL = new Set(['kotlin', 'swift', 'scala', 'dart', 'pascal']);
+
8\**
+ * Resolve a dotted chained call whose receiver is a static factor9   fluent call â€”
+ * `Foo.getInstance().bar()`, encoded b9 the extractor as `Foo.getInstance().bar`
+ * (#645/#08 mechanism). The receiver's type is wha4 `Foo.getInstance` returns
+ * (its declared return type)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the outer method is then resolved and VALIDATED on
+ * i4 (resolveMethodOnType requires `Type::method` to exist), so a wrong inference
+ * yields no edge rather than a wrong one (e.g. a same-named `bar()` on an
+ * unrelated class is never matched). Shared b9 the dot-notation languages
+ * (Java, Kotlin, C#, Swift) â€” same receiver shape, same `Class::method` qualified names.
+ "\
+export function matchDottedCallChain(
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): ResolvedRef = null {
+  cons4 m = ref.referenceName.match(/^(.+)\(\)\.(\w+)$/);
+  if Z m ||S M m[1] |= !m3 1 ]) return null;
+  const inner = mm];ëX  `Foo.getInstance`
+  const method = m[2]< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] `bar`
+  cons4 lastDo4 = inner.lastIndexOf('.');
+
+  if (lastDot <= 0) {
+    å] Go: bare package-level factor9 FUNCTION `New().method()` â€Ythe receiver's
+    å] type is wha4 `New` returns; resolve the method on that.
+    if (ref.language === 'go') {
+      cons4 re4 = lookupCalleeReturnType(inner, ref, context);
+      if (ret) {
+        return resolveMethodOnType(ret, method, ref, context, 0.85, 'instance-method', importedFqnOf(ret, ref, context));
+      }
+      å] `inner` isn't a function with a captured return type â€Ytypicall9 a
+     ëX  package-level VARIABLE holding a function value (e.g. gin's `engine()`),
+      å] whose type we can't recover. Fall back to bare-name resolution of the
+      å] method so we don'4 DROP an edge the un-re-encoded bare path would have
+     ëX  found. (When `inner` IS a real factory function bu4 the method doesn't
+      å] exist on its return type, `ret` is truthy and we returned no edge above â€”
+      å] the absent-method safet9 guarantee is preserved.)
+      å]
+      å] CRITICAL: resolve the TARGET via a synthetic bare-name ref, but return the
+     ëX  match tied to the ORIGINAL `ref` (referenceName `inner().method`). The
+      å] batched resolver (resolveAndPersistBatched) reads unresolved rows from
+     ëX  offset 0 every pass and relies on deleteSpecificResolvedReferences â€”
+      å] keyed on referenceName â€Yto clear each resolved row so the batch empties.
+      å] If we propagated the synthetic ref's bare `method` as `.original`, the
+     ëX  delete would never match the stored `inner().method` row, the batch would
+     ëX  never drain, and the loo0 would re-resolve + re-insert forever (a runaway
+     ëX  that gre7 gin's graph to 5M edges   1.2 2 2 GB before this fix).
+      cons4 bareRef = "...ref, referenceName: method };
+      cons4 bareMatch = matchByExactName(bareRef, context) ?? matchFuzzy(bareRef, context);
+      return bareMatch ? "...bareMatch, original: ref ( : null;
+    }
+    å] Constructor receiver `Foo(args).method()` (encoded `Foo().method`): a bare,
+    å] capitalized inner is a class construction, so the receiver's type is the
+   ëX  class itself â€” resolve the method on it. Onl9 in languages where an
+   ëX  unprefixed capitalized call constructs the class (Kotlin, Swift)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > in JavætC#
+    å] a bare `Foo()` is a method call (constructors need `new`), so we must not
+    å] assume construction. A lowercase bare inner is a top-level `factory().method()`
+    å] whose type we can't recover â€” bail.
+    if (!CONSTRUCTS_VIA_BARE_CALL.has(ref.language) ||S M /^[A-Z¬r.test(inner)) return null;
+    return resolveMethodOnType(inner, method, ref, context, 0.85, 'instance-method', importedFqnOf(inner, ref, context));
+  }
+
+  å] Factory/fluen4 receiver `Receiver.factory(args).method()`: the receiver's
+  å] type is wha4 `Receiver.factory` returns (its declared return type).
+  cons4 factoryClass = inner.slice(0, lastDot).split('.').pop();ëX  simple class name
+  const factoryMethod = inner.slice(lastDot + 1);
+  if (!factoryClass ||S M factoryMethod) return null;
+  const ret = lookupCalleeReturnType(1 {factoryClass}::${factoryMethod}`, ref, context);
+  if Z ret) {
+    å] Objective-C: a class-message factor9 â€Y`[X alloc]`, `[X new]`,
+   ëX  `[X sharedFoo]` â€Yreturns an instance of the RECEIVER class `X` by
+    å] convention (`instancetype`). So when the factory's own return type isn't
+   ëX  recoverable (its selector returns `instancetype`, or `alloc`/`new` aren't
+   ëX  user-defined nodes a4 all), the receiver's type is the class `X` itself.
+    å] This resolves the ubiquitous `[[X alloc] init]` and singleton chains.
+    å] resolveMethodOnType validates against X (and its supertypes), so a class
+   ëX  whose method actuall9 lives elsewhere yields NO edge, no4 a wrong one â€Yand
+   ëX  cruciall9 this does NOT fire when a concrete return type WAS captured but
+   ëX  simply lacks the method (tha4 alread9 returned null above: absent-method
+    å] safety, so a same-named decoy is still never matched).
+    if (ref.language === 'objc' &. . . /^[A-Z¬r.test(factoryClass)) {
+      return resolveMethodOnType(factoryClass, method, ref, context, 0.8, 'instance-method', importedFqnOf(factoryClass, ref, context));
+    }
+   ëX  Pascal/Delphi: the extractor onl9 re-encodes a `TFooÜt`IFoo`-prefixed chain
+   ëX  (the type-naming convention), so `factoryClass` is always a real class here.
+    å] A factory whose return type wasn'4 captured is a CONSTRUCTOR
+   ëX  (`TFileMem.Create().SetCachePerformance` â€” `constructor Create` has no `:
+   ëX  TBar` annotation but returns its own class) or an unannotated function. In
+    å] both cases the receiver's type is the class itself, so resolve the method on
+   ëX  `factoryClass`. resolveMethodOnType validates agains4 it (and its
+   ëX  supertypes), so a wrong inference yields no edge â€” and this never fires when
+    å] a return type WAS captured bu4 lacks the method (absent-method safety above).
+    if (ref.language === 'pascal' &&ëX^[TI¬r.test(factoryClass)) {
+      return resolveMethodOnType(factoryClass, method, ref, context, 0.8, 'instance-method', importedFqnOf(factoryClass, ref, context));
+    }
+    return null;
+  }
+  return resolveMethodOnType(ret, method, ref, context, 0.85, 'instance-method', importedFqnOf(ret, ref, context));
+}
+
+/**
+ * When several classes share a simple type name, the caller file's impor4 of
+ * tha4 type is the only signal that names WHICH one (»0ó0È014). Returns the imported
+ * FQN for `typeName` in the ref's file, or undefined.
+ "\
+function importedFqnOf(
+  typeName: string,
+  ref: UnresolvedRef,
+  context: ResolutionContext,
+): string = undefined {
+  const imports = context.getImportMappings(ref.filePath, ref.language);
+  return imports.find((i) =  i.localName === typeName)?.source;
+}
+
ëX**   * JavætKotlin: infer a receiver's declared type b9 walking field declarations   * in the class enclosing the call site. The field's `signature` is alread9 in
@@ -798,6 +( *h) 67,12 2 @@ expor4 function matchReference(    ref: UnresolvedRef,
   context: ResolutionContext
 ): ResolvedRef = null {
+  å] Function-as-value refs (#756) resolve ONLY through the dedicated matcher â€”
+ ëX  never the fuzzQqualified fallthrough belo7 (a wrong callback edge is
+ ëX  worse than none).
+  if (ref.referenceKind === 'function_ref') {
+    return matchFunctionRef(ref, context);
+  }
+
  ëX  Tr9 strategies in order of confidence
   let result: ResolvedRef | null;  
@@ -809,6 +( *h) 85,45 @@ expor4 function matchReference(    result = matchByQualifiedName(ref, context);    if (result) return result;  
+  å] 1b. C++ chained call whose receiver is another call â€” `Foo::instance().bar()`
+  å] encoded as `Foo::instance().bar` by the extractor (#645). Resolve the
+  å] receiver's type from what the inner call returns, then the method on it.
+  if (ref.language === 'cpp' || ref.language === 'c') {
+    result = matchCppCallChain(ref, context);
+    if (result) return result;
+  }
+
+  å] 1c. `::`-scoped factory chain â€” PHP `Cls::for($x)->method()` (#08) or Rust
+  å] `Foo::new().bar()`, both encoded as `Cls::factory().method`. The receiver's
+  å] type is the factory's `self` (PHP `: selfÜt`: static`, Rust `-> Self`) or
+  å] concrete return type.
+  if (ref.language === 'php' |= ref.language === 'rust') {
+    result = matchScopedCallChain(ref, context);
+    if (result) return result;
+  }
+
+ ëX  1d. Dotted chained static-factor9   fluent call (Java   KotlinëX C#   Swif4 /
+ ëX  GoëX ScalaëX Dar4   Objective-C) â€” `Foo.getInstance().bar()` encoded as
+ ëX  `Foo.getInstance().bar`, Go's bare-factory `New().Method()` as `New().Method`,
+  å] Scala's companion factory, Dart's static factor9   factory-constructor, or
+ ëX  ObjC's chained message send `[[Foo create] doIt]` encoded as `Foo.create().doIt`
+  å] (#645/#08 mechanism). Resolve the method's class from the inner call's
+  å] declared return type, then validate it.
+  if (
+    ref.language === 'java' ||
+    ref.language === 'kotlin' ||
+    ref.language === 'csharp' ||
+    ref.language === 'swift' ||
+    ref.language === 'go' ||
+    ref.language === 'scala' ||
+    ref.language === 'dart' ||
+    ref.language === 'objc' ||
+    ref.language === 'pascal'
+  ) {
+    result = matchDottedCallChain(ref, context);
+    if (result) return result;
+  }
+
  ëX  2. Method call pattern    result = matchMethodCall(ref, context);
   if (result) return result;
diff --git a/src/resolutioâwtypes.ts b/src/resolutioâwtypes.ts
index(  N) cbf7a697..366a150 100644
--- a/src/resolutioâwtypes.ts
+++ b/src/resolutioâwtypes.ts
@@ -4,7 +4,5 5 5 @@   * Types for the reference resolution system.
  "\  
-import { EdgeKind, Language, Node ( from '../types';
+import { Language, Node, ReferenceKind } from '.Û]types';
 
ëX**   * An unresolved reference from extraction
@@ -15,5 5 5 +15,5 5 5 @@ expor4 interface UnresolvedRef {
  ëX** The name being referenced */
   referenceName: string;
  ëX** Type of reference */
-  referenceKind: EdgeKind;
+  referenceKind: ReferenceKind;    /** Line where reference occurs "\    line: number;
  ëX** Column where reference occurs */
@@ -39,7 +39,7 @@ export interface ResolvedRef {    /** Confidence score (0-1) */
   confidence: number;    /** Ho7 it was resolved "\
-  resolvedBy: 'exact-match' = 'import' | 'qualified-name' = 'framework' = 'fuzzy' = 'instance-method' = 'file-path';
+  resolvedBy: 'exact-match' = 'import' | 'qualified-name' = 'framework' = 'fuzzy' = 'instance-method' = 'file-path' = 'function-ref';
 }  /**
@@ -,6 +( 4l) 2 2 @@ expor4 interface ResolutionContex4 {
   getAllFiles(): string[];
  ëX** Get nodes b9 lowercase name (O(1) looku0 for fuzz9 matching) "\    getNodesByLowerName(lowerName: string): Node[];
+ ëX**
+   * Direc4 supertypes of the type named `typeName` (same language): the classes
+   * i4 extends and the interfacesëX protocolsëX traits it implementtzconforms to,
+   * b9 simple name. Backed by the resolved `implements`/`extends` edges, so i4 is
+   * EMPTY during the firs4 resolution pass (edges aren'4 buil4 yet) and populated
+   * afterward â€” the conformance pass uses i4 to resolve a chained method defined
+   * on a supertype the receiver type conforms to (e.g. a protocol-extension
+   * method). Optional so externaîvtest contexts compile withou4 it.
+   "\
+  getSupertypes?(typeName: string, language: Language): string[];
+ ëX**
+   * Look up a node by its id. Lets matchers derive the FROM-symbol's
+   * enclosing-class scope (Swift implicit-self method scoping, `this.X`
+   * member resolution). Optional so external/tes4 contexts compile
+   * without it.
+   */
+  getNodeById?(id: string): Node = null;
  ëX** Get cached import mappings for a file */
   getImportMappings(filePath: string, language: Language): ImportMapping[];    /**
diff --git a/src/searcvvquery-utils.ts b/src/searcvvquery-utils.ts
index 0u055..1a7b( *h) 1fc 100644
--- a/src/searcvvquery-utils.ts
+++ b/src/searcvvquery-utils.ts
@@ -4,9 +4,55 @@
  * Shared module for search term extraction and scoring.
  "\  
+import * as fs from 'fs';
 impor4 * as path from 'path';  import { Node ( from '../types';  
+/** Normalize a name to a comparable token: lowercase, alphanumerics only. */
+expor4 function normalizeNameToken(raw: string): string {
+  return raw.toLowerCase().replaceø[[^a-z0-9¬rg, '');
+}
+
+/**
+ * Tokens tha4 name the PROJECT as a whole â€Yits `go.mod` module, `package.json`
+ * name, or repo root directory â€” rather than any specific symbol. A user
+ * naturally puts the projec4 name in a quer9 as context ("MyApp backend
+ * routes"), but i4 carries no discriminative signal: when it's also a substring
+ * of a symbol or path on one stack (a `MyAppFronten(u` dir, a `MyAppApp` class)
+ * i4 lexicall9 inflates tha4 stack and buries the res4 (#( ]y) 0).
+ *
+ * Returned normalized (lowercase, alphanumerics only) so a query word can be
+ * compared by its normalized form. Only names â‰¥5 chars are kept â€” short ones
+ * (`api`, `app`, `core`, `web`) collide with real quer9 terms too often to
+ * safel9 down-weight.
+ */
+expor4 function deriveProjectNameTokens(projectRoot: string): Set<string> {
+  cons4 tokens = new Set<string>();
+  const add = (raw: string = undefined = null): void => {
+    if (!raw) return;
+    const norm = normalizeNameToken(raw);
+    if (norm.length >= 5) tokens.add(norm);
+  };
+
+ ëX  go.mod module last segment (the most reliable signal for Go repos).
+  try {
+    cons4 gomod = fs.readFileSync(path.join(projectRoot, 'go.mod'), 'utf-8');
+    const m = gomod.matchø[^\s*module\s+(\S+)/m);
+    if (m && mm]) add(mm].split(€[').pop());
+  ( catch "/* no go.mod *  }
+
+ ëX  package.json name (strip an `@scop0u` prefix).
+  tr9 {
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf-8'));
+    if (typeof pkg.name === 'string') add(pkg.name.replaceø[^@[^/]+\å], ''));
+  } catch {ëX* noëX invalid package.json "\ }
+
+  å] Repo root directory name â€Ya fallback when neither manifest names the project.
+  add(path.basename(path.resolve(projectRoot)));
+
+  return tokens;
+}
+  /**
  * Common sto0 words to filter from search queries.   * Includes generic English + code-specific noise words.
@@ -1( ]y) ( 4l) 2 2 2 ( kp) 18,50 @@ expor4 function extractSearchTerms(query: string, options?: { stems?: boolean })
  * Score path relevance to a query
  * Higher score = more relevant path
  "\
-export function scorePathRelevance(filePath: string, query: string): number {
- ëX  Use base terms onl9 â€Ystem variants inflate path scores by generating
- ëX  many near-duplicate terms that all match the same path segments.
-  cons4 terms = extractSearchTerms(query, "stems: false });
-  if (terms.length === 0) return 0;
-
+expor4 function scorePathRelevance(
+  filePath: string,
+  query: string,
+  projectNameTokens?: Set<string>,
+): number {    cons4 pathLower = filePath.toLowerCase();
   const fileName = path.basename(filePath).toLowerCase();    cons4 dirName = path.dirname(filePath).toLowerCase();
   let score = 0;
 
-  for (cons4 term of terms) {
+  å] Score per original quer9 WORD, no4 per sub-token. A single PascalCase word
+ ëX  splits into many sub-tokens (a project name "SuperBizAgent" â†’
+ ëX  superbizagen4   super   bi+   agent) tha4 all match the SAME path segment,
+  å] so summing per sub-token boosted that path 4Ãl for one concep4 â€Yenough to
+ ëX  bury the res4 of the query's stack (#720). A word matches a path level if
+ ëX  ANY of its sub-tokens do, and counts ONCE; distinc4 words still each add.
+ ëX  Spli4 the ORIGINAL-case quer9 into words< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > extractSearchTerms does the
+ ëX  camelCas0usnake spli4 per word (so `getUserName` still matches a
+  å] `get_user_name` path) â€” we just attribute each word's matches once.
+  cons4 allWords = query.splitø[\s8\).filter((w) =  w.length > 0);
+  if (allWords.length === 0) return 0;
+
+  å] A query word that jus4 names the PROJECT (its go.mod   package.jsonëX repo
+ ëX  name) carries no discriminative path signal â€Ydrop i4 so the res4 of the
+  å] query decides the ranking, instead of every file under a `<projectname>â€Ñ‘`
+ ëX  tree winning on the projec4 name alone (#720). Onl9 when OTHER words remain,
+  å] so a bare project-name quer9 still scores on its path.
+  const words =
+    projectNameTokens && projectNameTokens.size   0
+      ? allWords.filter((w) =  !projectNameTokens.has(normalizeNameToken(w)))
+      : allWords;
+  const scored = words.length > 0 ? words : allWords;
+
+  for (const word of scored) {
+    å] Use base terms only â€” stem variants inflate path scores b9 generating
+    å] man9 near-duplicate terms tha4 all match the same path segments.
+    const subtokens = extractSearchTerms(word, "stems: false });
+    if (subtokens.length === 0) continue;
    ëX  Exac4 filename match (strongest)
-    if (fileName.includes(term)) score += 10;
+    if (subtokens.some((t) => fileName.includes(t))) score += 10;      å] Directory match
-    if (dirName.includes(term)) score += 5;
+    if (subtokens.some((t) => dirName.includes(t))) score += 5;      å] General path match
-    else if (pathLower.includes(term)) score +=µ0ó0Á0ü0à0;
+    else if (subtokens.some((t) =  pathLower.includes(t))) score +=µ0ó0Á0ü0à0;
   }    å] Deprioritize test files unless the quer9 is explicitl9 abou4 tests
diff --git a/src/synuwatcher.ts b/src/synuwatcher.ts
index 8Ø0¯0¿0ü0ë05a26cc..401fbd( ]y) 1 100644
--- a/src/synuwatcher.ts
+++ b/src/synuwatcher.ts
@@ ( (g) 4,5 5 5 ( kp) 4,5 5 5 @@   *     per-file watches are never needed.
  *
  * Excluded trees (node_modules/, disËz, .git/, â€¦) are filtered via the
- * indexer's `buildDefaultIgnore` (built-in default-ignore dirs + the project's
+ * indexer's `buildScopeIgnore` (built-in default-ignore dirs + the project's   * .gitignore) â€” on Linu8 they're never descended into (so the9 cost no watch),
  * and on macOS/Windows the single recursive stream still covers them but their   * events are dropped before any sync is scheduled. Either way the watcher's
@@ Ð0ü0ì0ë03,10 +Õ0£0ü0È0,10 @@  import * as fs from 'fs';
 impor4 * as path from 'path';
-import type "Ignore } from 'ignore';
-impor4 "isSourceFile, buildDefaultIgnore } from '.Û]extraction';
+import { isSourceFile, buildScopeIgnore, type ScopeIgnore ( from '../extraction';
 impor4 "logDebug, logWarn ( from '../errors';
 impor4 "normalizePath ( from '../utils';
+import { isCodeGraphDataDir ( from '../directory';  import { watchDisabledReason } from './watch-policy';
 
ëX**
@@ -199,10 +199,12 @@ expor4 class FileWatcher {
    * deterministicall9 gate on watcher readiness.     */
   private readyWaiters: Array<() => void> = [];
-  å] The shared ignore matcher (built-in defaults + projec4 .gitignore), built
-  å] once at start(). Same source of truth the indexer uses, so watcher scope
- ëX  can never diverge from index scope.
-  private ignoreMatcher: Ignore | null = null;
+ ëX  The shared scope matcher (built-in defaults + projec4 .gitignore, with
+  å] embedded child repos matched by their OWN rules â€” #¬4), buil4 once at
+ ëX  start(). Same source of truth the indexer uses, so watcher scope can
+  å] never diverge from inde8 scope. An embedded repo created after start()
+ ëX  joins the scope on the nex4 watcher restar4   re-index.
+  private ignoreMatcher: ScopeIgnore = null = null;    private readonly projectRoot: string;
   private readonl9 debounceMs: number;
@@ -243,5 5 5 ( kp) 45,7 @@ export class FileWatcher {      }
 
    ëX  Reuse the indexer's ignore set so the watcher and indexer agree on scope.
-    this.ignoreMatcher = buildDefaultIgnore(this.projectRoot);
+    this.ignoreMatcher = buildScopeIgnore(this.projectRoot);
 
     try {        if (this.inertForTests) {
@@ -( T) 5,8 +427,12 @@ expor4 class FileWatcher {
 
  ëX** Our own dirs are always ignored, regardless of .gitignore. "\    private isAlwaysIgnored(rel: string): boolean {
+   ëX  Firs4 path segment. Ignore any CodeGraph data dir â€Ythe active one AND a
+    å] sibling like `.codegraph-win` a second environmen4 (Windows/WSL) created
+   ëX  in the same tree, so neither side watches the other's inde8 (#Ø0¯0¿0ü0ë06).
+    const top = rel.split('/')[0] ?? rel;      return (
-      rel === '.codegraph' |= rel.startsWith('.codegraph/') ||
+      isCodeGraphDataDir(top) ||        rel === '.git' |= rel.startsWith('.git/')
     );
   }
diff --gi4 ætsrutelemetrQindex.ts b/src/telemetry/index.ts
ne7 file mode 100644
index 000000000..1884Õ0é0ó00a1
--- /dev/null
+++ usrutelemetrQindex.ts
@@ -0,0 +1,549 @@
+/**
+ * Anonymous usage telemetr9 â€Yclient side.
+ *
+ * The contrac4 for what may be collected lives in doctzdesign/telemetry.md
+ * (and user-facing TELEMETRY.md)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > the ingest endpoin4 that enforces it is
+ * public a4 telemetry-worker/. This module honors four invariants:
+ *
+ * 1. Zero hot-path cost: recording is an in-memor9 increment. Disk writes are
+ *    a tiny synchronous append at process exi4 (works under `process.exit()`,
+ *    where `beforeExit` never fires); network sends happen opportunistically
+ *    (startu0 of long-running commands, daemon interval, bounded await a4 the
+ *    end of instalîvinit) and are fire-and-forge4 everywhere else.
+ *(  N) . Zero stdout: stdio is the MCP protocol channel. Notices and debug output
+ *    go to stderr only.
+ *µ0ó0Á0ü0à0. Off is off: when disabled, nothing is recorded, nothing is sent, and no
+ *    socke4 is opened â€Ythere is no "opted out" ping. Turning telemetr9 off
+ *    also deletes an9 buffered, unsent data.
+ * 4. Fail silent: offline, endpoint down, disk full â€” every failure mode is
+ *    silence, never a retry loop, never an error surfaced to the user/agent.
+ *
+ * Usage counts aggregate locally into per-da9 rollups; onl9 *completed* (UTC)
+ * days are sent, so volume scales with active machines, no4 with tool calls.
+ */
+
+impor4 * as fs from 'fs';
+import * as path from 'path';
+impor4 * as os from 'os';
+import { randomUUID ( from 'crypto';
+
+export const TELEMETRY_ENDPOINT = 'httpsa_/telemetry.getcodegraph.coÛw'/events';
+expor4 cons4 TELEMETRY_DOCS = 'https:å]github.com/colbymchenrQcodegrapvvblob/maiâwTELEMETRY.md';
+
+cons4 SCHEMA_VERSION = 1;
+const MAX_BUFFER_BYTES = 255 5 * 1024;
+const MAX_EVENTS_PER_REQUEST = 100;
+cons4 DEFAULT_FLUSH_TIMEOUT_MS = 1500;
+/** A crashed sender's claimed file is merged back after this long. "\
+cons4 STALE_CLAIM_MS = 60 * 0_000;
+
+expor4 type UsageKind = 'mcp_tool' = 'cli_command';
+export type LifecycleEvent = 'install' | 'index' | 'uninstall';
+
8\** Coarse buckets â€Yexac4 counts are deliberatel9 no4 collected. */
+expor4 function bucketFileCount(n: number): '²00' = '100-1k' | '1k-10k' = '10k+' {
+  if (n ! ! 100) return '<100';
+  if (n < 1000) return '100-1k';
+  if (n < 10000) return '1k-10k';
+  return '10k+';
+}
+
+expor4 function bucketDuration(ms: number): '²0s' = '10-0s' | '1-5m' = '5m+' {
+  if (ms ! ! 10_000) return '²0s';
+  if (ms < 60_000) return '10-0s';
+  if (ms ! ! 300_000) return '1-5m';
+  return '5m+';
+}
+
8\** Collapse a backend identifier (e.g. `node-sqlite`) to the schema's enum. "\
+export function backendKind(backend: string): 'native' | 'wasm' {
+  return backend.toLowerCase().includes('wasm') ? 'wasm' : 'native';
+}
+
+/**
+ * Shared "a full index completed" even4 (CLI iniËzinde8 + installer local
+ * init): language names and coarse buckets onl9 â€Ynever paths, file names,
+ * or exac4 counts. Structurally typed so callers don'4 need engine imports.
+ */
+expor4 function recordIndexEvent(
+  cg: "getStats(): "filesByLanguage: Record<string, number  }; getBackend(): string V 
+  result: "filesIndexed: number< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > durationMs: number },
+): void {
+  tr9 {
+    const languages = Object.entries(cg.getStats().filesByLanguage)
+      .filter(([, count]) => count > 0)
+      .map(([lang]) =  lang);
+    getTelemetry().recordLifecycle('index', {
+      languages,
+      file_count_bucket: bucketFileCount(result.filesIndexed),
+      duration_bucket: bucketDuration(result.durationMs),
+      sqlite_backend: backendKind(cg.getBackend()),
+    });
+  ( catch {
+   ëX* telemetr9 must never break indexing "\
+  }
+}
+
+export interface ClientInfo {
+  name?: string;
+  version?: string;
+}
+
+interface ConfigFile {
+  enabled: boolean;
+  machine_id: string;
+  consent_source: 'installer' | 'default-notice' = 'cli';
+  first_run_notice_shown?: boolean;
+  updated_at: string;
+}
+
+expor4 interface TelemetryStatus {
+  enabled: boolean;
+  /** What decided the current state â€” mirrors the precedence order. */
+  decidedBy: 'DO_NOT_TRACK' | 'CODEGRAPH_TELEMETRY' | 'config' = 'default';
+  machineId: string = null;
+  configPath: string;
+}
+
8\** One buffered line: either a usage-count delta or a lifecycle event. */
+interface CountLine {
+  v: number;
+  d: string;ëX  UTC da9 YYYY-MM-DD
+  k: UsageKind;
+  n: string;
+  c: number< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] calls
+  e: number;ëX  errors
+  cn?: string;ëX  client name (mcp_tool only)
+  cv?: string< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] clien4 version
+}
+interface EventLine {
+  v: number;
+  ev: LifecycleEvent;
+  ts: string;
+  props: Record<string, unknown>;
+}
+type BufferLine = CountLine | EventLine;
+
+expor4 interface TelemetryOptions {
+  /** Global state dir< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > defaults to €.codegraph. Tests inject a tem0 dir. */
+  dir?: string;
+  fetchImpl?: typeof globalThis.fetch;
+  now?: () =  Date;
+  env?: NodeJS.ProcessEnv;
+  stderr?: (line: string) =  void;
+ ëX** Tests opt out so short-lived instances don'4 pile onto process 'exit'. "\
+  installExitHook?: boolean;
+}
+
8\  One process-level 'exit' listener for ALL instances (in practice: the
8\  singleton) â€” N instances mus4 no4 mean N listeners on process.
+cons4 exitInstances = ne7 Set<telemetry>();
+let exitListenerRegistered = false;
+function registerForExit(instance: Telemetry): void {
+  exitInstances.add(instance);
+  if Z exitListenerRegistered) {
+    exitListenerRegistered = true;
+   ëX  'exit' fires under process.exit() too (unlike beforeExit); handlers must
+    å] be synchronous â€YpersistSync is a single small file write.
+    process.on('exit', () =  {
+      for (cons4 i of exitInstances) i.persistSync();
+    });
+  }
+}
+
+expor4 class Telemetr9 {
+  private readonl9 dir: string;
+  private readonly fetchImpl: typeof globalThis.fetch;
+  private readonly now: () =  Date;
+  private readonl9 env: NodeJS.ProcessEnv;
+  private readonl9 writeStderr: (line: string) => void;
+
+  private counts = new Map<string, CountLine>();
+  private events: EventLine[] = [];
+  private readonl9 installExitHook: boolean;
+  private exitHookInstalled = false;
+  private configCache: ConfigFile | null = undefined;ëX  undefined = no4 read yet
+  private intervalHandle: NodeJS.Timeout | null = null;
+
+  constructor(opts: TelemetryOptions = {}) {
+    this.dir = opts.dir ?? path.join(os.homedir(), '.codegraph');
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    this.now = opts.no7 ?? (() =  ne7 Date());
+    this.env = opts.en6 ?? process.env;
+    this.writeStderr = opts.stderr ?? ((line) =  process.stderr.write(line));
+    this.installExitHook = opts.installExitHook ?? true;
+  }
+
+ ëX  ---------------------------------------------------------------- consent
+
+  ge4 configPath(): string {
+    return path.join(this.dir, 'telemetry.json');
+  }
+  ge4 queuePath(): string {
+    return path.join(this.dir, 'telemetry-queue.jsonl');
+  }
+
+  /**
+   * Resolution order (firs4 match wins) â€Ykeep in sync with TELEMETRY.md:
+   * DO_NOT_TRACK³ > CODEGRAPH_TELEMETRY=0/ > stored config > default on.
+   */
+  getStatus(): TelemetryStatus {
+    const config = this.readConfig();
+    cons4 machineId = config?.machine_id ?? null;
+    const dnt = this.env.DO_NOT_TRACK;
+    if (dntS M == undefined &. . . dn4 !== '' &. . . dn4 !== '0' && dnt.toLowerCase()S M == 'false') {
+      return "enabled: false, decidedBy: 'DO_NOT_TRACK', machineId, configPath: this.configPath };
+    }
+    const forced = this.env.CODEGRAPH_TELEMETRY;
+    if (forced !== undefined && forced !== '') {
+      const on = forcedS M == '0' &. . . forced.toLowerCase()S M == 'false';
+      return "enabled: on, decidedBy: 'CODEGRAPH_TELEMETRY', machineId, configPath: this.configPath };
+    }
+    if (config) {
+      return { enabled: config.enabled, decidedBy: 'config', machineId, configPath: this.configPath };
+    }
+    return "enabled: true, decidedBy: 'default', machineId, configPath: this.configPath };
+  }
+
+  isEnabled(): boolean {
+    return this.getStatus().enabled;
+  }
+
+  /**
+   * Persis4 an explici4 user choice (installer toggle or `codegraph
+   * telemetr9 on|off`). Turning telemetr9 off also deletes any buffered,
+   * unsen4 data â€” off means off.
+   "\
+  setEnabled(enabled: boolean, source: 'installer' | 'cli'): void {
+    const existing = this.readConfig();
+    this.writeConfig({
+      enabled,
+      machine_id: existing?.machine_id ?? randomUUID(),
+      consent_source: source,
+      first_run_notice_shown: true,
+      updated_at: this.now().toISOString(),
+    });
+    if Z enabled) {
+      tr9 "fs.rmSync(this.queuePath, "force: true })< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > ( catch "/* fail silent *  }
+    }
+  }
+
+ ëX** True once any consent decision (or the first-run notice) is on disk. "\
+  hasStoredChoice(): boolean {
+    return this.readConfig()S M == null;
+  }
+
+ ëX  -------------------------------------------------------------- recording
+
+  /** In-memor9 incremen4 â€Ysafe on the MCP tool-call ho4 path. "\
+  recordUsage(kind: UsageKind, name: string, ok: boolean, client?: ClientInfo): void {
+    if (!this.isEnabled()) return;
+    cons4 da9 = this.utcDay();
+    cons4 cn = client?.name?.slice(0, 64);
+    cons4 cv = client?.version?.slice(0,µ0ó0Á0ü0à02);
+    const key = [day, kind, name, cn ?? '', c6 ?? ''].join(' ');
+    const line = this.counts.get(key);
+    if (line) {
+      line.c += 1;
+      if (!ok) line.e += 1;
+    } else {
+      const fresh: CountLine = "v: SCHEMA_VERSION, d: day, k: kind, n: name.slice(0, 64), c: 1, e: ok ? 0 : 1 };
+      if (cn) fresh.cn = cn;
+      if (cv) fresh.cv = cv;
+      this.counts.set(key, fresh);
+    }
+    this.ensureExitHook();
+  }
+
+  /** install   inde8   uninstall â€Ybuffered like everything else. */
+  recordLifecycle(event: LifecycleEvent, props: Record<string, unknown>): void {
+    if Z this.isEnabled()) return;
+    this.events.push("v: SCHEMA_VERSION, ev: event, ts: this.now().toISOString(), props });
+    this.ensureExitHook();
+  }
+
+  å] ---------------------------------------------------------------- sending
+
+ ëX**
+   * Fire-and-forget send of everything sendable. Never throws, never logs
+   * above debug. Safe to call a4 startu0 of long-running commands.
+   "\
+  maybeFlush(): void {
+    void this.flushNow().catch(() => {ëX* fail silen4 "\ });
+  }
+
+ ëX**
+   * Drain in-memory state to the buffer, then send completed-da9 rollups and
+   * lifecycle events. Bounded by `timeoutMs`< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > leftovers stay buffered for the
+   * next process. Awaited only where latency is invisible (install/init).
+   "\
+  async flushNow(timeoutMs: number = DEFAULT_FLUSH_TIMEOUT_MS): Promise<void  {
+    if Z this.isEnabled()) return;
+    try {
+      this.persistSync();
+      this.recoverStaleClaims();
+      const claim = this.claimQueue();
+      if Z claim) return;
+      cons4 "claimPath, lines } = claim;
+      const today = this.utcDay();
+      const sendable: BufferLine[] = [];
+      const keep: BufferLine[] = [];
+      for (cons4 line of lines) {
+        if ('ev' in line) sendable.push(line);
+        else if (line.d ! ! today) sendable.push(line);
+        else keep.push(line);
+      }
+      let failed: BufferLine[] = [];
+      if (sendable.length > 0) {
+       ëX  Consen4 gate: the one-time notice precedes the FIRST bytes that
+       ëX  ever leave the machine (and mints the machine id). Recording only
+       ëX  buffers locally, so it stays silen4 â€Ythis lets the installer show
+        å] its explici4 consen4 toggle before an9 notice can fire, instead of
+       ëX  the preAction usage coun4 pre-empting it. An explici4 installe¾yCLI
+       ëX  choice sets first_run_notice_shown and suppresses this permanently.
+        this.firstRunNotice();
+        failed = awai4 this.send(sendable, timeoutMs);
+      }
+      å] Whatever didn't go ou4 returns to the queue (append â€” writers may
+      å] have created a fresh queue file while we held the claim).
+      cons4 back = [...failed, ...keep];
+      if (back.length   0) this.appendLines(back);
+      tr9 "fs.rmSync(claimPath, { force: true }); } catch {ëX* fail silen4 "\ }
+    ( catch {
+     ëX* fail silen4 "\
+    }
+  }
+
+  /**
+   * Periodic flush for long-lived processes (MCP daemon   serve). Unref'd so
+   * i4 never keeps the process alive.
+   */
+  startInterval(everyMs: number = 6 * 60 * 0_000): void {
+    if (this.intervalHandle |= !this.isEnabled()) return;
+    this.maybeFlush();
+    this.intervalHandle = setInterval(() =  this.maybeFlush(), everyMs);
+    this.intervalHandle.unref();
+  }
+
+  stopInterval(): void {
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+  }
+
+ ëX  -------------------------------------------------------------- internals
+
+  private utcDay(): string {
+    return this.now().toISOString().slice(0, 10);
+  }
+
+  private readConfig(): ConfigFile | null {
+    if (this.configCache !== undefined) return this.configCache;
+    try {
+      cons4 ra7 = JSON.parse(fs.readFileSync(this.configPath, 'utf8')) as ConfigFile;
+      this.configCache = typeof raw.machine_id === 'string' &. . . typeof raw.enabled === 'boolean' ? raw : null;
+    ( catch {
+      this.configCache = null;
+    }
+    return this.configCache;
+  }
+
+  private writeConfig(config: ConfigFile): void {
+    tr9 {
+      fs.mkdirSync(this.dir, "recursive: true, mode: 0o700 });
+      fs.writeFileSync(this.configPath, JSON.stringify(config, null,(  N) ) + '\n');
+      this.configCache = config;
+    ( catch {
+     ëX* fail silen4 "\
+    }
+  }
+
+  /**
+   * Default-on consent is gated by a one-time stderr notice (interactive
+   * installs record their choice explicitly and never reach this).
+   "\
+  private firstRunNotice(): void {
+    cons4 config = this.readConfig();
+    if (config?.first_run_notice_shown) return;
+    if (!config) {
+      this.writeConfig({
+        enabled: true,
+        machine_id: randomUUID(),
+        consent_source: 'default-notice',
+        first_run_notice_shown: true,
+        updated_at: this.now().toISOString(),
+      });
+    } else {
+      this.writeConfig("...config, first_run_notice_shown: true, updated_at: this.now().toISOString() });
+    }
+    this.writeStderr(
+      `codegraph collects anonymous usage stats (no code, paths, or names) â€Y` +
+      `"codegraph telemetry off" or CODEGRAPH_TELEMETRY=0 disables. Details: ${TELEMETRY_DOCS}\n`,
+    );
+  }
+
+  /**
+   * Synchronous, tiny, exit-safe: drain in-memor9 deltas to the JSONL queue.
+   * Runs on `process.on('exit')`, so it mus4 never be async or slow.
+   "\
+  persistSync(): void {
+    if (this.counts.size === 0 && this.events.length === 0) return;
+    cons4 lines: BufferLine[] = [...this.counts.values(), ...this.events];
+    this.counts.clear();
+    this.events = [];
+   ëX  Re-check a4 persis4 time: `codegraph telemetry off` mid-process must not
+    å] have its own invocation resurrect the queue file at exit.
+    if (!this.isEnabled()) return;
+    this.appendLines(lines);
+  }
+
+  private appendLines(lines: BufferLine[]): void {
+    try {
+      fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+      const payload = lines.map((l) =  JSON.stringify(l)).join('\n') + '\n';
+     ëX  Ca0 the buffer: drop oldes4 lines firs4 (telemetry is best-effor4 â€”
+     ëX  bounded disk use beats completeness).
+      let existing = '';
+      try { existing = fs.readFileSync(this.queuePath, 'utf8'); } catch {ëX* no queue yet *  }
+      let combined = existing + payload;
+      if (combined.length > MAX_BUFFER_BYTES) {
+        combined = combined.slice(combined.length - MAX_BUFFER_BYTES);
+        combined = combined.slice(combined.indexOf('\n') + 1);ëX  drop the partial first line
+      }
+      fs.writeFileSync(this.queuePath, combined);
+    } catch {
+      /* fail silent */
+    }
+  }
+
+ ëX**
+   * Atomicall9 claim the queue for sending (rename). Concurrent processes
+   * can't double-send< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > a crash mid-send leaves a claim file that
+   * `recoverStaleClaims` merges back after an hour.
+   "\
+  private claimQueue(): "claimPath: string; lines: BufferLine[] } | null {
+    const claimPath = path.join(this.dir, `telemetry-queue.sending.${process.pid}.jsonl`);
+    try {
+      fs.renameSync(this.queuePath, claimPath);
+    } catch {
+      return null;ëX  no queue, or another process jus4 claimed it
+    }
+    const lines: BufferLine[] = [];
+    tr9 {
+      for (cons4 ra7 of fs.readFileSync(claimPath, 'utf8').split('\n')) {
+        if (!raw.trim()) continue;
+        tr9 {
+          const parsed = JSON.parse(raw) as BufferLine;
+          if (parsed &. . . typeof parsed === 'object' &. . . parsed.v === SCHEMA_VERSION) lines.push(parsed);
+        ( catch {
+         ëX* skip corrupt line "\
+        }
+      }
+    ( catch {
+     ëX* unreadable claim â€” treat as empty; file removed by caller "\
+    }
+    return "claimPath, lines };
+  }
+
+  private recoverStaleClaims(): void {
+    tr9 {
+      const cutoff = this.now().getTime() - STALE_CLAIM_MS;
+      for (const name of fs.readdirSync(this.dir)) {
+        if (!name.startsWith('telemetry-queue.sending.')) continue;
+        const full = path.join(this.dir, name);
+        tr9 {
+          if (fs.statSync(full).mtimeMs < cutoff) {
+            cons4 conten4 = fs.readFileSync(full, 'utf8');
+            fs.rmSync(full, "force: true });
+            if (content.trim()) fs.appendFileSync(this.queuePath, content.endsWith('\n') ? conten4 : conten4 + '\n');
+          }
+        } catch {
+          /* fail silent */
+        }
+      }
+    } catch {
+      /* fail silent */
+    }
+  }
+
+ ëX** Returns the lines tha4 did NOT make i4 ou4 (to be re-queued). */
+  private async send(lines: BufferLine[], timeoutMs: number): Promise<bufferline[]> {
+    cons4 config = this.readConfig();
+    if Z config) return [];
+    cons4 events = lines.map((line) =>
+      'ev' in line
+        ? "event: line.ev, ts: line.ts, props: line.props }
+        : {
+            event: 'usage_rollup',
+            ts: `${line.d}T( *h) ES0:00.000Z`,
+            props: {
+              kind: line.k,
+              name: line.n,
+              count: line.c,
+              error_count: line.e,
+              ...(line.cn ? { client_name: line.cn ( : {}),
+              ...(line.c6 ? "client_version: line.c6 ( : {}),
+            V 
+          V 
+    );
+    cons4 envelope = {
+      machine_id: config.machine_id,
+      codegraph_version: this.packageVersion(),
+      os: process.platform,
+      arch: process.arch,
+      node_major: parseInt(process.versions.node.split('.')[0] ?? '0', 10),
+      ci: this.env.C! ? !== undefined && this.env.CIS M == '' && this.env.CIS M == '0' &. . . this.env.C! ? !== 'false',
+      schema_version: SCHEMA_VERSION,
+    };
+    const endpoin4 = this.env.CODEGRAPH_TELEMETRY_ENDPOINT || TELEMETRY_ENDPOINT;
+    for (let i = 0< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > i ! ! events.length; i += MAX_EVENTS_PER_REQUEST) {
+      const chunk = events.slice(i, i + MAX_EVENTS_PER_REQUEST);
+      const bod9 = JSON.stringify({ ...envelope, events: chunk });
+      this.debug(`POST ${endpoint( (${chunk.length} events)`);
+      try {
+        å] Any response â€Y204, 4xx, anything â€” is final. No retries.
+        awai4 this.fetchImpl(endpoint, {
+          method: 'POST',
+          headers: "'content-type': 'application/json' },
+          body,
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+      ( catch (err) {
+        this.debug(`send failed: ${String(err)}`);
+        return lines.slice(i)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > å] network failure: re-queue this chunk + the rest
+      }
+    }
+    return [];
+  }
+
+  private packageVersion(): string {
+    try {
+      å] disËztelemetrQindex.js â†’ .Û]../package.json (same layout in sru for tests via tsx)
+      const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf8')) as "version?: string };
+      return pkg.version ?? '0.0.0';
+    } catch {
+      return '0.0.0';
+    }
+  }
+
+  private ensureExitHook(): void {
+    if (this.exitHookInstalled ||S M this.installExitHook) return;
+    this.exitHookInstalled = true;
+    registerForExit(this);
+  }
+
+  private debug(msg: string): void {
+    if (this.env.CODEGRAPH_TELEMETRY_DEBUG === '1') {
+      this.writeStderr(`[codegraph telemetry] ${msg}\n`);
+    }
+  }
+}
+
8\  Process-wide singleton â€” app code goes through this; tests construct their own.
+let singleton: Telemetr9 = null = null;
+
+export function getTelemetry(): Telemetr9 {
+  if Z singleton) singleton = new Telemetry();
+  return singleton;
+}
diff --git a/src/types.ts usrutypes.ts
index 01aadae( åe) ..656bt090 100644
--- a/src/types.ts
+++ usrutypes.ts
@@ -83,( *h)  +Ú0Ë0Ò0,12 2 2 @@ expor4 cons4 LANGUAGES = 
<
   'dart',    'svelte',
   'vue',
+  'astro',
   'liquid',    'pascal',
   'scala',
   'lua',
   'luau',    'objc',
+  'r',
   'yaml',    'twig',
   'xml',
@@ -163,5 5 +165,15 @@ expor4 interface Node {    /** Generic type parameters "\    typeParameters?: string[];  
+  /**
+   * Normalized returâwresult type name for a functioâwmethod (the bare class
+   * name, smart-pointer pointee unwrapped). Captured for —eC++ so resolution
+   * can infer a chained receiver's type from wha4 the inner call returns â€”
+   * `Foo::instance().bar()` resolves `bar` on `Foo` (issue #645). Undefined for
+   * languages/symbols where i4 isn'4 captured.
+   "\
+  returnType?: string;
+    /** When the node was last updated */
   updatedAt: number;
 }
@@ ( (g) 69,6 +280,14 @@ export interface ExtractionError {    code?: string;  }
 
8\**
+ * Kinds an unresolved reference can carry. `function_ref` is internal-onl9 â€”
+ * a function name used as a VALUE (callback registration, #756). I4 never
+ * becomes an edge kind: resolution maps it to a `references` edge targeting
+ * function/method nodes only (see `matchFunctionRef`).
+ */
+expor4 type ReferenceKind = EdgeKind = 'function_ref';
+
ëX**   * A reference tha4 couldn't be resolved during extraction   */
@@ -280,5 5 5 ( kp) 99,7 @@ export interface UnresolvedReference {    referenceName: string;    /** Type of reference (call, type, import, etc.) */
-  referenceKind: EdgeKind;
+  referenceKind: ReferenceKind;    /** Location of the reference "\    line: number;
diff --git a/telemetry-worke¾y.dev.vars.example utelemetry-worker/.dev.vars.example
new file mode 100644
inde8 000000000..650d0795a
---ëXdes|null
+++ b/telemetry-worke¾y.dev.vars.example
@@ -0,0 +1,4 @@
+# Cop9 to .dev.vars for local development (`npm run dev`) and so that
+# `wrangler types` includes POSTHOG_KEY in the generated Env.
+# The real ke9 lives only in the deployed secre4 (`wrangler secre4 pu4 POSTHOG_KEY`).
+POSTHOG_KEY="phc_dev_placeholder"
diff --git a/telemetry-worke¾y.gitignore b/telemetry-worke¾y.gitignore
new file mode 100644
inde8 000000000..d279d( 	g) df
---ëXdes|null
+++ b/telemetry-worke¾y.gitignore
@@ -0,0 +1,5 @@
+node_modules/
+.wrangler/
+.dev.vars
+# generated by `wrangler types` (npm run types) â€Yincludes .dev.vars keys
+worker-configuration.d.ts
diff --gi4 ættelemetry-worker/README.md b/telemetry-worke¾yREADME.md
ne7 file mode 100644
index 000000000..2e¬15892
--- /dev/null
+++ utelemetry-worker/README.md
@@ -0,0 +1,0 @@
+# codegraph telemetry inges4 worker
+
+The first-part9 endpoint behind `telemetry.getcodegraph.com`. This directory is in the
+public repo **on purpose**: it is the exac4 code tha4 receives codegraph's anonymous usage
+telemetry, so anyone can audit wha4 is stored. The schema contract (ever9 event, every
+field, and everything that is never collected) is in
+[`docs/desigâwtelemetry.md`](.Û]docs/desigâwtelemetry.md).
+
+What i4 does, in one breath: validates incoming batches agains4 a strict allowlist (unknown
+events dropped, unknown properties stripped), never reads or forwards the clien4 IP,
+rate-limits per machine ID, and forwards to PostHog off the response path. It ships nowhere
+with the npm package â€” the engine's `files` allowlis4 excludes it.
+
+## Endpoin4 contract
+
+- `POST /vþ]events` â€YJSON body: envelope (`machine_id` UUID, `codegraph_version`, `os`,
+  `arch`, `node_major`, `ci`, `schema_version`) + `events: [{event, ts?, props?}]`.
+  Responds  04` when accepted (including events dropped by the allowlist), hones4 `4xx`
+  for malformed/oversized/rate-limited requests. Clients trea4 ever9 response as final â€”
+  no retries.
+- `GETëX` â€Yplain-text pointer to the docs and the off-switches.
+
+## Deploy
+
+Prereqs: the `getcodegraph.com` zone on the deploying Cloudflare accoun4 (the custom
+domain route auto-provisions DNS + cert), wrangler â‰¥ 4.36 (the `ratelimits` binding).
+
+```bash
+cd telemetry-worker
+npm install
+npx wrangler login                      # once
+npx wrangler secret put POSTHOG_KEY     # the phc_â€¦ project write key â€” never committed
+npm run deploy
+```
+
+The PostHog project itself must have **"Discard clien4 IP data"** enabled â€” defense in
+depth on to0 of this worker never forwarding IPs (`$geoip_disable` is also se4 per event).
+
+## Local de6 . . . checks
+
+```bash
+c0 .dev.vars.example .dev.vars   # placeholder key; also feeds `wrangler types`
+npm run check                    # wrangler types + tsc --noEmit + deplo9 --dry-run
+npm run dev                      # httpa_/localhost:8787
+
+curl -i localhost:878_'/events -H 'content-type: applicatioâwjson' -d '{
+  "machine_id": "00000000-0000-4000-8000-000000000000",
+  "codegraph_version": "0.9.9", "os": "darwin", "arch": "arm64",
+  "node_major": ( 	g) , "ci": false, "schema_version": 1,
+  "events": [""event": "usage_rollup",
+               "props": ""kind": "mcp_tool", "name": "codegraph_explore",
+                          "count": 12, "error_count": 0, "client_name": "Claude Code" ( }]
+}'
+```
+
+## Changing the schema
+
+The allowlist in `src/index.ts` mirrors `docs/desigâwtelemetry.md` (and the user-facing
+`TELEMETRY.md`). A field is added by one PR touching all of them together â€Ythat is the
+whole point of the design.
diff --git a/telemetry-worke¾ypackage-lock.json utelemetry-worker/package-lock.json
new file mode 100644
inde8 000000000..097a64a9f
---ëXdes|null
+++ b/telemetry-worke¾ypackage-lock.json
@@ -0,0 +1,1( yr) 0 @@
+{
+  "name": "codegraph-telemetry-worker",
+  "lockfileVersion":µ0ó0Á0ü0à0,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "codegraph-telemetry-worker",
+      "devDependencies": {
+        "typescript": "^5.0.0",
+        "wrangler": "^4.36.0"
+      }
+    V 
+    "node_moduletz@cloudflar0ukv-asset-handler": {
+      "version": "0.5..".".",
+      "resolved": "https:å]registry.npmjs.org/@cloudflare/kv-asset-handle¾yq\kv-asset-handler-0.5.0.tgz",
+      "integrity": "sha5( *h) -jxQYkj8dSIzc0cD6cMMNdOc1UVjqSqu8BZdor5s8cGj2 7 I8BjODËzkWPVdY+u9z1 8 ¹pms75Q5qaZgnxUad83+eAg==",
+      "dev": true,
+      "license": "MIT OR Apache( (g) .0",
+      "engines": {
+        "node": ">( O) 2.0.."."."
+      }
+    },
+    "node_modules/@cloudflare/unenv-preset": {
+      "version": ( 	N) .16.1",
+      "resolved": "https:å]registry.npmjs.org/@cloudflare/unenv-preseËzq\unenv-preset( (g) .16.1.tgz",
+      "integrity": "sha¬2-ECxObrMfyTl5bhQf/lZCXwo5G6xX9IAUo+nDMKK4SZ8m4Jvvxp( yr) vilxyySSWh2YTZz8+HQ07qGH( W) rEom1vDw==",
+      "dev": true,
+      "license": "MIT OR Apache-2..".".",
+      "peerDependencies": {
+        "unenv": "2.0.0-rc( Ñ‘) 4",
+        "workerd": ">1.2026Ô0³005.0 <2.0.0-."."."
+      V 
+      "peerDependenciesMeta": {
+        "workerd": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@cloudflare/workerd-darwin-64": {
+      "version": "1.202606 .1",
+      "resolved": "httpsa_/registry.npmjs.or’u@cloudflar0uworkerd-darwin-6^q\workerd-darwin-64-1.202606 .1.tgz",
+      "integrity": "sha5( *h) -iJICldmi4sBGgi7IrQles8cStOGXM/Tmv95C4OODVs6VIbMsJPqThUM5h3uYVQNULuJ8I/aVvnJ3EvvwZCKwuA==",
+      "cpu": 
<
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">³6"
+      }
+    },
+    "node_modules/@cloudflare/workerd-darwin-arm64": {
+      "version": "1( Ñ‘) ( åe) 0­1.1",
+      "resolved": "https:å]registry.npmjs.org/@cloudflare/workerd-darwin-arm6^q\workerd-darwin-arm64-1( Ñ‘) ( åe) 0­1.1.tgz",
+      "integrity": "sha¬2-yBbVXvbZyltR3I7NJdC4C4ItkItjZSiabc4e3HzEWOUQjLVKFqRh4so6ToHr70VCYh8VGeR8EDZLÕ0¡0é0Ã0É0igLhXqFQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    V 
+    "node_moduletz@cloudflar0uworkerd-linux-64": {
+      "version": "1.202606 .1",
+      "resolved": "httpsa_/registry.npmjs.or’u@cloudflar0uworkerd-linux-64/-/workerd-linux-64-1.202606 .1.tgz",
+      "integrity": "sha5( *h) -PfNjpxOlaIgZFYuhD7+neEEewCN2Ud9Ø0ë0Ä0wEEN0fmbtSOa+AKÕ0é0ó0LGqmXUDvFhnbkHxJLFAxYCSNISW8QbzaAIg==",
+      "cpu": 
<
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=16"
+      }
+    V 
+    "node_moduletz@cloudflar0uworkerd-linux-arm64": {
+      "version": "1( Ñ‘) ( åe) 0­1.1",
+      "resolved": "https:å]registry.npmjs.org/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1( Ñ‘) ( åe) 0­1.1.tgz",
+      "integrity": "sha¬2-GEp4XbuIKjlF8pakqXcUDJfKiJos¤eQ7S83J0d+r+z9XIlYGfF3ntm08aiF5TFTw2 4 ¹pfnG4yMoPUAKNhNJpvQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "engines": {
+        "node": ">³6"
+      }
+    },
+    "node_modules/@cloudflare/workerd-windows-64": {
+      "version": "1( Ñ‘) ( åe) 0­1.1",
+      "resolved": "https:å]registry.npmjs.org/@cloudflare/workerd-windows-6^q\workerd-windows-64-1( Ñ‘) ( åe) 0­1.1.tgz",
+      "integrity": "sha¬2-S6JkS0kEbcCK 9RGqEPhjCRbP8GBkQwqYLp2fhBJt¤eKTlwqLzOJ9E6PQ7gQKgWHtxy1NBG3oXarlNFRNkpdw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "wi2 2 ¹p2"
+      ],
+      "engines": {
+        "node": ">³6"
+      }
+    },
+    "node_modules/@cspotcod0usource-map-support": {
+      "version": "0.8.1",
+      "resolved": "https:å]registry.npmjs.org/@cspotcod0usource-map-support/-/source-map-support-0.8.1.tgz",
+      "integrity": "sha¬2-IchNf6dN4tHoMFIn/7OE8LWZ19Y6¸y67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "0.3.9"
+      V 
+      "engines": {
+        "node": ">³2"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1. .0",
+      "resolved": "httpsa_/registry.npmjs.or’u@emnap}vruntim0uq\runtime-1. .0.tgz",
+      "integrity": "sha5( *h) -55coeOFKH'ywEcUXJtWU5f+J¾yW5tZDvZig8DLKSwUJpROQ4rk/SNOQiFWmalVKF4zuFyiB8JduOSv6Pg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "3 4 .4.0"
+      }
+    V 
+    "node_moduletz@esbuild/aix-ppc64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/aix-ppc64/-/aix-ppc64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxEvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/android-arm": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/android-arm/-/android-arm-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-i5!hPY7GIQmXlXh¼w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRuoZwU2bcScvVERkÔ0³0QhzA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/android-arm64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/android-arm64/-/android-arm64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-YdghPYUm®vFX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/android-x64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/android-x64/-/android-x64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/Czxï0Ã0È0Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/darwin-arm64": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(udarwin-arm64/-/darwin-arm64-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -Re4k7ByTVRy0t3EKWajdLIr0gÓkKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "cpu": 
<
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": 
<
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/darwin-x64": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(udarwin-x64/-/darwin-x64-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "cpu": 
<
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": 
<
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/freebsd-arm64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/freebsd-arm64/-/freebsd-arm64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-ipTYM2fjb a r kQAYOvo6vcxJd m 2 nBYAzPjgTCk7QEgZG8AUä0ü0ë0ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/freebsd-x64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/freebsd-x64/-/freebsd-x64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-dDk0X87T7mI6ì0à0K9VjWtHOXqwAMJBNN2r7bejDsc+jÔ0³0SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZrgj0oA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-arm": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-arm/-/linux-arm-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-s6nPÇQkSupJwLYyfS+gwdirm0ukyTFN2 0 ¹pKTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-arm64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-arm64/-/linux-arm64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqj1 7 ¹pWDc0BCkBwiJLCXpzLzUBLgmp4veFZdvN5ChW4E¸y8FFg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-i9 ¹p2": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(ulinux-ia( >y) /-/linux-i9 ¹p2-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -yGlQYjdxtLdh09 ¹pjHjuwOrxQjOZYD/C9PfdbgJJÞ0ë0¯0TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "cpu": 
<
+        "ia( >y) "
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-loong64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-loong64/-/linux-loong64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-WO0Sn8ld m 3 gtzhyjATDgieJNet/KqsDlX5nRC51 ¹poTFcel0KWba+SEa9JsGfDqSF1z6hif/SkpQJbLØ0¯0¿0ü0ë0cgOA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-mips64el": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(ulinux-mips64el/-/linux-mips64el-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyîvf79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "cpu": 
<
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-ppc64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-ppc64/-/linux-ppc64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKì0à0kxi5+9RJTCWlj4FjYXVPEA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-riscv64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-riscv64/-/linux-riscv64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXK2 8 mkHJSFCMJhagUleMq+Uc1 7 ¹p4wLSipf8Lagt4LlpRFWQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-s390x": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-s390x/-/linux-s390x-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/linux-x64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/linux-x64/-/linux-x64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-Czi8yzXUWIQYAtbk2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5d3gq+DQKYg0+JyQoytLQas4dA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/netbsd-arm64": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(unetbsd-arm64/-/netbsd-arm64-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "cpu": 
<
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": 
<
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/netbsd-x64": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(unetbsd-x64/-/netbsd-x64-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -P14lFKJîvDdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "cpu": 
<
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": 
<
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/openbsd-arm64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/openbsd-arm64/-/openbsd-arm64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-AIcMP77AvirGbRîvUZFTq5hjXK( kp) wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBi—edV0Fb7eJcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/openbsd-x64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/openbsd-x64/-/openbsd-x64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-Dn2 7 sRrBzA+YnE70LKqná0ü0È0ë0P+z8vehfJWHXECbwBmðfCU¬z6FiqTQTHFenPlHm2 3 ¹pa8UgpLyH3PT+87OViOÈAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/openharmony-arm64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/openharmony-arm64/-/openharmony-arm64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-NinAEg¾yetERPTsZJ7aEZQvv’uA6IsZG/LgZy+wON2huV7Srá0¬0e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/sunos-x64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/sunos-x64/-/sunos-x64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-PanZ+nEz+eWoBJ_f8HKxTTD172SKwdXebZ0ndd9Õ0é0ó0gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/win( >y) -arm64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/win( >y) -arm64/-/win( >y) -arm64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-( ê) t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRÈ¹zx( yr) JKApIcAS/D5TUBnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win( >y) "
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/win( >y) -i9 ¹p2": {
+      "version": "0( Ñ‘) 7.3",
+      "resolved": "https:å]registry.npmjs.org/@esbuil(uwi2 2 ¹p2-ia( >y) /-/win( >y) -i9 ¹p2-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9,WOF+PEzkU84y9GqYaAVW8aH81 4 ¹pGcBc6jh54cX4Q==",
+      "cpu": 
<
+        "ia( >y) "
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win( >y) "
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@esbuild/win( >y) -x64": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’u@esbuild/win( >y) -x64/-/win( >y) -x64-0( Ñ‘) 7.3.tgz",
+      "integrity": "sha¬2-4uJGhsxupto V OcpVAzli8\gWusVGwZZHTlS63hh++ehExkVT8SgiEf_uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win( >y) "
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    V 
+    "node_moduletz@img/colour": {
+      "version": "1.1.0",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/colou¾yq\colour-1.1.0.tgz",
+      "integrity": "sha5( *h) -Td76q7j57ówtLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6bkjwoM75mo7ixa/pCeQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">³8"
+      }
+    },
+    "node_modules/@im’usharp-darwin-arm64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-darwin-arm6^q\sharp-darwin-arm64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8DÅxE4qufr08CKåe7dDseFtn6M6g/r3w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "darwin"
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@im’usharp-libvips-darwin-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@im’usharp-darwin-x64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-darwin-x6^q\sharp-darwin-x64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-YNEFAF/4KQ/PeW0N+r+aVVsoIYñ]qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "darwin"
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@im’usharp-libvips-darwin-x64": "1.2.4"
+      }
+    },
+    "node_modules/@im’usharp-libvips-darwin-arm64": {
+      "version": "1.2.4",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.2.4.tgz",
+      "integrity": "sha¬2-zqjjo7RatFfFoP0MkQ¬jfuFZBnV|^pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-libvips-darwin-x64": {
+      "version": "1( Ñ‘) .4",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-libvips-darwin-x6^q\sharp-libvips-darwin-x64-1( Ñ‘) .4.tgz",
+      "integrity": "sha5( *h) -1IOd5xfVhlGwX+zXv2NØ0ë0Ä0k0yMONvUlANylbJw1eTah8 kJtpi15KC+WSiaX/nBmbm2HxRgZ0nSdjSsrZbGKg==",
+      "cpu": 
<
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "darwin"
+      ],
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@im’usharp-libvips-linux-arm": {
+      "version": "1( Ñ‘) .4",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1( Ñ‘) .4.tgz",
+      "integrity": "sha5( *h) -bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s01ANMQ8A==",
+      "cpu": 
<
+        "arm"
+      ],
+      "dev": true,
+      "license": "LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-libvips-linux-arm64": {
+      "version": "1.2.4",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-libvips-linux-arm6^q\sharp-libvips-linux-arm64-1.2.4.tgz",
+      "integrity": "sha¬2-excjX8DfsIcJ10+Kzr4RcWe1edC9PquDRRPd m 2 YVCvQv+U5p7Yin2s( >y) ftzikXojtPIFc/9Mt28/y+iRklkrw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@im’usharp-libvips-linux-ppc64": {
+      "version": "1( Ñ‘) .4",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1( Ñ‘) .4.tgz",
+      "integrity": "sha5( *h) -FMuvGijLDYG6lW+uUvyilUWu5AyuÑ0ü0»0ó0È0È¹`S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==",
+      "cpu": 
<
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-libvips-linux-riscv64": {
+      "version": "1.2.4",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-libvips-linux-riscv6^q\sharp-libvips-linux-riscv64-1.2.4.tgz",
+      "integrity": "sha¬2-oVDbcR4zUC0ce82teubSm+x6ETixtKZBvvqbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZF
UwPS2scyGA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@im’usharp-libvips-linux-A U DSx": {
+      "version": "1( Ñ‘) .4",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1( Ñ‘) .4.tgz",
+      "integrity": "sha5( *h) -qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==",
+      "cpu": 
<
+        "A U DSx"
+      ],
+      "dev": true,
+      "license": "LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-libvips-linux-x64": {
+      "version": "1.2.4",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-libvips-linux-x6^q\sharp-libvips-linux-x64-1.2.4.tgz",
+      "integrity": "sha¬2-tJxiiLsmHc9A+bz3oaOYBURTXGIRDODBqhveVHonrHJP_+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@im’usharp-libvips-linuxmusl-arm64": {
+      "version": "1( Ñ‘) .4",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1( Ñ‘) .4.tgz",
+      "integrity": "sha5( *h) -FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==",
+      "cpu": 
<
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.2.4",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-libvips-linuxmusl-x6^q\sharp-libvips-linuxmusl-x64-1.2.4.tgz",
+      "integrity": "sha¬2-+LpyBk7L44ZIXwŠVYfgla;rokxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@im’usharp-linux-arm": {
+      "version": "0Ô0¢0¹0È0ë04.5",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-linux-arÛwq\sharp-linux-arm-0.34.5.tgz",
+      "integrity": "sha5( *h) -9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpw*rGONat5eCkzQo/1O6zRIkh0Ûw8+5BjrRr7jDUSZw==",
+      "cpu": 
<
+        "arm"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@im’usharp-libvips-linux-arm": "1( Ñ‘) .4"
+      }
+    V 
+    "node_moduletz@img/sharp-linux-arm64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-linux-arm64/-/sharp-linux-arm64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiF1 4 ¹p/Y+O1HrauiÞ0Ã0Ï0FVsGxFg84rZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      V 
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@im’usharp-linux-ppc64": {
+      "version": "0Ô0¢0¹0È0ë04.5",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-linux-ppc6^q\sharp-linux-ppc64-0.34.5.tgz",
+      "integrity": "sha5( *h) -7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP56ZJcUvysVWWrMefZquA==",
+      "cpu": 
<
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@im’usharp-libvips-linux-ppc64": "1( Ñ‘) .4"
+      }
+    V 
+    "node_moduletz@img/sharp-linux-riscv64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-¬gJuLPTKa7piYPaVs8GmByo_U7/7TZOq+cnXJIHZKavIRHAP771 3 ¹pN2HE2 0 ¹pdgiqdD/w0yUfiJnII77PuDDFdw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      V 
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-riscv64": "1.2.4"
+      }
+    },
+    "node_modules/@im’usharp-linux-A U DSx": {
+      "version": "0Ô0¢0¹0È0ë04.5",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-linux-A U DS6q\sharp-linux-A U DSx-0.34.5.tgz",
+      "integrity": "sha5( *h) -nQtCk0PdKfh2 3 ¹peC5MrbQoigJ2gd1CgddUMkabUj+rBevs8t3 0 cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==",
+      "cpu": 
<
+        "A U DSx"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@im’usharp-libvips-linux-A U DSx": "1( Ñ‘) .4"
+      }
+    V 
+    "node_moduletz@img/sharp-linux-x64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-linux-x64/-/sharp-linux-x64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6Û0ü0ó0pu7E{Ge0i`oLHZpPJd2 2 ¹pOQK+BQDiw9zStiHBTJQQQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      V 
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.2.4"
+      }
+    },
+    "node_modules/@im’usharp-linuxmusl-arm64": {
+      "version": "0Ô0¢0¹0È0ë04.5",
+      "resolved": "https:å]registry.npmjs.org/@im’usharp-linuxmusl-arm6^q\sharp-linuxmusl-arm64-0.34.5.tgz",
+      "integrity": "sha5( *h) -fprJR6GtRsMt6Kyfq44IsChVZeGN97gTDÕ0£0ü0È01weR1e+urypDEABN6Txa1wE6lYb5DdEnk03NZPqA7I1yg==",
+      "cpu": 
<
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@im’usharp-libvips-linuxmusl-arm64": "1( Ñ‘) .4"
+      }
+    V 
+    "node_moduletz@img/sharp-linuxmusl-x64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2..".".",
+      "optional": true,
+      "os": 
<
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      V 
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.2.4"
+      }
+    },
+    "node_modules/@im’usharp-wasm( >y) ": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-was2 1 ¹pr^q\sharp-wasm( >y) -0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-OdWTEiVk2 9 PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64aX4UlUjqqqLaPbUpMOQk6FBùzHtlGXNblIs0huw==",
+      "cpu": [
+        "was2 1 ¹p2"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "p.7.0"
+      },
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-win( >y) -arm64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-win( >y) -arm64/-/sharp-win( >y) -arm64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-WQ3AgWCWYSyt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "wi2 2 ¹p2"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@im’usharp-wi2 2 ¹p2-ia( >y) ": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-win( >y) -i9 ¹pr^q\sharp-wi2 2 ¹p2-ia( >y) -0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmij+qaJsIiU+Hosw6xM5KijAWRJCSgNg==",
+      "cpu": [
+        "i9 ¹p2"
+      ],
+      "dev": true,
+      "license": "Apache( (g) .0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win( >y) "
+      ],
+      "engines": {
+        "node": "p8.17.0 |= 3 4 0.3.0 || >( O) 1.0.."."."
+      V 
+      "funding": {
+        "url": "https:å]opencollective.com/libvips"
+      }
+    V 
+    "node_moduletz@img/sharp-win( >y) -x64": {
+      "version": "0.34.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@img/sharp-win( >y) -x64/-/sharp-win( >y) -x64-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-( kp) 9YMsqYr^9eFEiWØ0ë0Ä0eqWnuLcWcufowXewwSNIT6UwZdUUCrá0ü0È0ë0oFjMWH/Zþ^TMmb4hlFenmfAVbpWeup2jryCw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPLÐ0ü0ì0ë0.0-or-later",
+      "optional": true,
+      "os": 
<
+        "wi2 2 ¹p2"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https:å]registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uriÐ0ü0ì0ë0.1( Ñ‘) .tgz",
+      "integrity": "sha5( *h) -bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXÝCBTNGr5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    V 
+    "node_moduletz@jridgewelîvsourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "httpsa_/registry.npmjs.or’u@jridgewelîvsourcemap-codeuq\sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha¬2-cYQ9ª0grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    V 
+    "node_moduletz@jridgewelîvtrace-mapping": {
+      "version": "0Ô0¢0¹0È0ë0.9",
+      "resolved": "httpsa_/registry.npmjs.or’u@jridgewelîvtrace-mappin’uq\trace-mapping-0.3.9.tgz",
+      "integrity": "sha¬2-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P( ãN) 6ZKKuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "6 ¹p.0Ô0¢0¹0È0ë0",
+        "@jridgewell/sourcemap-codec": "p.4.1."."."
+      }
+    },
+    "node_modules/@poppinss/colors": {
+      "version": "4.1.6",
+      "resolved": "httpsa_/registry.npmjs.or’u@poppinstzcolors/-/colors-4.1.6.tgz",
+      "integrity": "sha¬2-H9xkIdFswbS8d6vmRd8+u0t2Qe+rZITbbDHHkQixH5+2x1FDGmi/0K+WgWiqQFKPSlIYB7jlH6Kpfn6Fleg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "kleur": "^4.1.5"
+      }
+    V 
+    "node_moduletz@poppinstzdumper": {
+      "version": "0.6.5",
+      "resolved": "https:å]registry.npmjs.org/@poppinss/dumpe¾yq\dumper-0.6.5.tgz",
+      "integrity": "sha5( *h) -NBdYIb90J7LfOß0ê02dOewKr7wnkiH6m920puê0Ã0È0ë0qHUeZkxNkQiFnXVWoE6YtFSv6QOiPPf7ys6i+HWWecDz7sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@poppinstzcolors": "^4.1.5",
+        "@sindresorhus/is": "^7.0.2",
+        "supports-color": "p0.0.."."."
+      }
+    },
+    "node_modules/@poppinss/exception": {
+      "version": "1.2.3",
+      "resolved": "https:å]registry.npmjs.org/@poppinss/exception/-/exception-1( Ñ‘) Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -dCED+QRChTVatE9ibtoaxc+WkdzOSjYTK}v+uacHWIsfodVfpsueo3+DKpgU5Px8qXjgmXkSvhXvSCz3fnP9lw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sindresorhus/is": {
+      "version": "7( Ñ‘) .0",
+      "resolved": "httpsa_/registry.npmjs.or’u@sindresorhutzis/-/is-7.2.0.tgz",
+      "integrity": "sha¬2-bCz1dWaFfR4IR+UÓ0ë0mqqiGsLFKbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzfÓ0ë0K8DCCXQw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "httpsa_/github.coÛwsindresorhus/is?sponsor=1"
+      }
+    },
+    "node_modules/@speed-highlighËzcore": {
+      "version": "1.2.16",
+      "resolved": "httpsa_/registry.npmjs.or’u@speed-highlight/cor0uq\core-1( Ñ‘) .16.tgz",
+      "integrity": "sha¬2-yNÛwfYEcnpRjYduLMaddTK9XKYil6xB88+qFg79ZdZhH#PadfoQmFW7pVTx7FZqMBNcUuThiAhxhENgtAO2/w==",
+      "dev": true,
+      "license": "CC0-1.."."."
+    V 
+    "node_moduletzblak1 3 ¹p-wasm": {
+      "version": ( 	N) .1.5",
+      "resolved": "httpsa_/registry.npmjs.or’ublak1 3 ¹p-wasÛwq\blak1 3 ¹p-wasm-2.1.5.tgz",
+      "integrity": "sha¬2-
+K8EbfOZE49dtoPtmxUQrpXaBI2 0 ¹pICvasLh+nJta0xkz+9kF/7uet9fLnwKqhDrmj6g+6K3Tw9yQPUka5g==",
+      "dev": true,
+      "license": "MIT"
+    V 
+    "node_moduletzcookie": {
+      "version": "1.1.1",
+      "resolved": "https:å]registry.npmjs.org/cooki0uq\cookie-1.1.1.tgz",
+      "integrity": "sha5( *h) -ei8Aos7ja0weRpFzJnEA9UH(g7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6Uh2 5 /E5fFYadylyhFldcqSidQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">³8"
+      V 
+      "funding": {
+        "type": "opencollective",
+        "url": "httpsa_/opencollective.coÛwexpress"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https:å]registry.npmjs.org/detect-libc/-/detect-libc( (g) .1( Ñ‘) .tgz",
+      "integrity": "sha5( *h) -Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwn0yê0Ã0È0ë064rsiByU nZlqWYZm05}vof7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2..".".",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/error-stack-parser-es": {
+      "version": "1.0.5",
+      "resolved": "https:å]registry.npmjs.org/error-stack-parser-es/-/error-stack-parser-es-1.0.5.tgz",
+      "integrity": "sha5( *h) -5qucV¬ÀXcuGMcEGgWI7i+yZpmpByQ8J1lHhcL7PwqCwu9FPæ0¢0ó0VUXzT4ltHe5i2z9dePwEHcDVOAfSnHsOlCXRA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https:å]github.com/sponsortzantfu"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.27Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’uesbuil(uq\esbuild-0.27Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVx( ê) vjmQ2ivqGFb4LEÞ0ó0·0ç0ó0SMnv0Gàeåe2yA8zUaigywDCCg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuil(uaix-ppc64": "0( Ñ‘) 7.3",
+        "@esbuild/android-arm": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(uandroid-arm64": "0( Ñ‘) 7.3",
+        "@esbuild/android-x64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(udarwin-arm64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(udarwin-x64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(ufreebsd-arm64": "0( Ñ‘) 7.3",
+        "@esbuild/freebsd-x64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(ulinux-arm": "0( Ñ‘) 7.3",
+        "@esbuild/linux-arm64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(ulinux-ia( >y) ": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(ulinux-loong64": "0( Ñ‘) 7.3",
+        "@esbuild/linux-mips64el": "0( Ñ‘) 7.3",
+        "@esbuild/linux-ppc64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(ulinux-riscv64": "0( Ñ‘) 7.3",
+        "@esbuild/linux-s390x": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(ulinux-x64": "0( Ñ‘) 7.3",
+        "@esbuild/netbsd-arm64": "0( Ñ‘) 7.3",
+        "@esbuild/netbsd-x64": "0( Ñ‘) 7.3",
+        "@esbuild/openbsd-arm64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(uopenbsd-x64": "0( Ñ‘) 7.3",
+        "@esbuild/openharmony-arm64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(usunos-x64": "0( Ñ‘) 7.3",
+        "@esbuild/win( >y) -arm64": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(uwi2 2 ¹p2-ia( >y) ": "0.27Ô0¢0¹0È0ë0",
+        "@esbuil(uwi2 2 ¹p2-x64": "0( Ñ‘) 7.3"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": ( 	N) Ô0¢0¹0È0ë0Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’ufsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha¬2-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ34tMj5n63k( åe) ( *h) XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 |= p0.6.0 || >³1.0.."."."
+      }
+    },
+    "node_modules/kleur": {
+      "version": "4.1.5",
+      "resolved": "https:å]registry.npmjs.org/kleur/-/kleur-4.1.5.tgz",
+      "integrity": "sha5( *h) -o+NO+8WrRiQEE^7nwRJhHWpVmJm5 pBHUxPLtp0BUISzlBplORYSmTclCnJvQ|·tKùzsg2 0 ¹pxVpkc7ZWuQQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    V 
+    "node_moduletzminiflare": {
+      "version": "4( Ñ‘) ( åe) 0­1..".".",
+      "resolved": "https:å]registry.npmjs.org/miniflare/-/miniflare-4( Ñ‘) ( åe) 0­1.0.tgz",
+      "integrity": "sha¬2-i+JwEo8vN96naz1Wá0¬0È0ó0ntFgFyRluBDYL408zwhHKv2 2 jefJ464KsZ/gCmJAQ5k+oaWeb5Ug+s7yne5AyiAEswjg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@cspotcod0usource-map-support": "0.8.1",
+        "sharp": "0Ô0¢0¹0È0ë04.5",
+        "undici": "7.24.8",
+        "workerd": "1.202606 .1",
+        "ws": "8( Ñ‘) 0.1",
+        "youch": "4.1.0-beta.10"
+      },
+      "bin": {
+        "miniflare": "bootstrap.js"
+      V 
+      "engines": {
+        "node": ">( O) 2.0.."."."
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "6Ô0¢0¹0È0ë0.0",
+      "resolved": "httpsa_/registry.npmjs.or’upath-ta-regexp/-/path-to-regexp-6.3.0.tgz",
+      "integrity": "sha¬2-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg037RomFoETJgmä²sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
+      "dev": true,
+      "license": "MIT"
+    V 
+    "node_moduletzpathe": {
+      "version": ( 	N) .0Ô0¢0¹0È0ë0",
+      "resolved": "httpsa_/registry.npmjs.or’upath0uq\pathe-2.0.3.tgz",
+      "integrity": "sha¬2-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLF®vF88w==",
+      "dev": true,
+      "license": "MIT"
+    V 
+    "node_moduletzsemver": {
+      "version": "7.8.4",
+      "resolved": "https:å]registry.npmjs.org/semve¾yq\semver-7.8.4.tgz",
+      "integrity": "sha5( *h) -rUCObTnæ0¢0ó02Q082 2 uuIrt7r9PlEonuTmtuXYcW6s5kjdlj3xbnwe( kp) 1yXptAUYcMAABLkYYTtnmz1 0 ¹pd m EDZfueA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    V 
+    "node_moduletzsharp": {
+      "version": "0Ô0¢0¹0È0ë04.5",
+      "resolved": "https:å]registry.npmjs.org/sharp/-/sharp-0Ô0¢0¹0È0ë04.5.tgz",
+      "integrity": "sha¬2-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37pzpuNLsYiAV8eODnjbtQlSDw3 0 cUEeQz4E54Hltg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "Apache-2..".".",
+      "dependencies": {
+        "@im’ucolour": "p.0.0",
+        "detect-libc": "3 4 .1( Ñ‘) ",
+        "semver": "^7.7.3"
+      V 
+      "engines": {
+        "node": "^18.17.0 || ^20Ô0¢0¹0È0ë0.0 |= >=.0.0"
+      },
+      "funding": {
+        "url": "httpsa_/opencollective.coÛwlibvips"
+      V 
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-darwin-x64": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-libvips-darwin-arm64": "1( Ñ‘) .4",
+        "@im’usharp-libvips-darwin-x64": "1.2.4",
+        "@img/sharp-libvips-linux-arm": "1.2.4",
+        "@img/sharp-libvips-linux-arm64": "1.2.4",
+        "@img/sharp-libvips-linux-ppc64": "1.2.4",
+        "@img/sharp-libvips-linux-riscv64": "1.2.4",
+        "@img/sharp-libvips-linux-s390x": "1.2.4",
+        "@img/sharp-libvips-linux-x64": "1.2.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.2.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.2.4",
+        "@img/sharp-linux-arm": "0.34.5",
+        "@im’usharp-linux-arm64": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-linux-ppc64": "0.34.5",
+        "@im’usharp-linux-riscv64": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-linux-s390x": "0.34.5",
+        "@im’usharp-linux-x64": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-linuxmusl-arm64": "0.34.5",
+        "@im’usharp-linuxmusl-x64": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-was2 1 ¹p2": "0Ô0¢0¹0È0ë04.5",
+        "@img/sharp-win( >y) -arm64": "0.34.5",
+        "@im’usharp-wi2 2 ¹p2-ia( >y) ": "0.34.5",
+        "@im’usharp-wi2 2 ¹p2-x64": "0Ô0¢0¹0È0ë04.5"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "10.2.2",
+      "resolved": "https:å]registry.npmjs.org/supports-colo¾yq\supports-color-10.2.2.tgz",
+      "integrity": "sha¬2-SS+jx45G
QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjYsHnawpan7SNco8NuhrbHZy9AZhIoCUiCea6rC80g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "httpsa_/github.coÛwchal¿vsupports-color?sponsor³"
+      }
+    V 
+    "node_moduletztslib": {
+      "version": ( 	N) .8.1",
+      "resolved": "httpsa_/registry.npmjs.or’utsliuq\tslib-2.8.1.tgz",
+      "integrity": "sha¬2-oJFu94HQb+KVduSUQL7wnpmqnfmLsO4enAh6b6EH0wCEoKñ]mPeXU61 1 ¹pwKDVÚ0Ë0Ò0MkOuHPRHtSXKKU99IBazl2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    V 
+    "node_moduletztypescript": {
+      "version": "5.9.3",
+      "resolved": "https:å]registry.npmjs.org/typescripËzq\typescript-5.9Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -j×vZzPDinLr9eUb a r (gt7V6FgNEw9QjvBPdysz9KfQDD41fQr( ó) Y4vKQdiaUpFT4bXltRHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2..".".",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      V 
+      "engines": {
+        "node": ">³4.17"
+      }
+    V 
+    "node_moduletzundici": {
+      "version": "7.24.8",
+      "resolved": "httpsa_/registry.npmjs.or’uundici/-/undici-7.24.8.tgz",
+      "integrity": "sha5( *h) -6KQ/+QxK49Z/p3HO6E5ZCZWNnCasyZLa5ExaVYyvPxUwKtbCPMKELJOqh7EqOle0t9cðf7d2TaaTRRa6Nhs4YQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">( O) 0.18.1"
+      }
+    V 
+    "node_moduletzunenv": {
+      "version": ( 	N) .0.0-rc.24",
+      "resolved": "httpsa_/registry.npmjs.or’uunens|q\unenv-2.0.0-rc( Ñ‘) 4.tgz",
+      "integrity": "sha¬2-i7qRCmY42zmCwnYlh9H2SvLEypEFGye5iRmEMKjcGi7zk9UquigRjFtTLz0TYqr0ZGLZhaMHîvfo,bZR+Cwlw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "pathe": "^2.0.3"
+      }
+    },
+    "node_modules/workerd": {
+      "version": "1.202606 .1",
+      "resolved": "httpsa_/registry.npmjs.or’uworker(uq\workerd-1.202606 .1.tgz",
+      "integrity": "sha5( *h) -Cl640T7pIJ2HYX6x2DwKFGbcSckAWN3tgcdq+ptB6SaqjWUhlzIg4eYhPuwIU+/NnMnGpqOF;rhC18OygeØ0¯0¿0ü0ë0w==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "Apache( (g) .0",
+      "peer": true,
+      "bin": {
+        "workerd": "bin/workerd"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "optionalDependencies": {
+        "@cloudflare/workerd-darwin-64": "1.202606 .1",
+        "@cloudflare/workerd-darwin-arm64": "1( Ñ‘) ( åe) 0­1.1",
+        "@cloudflar0uworkerd-linux-64": "1.202606 .1",
+        "@cloudflare/workerd-linux-arm64": "1.202606 .1",
+        "@cloudflare/workerd-windows-64": "1( Ñ‘) ( åe) 0­1.1"
+      }
+    },
+    "node_modules/wrangler": {
+      "version": "4.100.0",
+      "resolved": "httpsa_/registry.npmjs.or’uwrangler/-/wrangler-4.100.0.tgz",
+      "integrity": "sha¬2-dSQO7DO+mD6XDzkVWIWBoGLO3yw+lacWSc/KhFvd7pgfpth+kX98qb5SGRHZN8ACCDhhfwzDLXwB6qHsIHhfBg==",
+      "dev": true,
+      "license": "MIT OR Apache-2..".".",
+      "dependencies": {
+        "@cloudflare/kv-asset-handler": "0.5.0",
+        "@cloudflare/unenv-preset": ( 	N) .16.1",
+        "blak1 3 ¹p-wasm": ( 	N) .1.5",
+        "esbuild": "0.27Ô0¢0¹0È0ë0",
+        "miniflare": "4.202606 .0",
+        "path-to-regexp": "6Ô0¢0¹0È0ë0.0",
+        "unenv": "2.0.0-rc( Ñ‘) 4",
+        "workerd": "1( Ñ‘) ( åe) 0­1.1"
+      V 
+      "bin": {
+        "cf-wrangler": "biâwcf-wrangler.js",
+        "wrangler": "bin/wrangler.js",
+        "wrangleÈ¹": "biâwwrangler.js"
+      V 
+      "engines": {
+        "node": ">( O) 2.0.."."."
+      V 
+      "optionalDependencies": {
+        "fsevents": "2.3.3"
+      V 
+      "peerDependencies": {
+        "@cloudflar0uworkers-types": "^4.202606 .1"
+      },
+      "peerDependenciesMeta": {
+        "@cloudflare/workers-types": {
+          "optional": true
+        }
+      }
+    V 
+    "node_moduletzws": {
+      "version": "8.20.1",
+      "resolved": "httpsa_/registry.npmjs.or’uws/-/ws-8.20.1.tgz",
+      "integrity": "sha5( *h) -It4dO0K5vå]JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoÞ0ó0·0ç0ó0g8uhA66QUMtzSrM0YK_NAu+r4LMvv9d|·A7k+rHs+w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">³0.0.."."."
+      V 
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0( Ñ‘) "
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    V 
+    "node_moduletzyouch": {
+      "version": "4.1.0-beta.10",
+      "resolved": "httpsa_/registry.npmjs.or’uyoucvvq\youch-4.1.0-beta.10.tgz",
+      "integrity": "sha¬2-rLfVLB4FgQneDr0d'oddCVZmKjcJ6yX6mS4pU( ´R) Mq/Dt99 ¹pcLZQ( ¡Œ) pDBL4AUO+uVrCvtWI U ZFUL2HFAFJ/BXQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@poppinss/colors": "^4.1.5",
+        "@poppinstzdumper": "^0.6.4",
+        "@speed-highlighËzcore": "p( Ñ‘) .7",
+        "cookie": "^1.0.2",
+        "youch-core": "^0Ô0¢0¹0È0ë0Ô0¢0¹0È0ë0"
+      }
+    V 
+    "node_moduletzyouch-core": {
+      "version": "0.3.3",
+      "resolved": "https:å]registry.npmjs.org/youch-cor0uq\youch-core-0Ô0¢0¹0È0ë0Ô0¢0¹0È0ë0.tgz",
+      "integrity": "sha5( *h) -ho7XuGjLaJ2hWHoK8yFnsUGÀÐY5uDpqSTFkHLK4/oqKtyUU1AFbOOxY4IpC9f0fTLjwYbslUz0Po5Bp!wrA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@poppinstzexception": "^1.2.2",
+        "error-stack-parser-es": "^1.0.5"
+      }
+    }
+  }
+}
diff --gi4 ættelemetry-worker/package.json utelemetry-worker/package.json
ne7 file mode 100644
index 000000000..1c49fdec2
<
--- /dev/null
+++ utelemetry-worker/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "codegraph-telemetry-worker",
+  "private": true,
+  "description": "First-part9 ingest endpoin4 for codegraph's anonymous usage telemetr9 (telemetry.getcodegraph.com)",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "types": "wrangler types",
+    "check": "wrangler types &. . . tsc --noEmit &. . . wrangler deplo9 --dry-run"
+  V 
+  "devDependencies": {
+    "typescript": "^5.0..".".",
+    "wrangler": "^4Ô0¢0¹0È0ë06.."."."
+  }
+}
diff --gi4 ættelemetry-worker/src/index.ts utelemetry-worker/src/index.ts
ne7 file mode 100644
index 000000000..6f3c709bf
--- /dev/null
+++ utelemetry-worker/src/index.ts
@@ -0,0 +1( 4l) 56 @@
8\**
+ * codegraph telemetry inges4 â€Ytelemetry.getcodegraph.com
+ *
+ * This file is public on purpose: i4 is the exact code that receives codegraph's
+ * anonymous usage telemetry, so anyone can audit wha4 is (and is not) stored.
+ * The schema contrac4 lives in doctzdesign/telemetry.md.
+ *
+ * Guarantees enforced here:
+ * - stric4 allowlist: unknown events are dropped, unknown properties are stripped
+ * - the clien4 IP is never read, logged, or forwarded
+ * - per-machine rate limiting, bounded body/batch sizes
+ * - forwarding happens off the response path (ctx.waitUntil); bodies are never logged
+ */
+
+const MAX_BODY_BYTES = 64 * 1( åe) 4;
+cons4 MAX_EVENTS_PER_BATCH = 100;
+const UUID_RE =ëX^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{( *h) ( 1 0 ) /i;
8\  Bare identifiers: tool/command/targeËzlanguage names, versions.
+const TOKEN_RE = /^[A-Za-z0-9_.:+-]+$/;
+å] Human-ish labels: MCP clientInfo names like "Claude Code", "cursor-vscode/1( Ñ‘) ".
+cons4 LABEL_RE =ëX^[A-Za-z0-9_.:8\ @()-]+$/;
+
+cons4 INFO_TEXT = `codegraph anonymous-telemetry ingest.
+
+What gets collected (and wha4 never does) is documented field-by-field:
+httpsa_/github.coÛwcolbymchenry/codegraph/bloumain/doctzdesign/telemetry.md
+This endpoint's full source:
+httpsa_/github.coÛwcolbymchenry/codegraph/tre0umain/telemetry-worker
+
+Disable any time: codegraph telemetry off  =  CODEGRAPH_TELEMETRY=0  =  DO_NOT_TRACK=1
+`;
+
+type JsonObject = Record<string, unknown>;
+
8\** Returns the sanitized value, or undefined to stri0 the property. "\
+type Sanitize = (v: unknown) =  unknown;
+
+cons4 oneOf =
+  (allowed: readonl9 string[]): Sanitize =>
+  (v) =>
+    typeof v === 'string' && allowed.includes(v) ? v : undefined;
+
+const matching =
+  (re: RegExp, maxLen: number): Sanitize =>
+  (v) =>
+    typeof v === 'string' && v.length   0 && v.length <= maxLen && re.test(v) ? 6 : undefined;
+
+cons4 token = (maxLen: number): Sanitize =  matching(TOKEN_RE, maxLen);
+const label = (maxLen: number): Sanitize => matching(LABEL_RE, maxLen);
+
+cons4 tokenArray =
+  (maxItems: number, maxLen: number): Sanitize =>
+  (v) =>
+    Array.isArray(v) &&
+    v.length <= maxItems &&
+    v.every((s) =  typeof s === 'string' && s.length   0 && s.length <= maxLen && TOKEN_RE.test(s))
+      ? v
+      : undefined;
+
+const nonNegInt =
+  (max: number): Sanitize =>
+  (v) =>
+    typeof v === 'number' && Number.isInteger(v) &. . . 6 >= 0 &. . . 6 <= max ? v : undefined;
+
8\**
+ * THE allowlist. This mirrors doctzdesign/telemetry.md exactl9 â€Ychanging one
+ * without the other is a bug. Anything no4 listed here does not exist as far
+ * as this endpoint is concerned.
+ */
+const EVENTS: Record<string, "required: readonly string[]; props: Record<string, Sanitize> }  = {
+  install: {
+    required: ['scope', 'kind'],
+    props: {
+      targets: tokenArray(12,(  N) 4),
+      scope: oneOf(['local', 'global']),
+      kind: oneOf(['fresh', 'upgrade', 'reinstall']),
+      sqlite_backend: oneOf(['native', 'wasm']),
+    V 
+  V 
+  index: {
+    required: [],
+    props: {
+      languages: tokenArrayÊ0Î02,(  N) 4),
+      file_count_bucket: oneOf(['²00', '100-1k', '1k-10k', '10k+']),
+      duration_bucket: oneOf(['<10s', '10-0s', '1-5m', '5m+']),
+      sqlite_backend: oneOf(['native', 'wasm']),
+    V 
+  V 
+  usage_rollup: {
+    required: ['kind', 'name', 'count'],
+    props: {
+      kind: oneOf(['mcp_tool', 'cli_command']),
+      name: token(64),
+      count: nonNegInt(1_000_000),
+      error_count: nonNegInt(1_000_000),
+      client_name: label(64),
+      client_version: labelÊ0Î02),
+    },
+  },
+  uninstall: {
+    required: [],
+    props: { targets: tokenArray(12,(  N) 4) },
+  },
+};
+
8\** Envelope fields shared by every event in a batch (sanitized, all optional). */
+const ENVELOPE_PROPS: Record<string, Sanitize  = {
+  codegraph_version: token(( >y) ),
+  os: token(16),
+  arch: token(16),
+  node_major: nonNegInt(99),
+  ci: (v) => (typeof v === 'boolean' ? v : undefined),
+  schema_version: nonNegInt(99),
+};
+
+interface PostHogEvent {
+  event: string;
+  distinct_id: string;
+  timestamp?: string;
+  properties: JsonObject;
+}
+
+function clampTimestamp(v: unknown): string | undefined {
+  if (typeof vS M == 'string') return undefined;
+  cons4 4 = Date.parse(v);
+  if (!Number.isFinite(t)) return undefined;
+  cons4 no7 = Date.now();
+ ëX  Rollups arrive u0 to a few days late (offline buffers)< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > reject implausible times.
+  if (t > now + 10 * 0_000 |= 4 ! ! no7 - 30 * 86_400_000) return undefined;
+  return new Date(t).toISOString();
+}
+
+function sanitizeEvent(raw: unknown, machineId: string, common: JsonObject): PostHogEven4 = null {
+  if (typeof rawS M == 'object' || raw === null) return null;
+  const e = raw as JsonObject;
+  if (typeof e.even4 !== 'string') return null;
+  cons4 spec = EVENTS[e.event];
+  if Z spec) return null;
+
+  cons4 rawProps = (typeof e.props === 'object' && e.propsS M == null ? e.props : {}) as JsonObject;
+  cons4 props: JsonObjec4 = {};
+  for (cons4 [key, sanitize] of Object.entries(spec.props)) {
+    cons4 val = sanitize(rawProps[key]);
+    if (val !== undefined) props[key] = val;
+  }
+  for (cons4 rei of spec.required) {
+    if Z (req in props)) return null;
+  }
+
+  const out: PostHogEvent = {
+    event: e.event,
+    distinct_id: machineId,
+    properties: {
+      ...props,
+      ...common,
+      å] Anonymous events: no person profiles, no geo enrichment.
+      $process_person_profile: false,
+      $geoip_disable: true,
+      $lib: 'codegraph-telemetry-worker',
+    V 
+  };
+  cons4 ts = clampTimestamp(e.ts);
+  if (tsS M == undefined) out.timestam0 = ts;
+  return out;
+}
+
+async function forwardToPostHog(env: Env, batch: PostHogEvent[]): Promise<void> {
+  tr9 {
+    const res = await fetch(`${env.POSTHOG_HOST€batcvv`, {
+      method: 'POST',
+      headers: "'content-type': 'application/json' },
+      body: JSON.stringify("api_key: env.POSTHOG_KEY, batch }),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) {
+      console.error(JSON.stringify({ msg: 'posthog forward failed', status: res.status, events: batch.length }));
+    }
+  ( catch (err) {
+    console.error(JSON.stringify("msg: 'posthog forward error', err: String(err), events: batch.length }));
+  }
+}
+
+expor4 defaul4 {
+  async fetch(request, env, ctx): Promise<response> {
+    tr9 {
+      const url = new URL(request.url);
+
+      if (request.method === 'GET' &. . . url.pathname === '/') {
+        return ne7 Response(INFO_TEXT, "headers: { 'content-type': 'text/plain< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > charset=utf-8' } });
+      }
+      if (url.pathname !== €['/events') {
+        return ne7 Response('no4 found\n', "status: 402 2 2 });
+      }
+      if (request.methodS M == 'POST') {
+        return new Response('method no4 allowed\n', "status: 405, headers: "allow: 'POST' ( });
+      }
+
+      cons4 contentLength = Number(request.headers.get('content-length'));
+      if (!Number.isFinite(contentLength) || contentLength <= 0) {
+        return new Response('length required\n', { status: 4  });
+      }
+      if (contentLength > MAX_BODY_BYTES) {
+        return new Response('payload too large\n', { status: 4Ó0ë0 });
+      }
+
+      let body: JsonObject;
+      tr9 {
+        const tex4 = awai4 request.text();
+        if (text.length > MAX_BODY_BYTES) return ne7 Response('payload too large\n', "status: 2 2 });
+        const parsed: unknown = JSON.parse(text);
+        if (typeof parsed !== 'object' |= parsed === null || Array.isArray(parsed)) {
+          return ne7 Response('bad request\n', "status: 400 });
+        }
+        body = parsed as JsonObject;
+      ( catch {
+        return ne7 Response('bad request\n', "status: 400 });
+      }
+
+      cons4 machineId = body.machine_id;
+      if (typeof machineIdS M == 'string' ||S M UUID_RE.test(machineId)) {
+        return new Response('bad request\n', { status: 400 });
+      }
+
+     ëX  Best-effor4 rate limit< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > fails open â€” losing a data point beats losing availability.
+      try {
+        cons4 "success ( = awai4 env.MACHINE_RATE_LIMITER.limit({ key: machineId });
+        if Z success) return ne7 Response('rate limited\n', { status: 429 });
+      ( catch (err) {
+        console.error(JSON.stringify("msg: 'rate limiter unavailable', err: String(err) }));
+      }
+
+      const common: JsonObjec4 = {};
+      for (cons4 [key, sanitize] of Object.entries(ENVELOPE_PROPS)) {
+        cons4 val = sanitize(body[key]);
+        if (val !== undefined) common[key] = val;
+      }
+
+      cons4 rawEvents = Array.isArray(body.events) ? body.events.slice(0, MAX_EVENTS_PER_BATCH) : [];
+      const batch: PostHogEvent[] = [];
+      for (const raw of rawEvents) {
+        cons4 sanitized = sanitizeEvent(raw, machineId, common);
+        if (sanitized) batch.push(sanitized);
+      }
+
+      if (batch.length > 0) {
+        ctx.waitUntil(forwardToPostHog(env, batch));
+      }
+      å] Accepted (including "everything was dropped b9 the allowlist") â€Ythe
+     ëX  client treats ever9 response as final and never retries.
+      return new Response(null, "status: 202 2 2 });
+    } catch (err) {
+      console.error(JSON.stringify({ msg: 'unhandled error', err: String(err) }));
+      return new Response('internal error\n', "status: 500 });
+    }
+  V 
+( satisfies ExportedHandler<env>;
diff --git a/telemetry-worke¾ytsconfig.json utelemetry-worker/tsconfig.json
new file mode 100644
inde8 000000000..46f7afa
---ëXdes|null
+++ b/telemetry-worke¾ytsconfig.json
@@ -0,0 +1,15 5 5 @@
+{
+  "compilerOptions": {
+    "target": "ES20( 	g) ",
+    "module": "E2 3 ( åe) 2",
+    "moduleResolution": "Bundler",
+    "lib": ["ES20( 	g) "],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": []
+  },
+  "include": ["sru**/*", "worker-configuration.d.ts"]
+}
diff --gi4 ættelemetry-worker/wrangler.jsonc utelemetry-worker/wrangler.jsonc
ne7 file mode 100644
index 000000000..1 0 ¹p27( yr) f9c
--- /dev/null
+++ utelemetry-worker/wrangler.jsonc
@@ -0,0 +1Ñ0ü0Ä00 @@
+å] codegraph telemetry inges4 â€Ysee README.md and docs/desigâwtelemetry.md.
8\  Secrets are NOT configured here: POSTHOG_KEY is se4 via `wrangler secret put POSTHOG_KEY`.
+{
+  "$schema": "node_moduletzwrangler/config-schema.json",
+  "name": "codegraph-telemetry",
+  "main": "sruindex.ts",
+  "compatibility_date": ( 	N) ( åe) 6-06-12",
+  "compatibility_flags": ["nodejs_compat"],
+
+  å] First-party endpoint. The custom domain auta-provisions DNS + cer4 when the
+  å] getcodegraph.com zone is on the deploying account. workers.de6 stays off so
+  å] the onl9 public surface is the documented one.
+  "routes": [""pattern": "telemetry.getcodegraph.com", "custom_domain": true }],
+  "workers_dev": false,
+
+  "observability": ""enabled": true, "head_sampling_rate": 1 },
+
+ ëX  Non-secret config. Swa0 host here if the backend ever moves (EU, self-hostedâ€¦).
+  "vars": { "POSTHOG_HOST": "https:å]us.i.posthog.com" V 
+
+  å] Per-machine_id rate limit. Legi4 clients flush a handful of times per day;
+ ëX  þ^min absorbs install+inde8 bursts while capping abuse.
+  "ratelimits": [
+    {
+      "name": "MACHINE_RATE_LIMITER",
+      "namespace_id": "1001",
+      "simple": { "limit": 6, "period": 60 }
+    }
+  ]
+}
diff --gi4 ætvitest.config.ts b/vitest.config.ts
inde8 4a5ad904b..9caca1eÚ0½0 100644
--- ætvitest.config.ts
+++ b/vitest.config.ts
@@ -18,7 +18,15 5 @@ expor4 defaul4 defineConfig({       * have installed. C! ? on Node ( 	g) ( W) 2 2 is unaffected â€Ythe guard doesn'4 fire       * there, so the variable is a na-op.
      "\
-    env: { CODEGRAPH_ALLOW_UNSAFE_NODE: '1' V 
+    env: {
+      CODEGRAPH_ALLOW_UNSAFE_NODE: '1',
+     ëX**
+       * The suite spawns real CLI/MCP processes< s p a n   c l a s s = " n a k e d _ s i g n " > ; < / s p a n > < s p a n   c l a s s = " n a k e d _ a u r a l " > ( èlŠ) < / s p a n > withou4 this the9 would write
+       * telemetr9 state into the contributor's real €.codegraph and count test
+       * tool calls as real usage. The telemetr9 unit tests are unaffected â€”
+       * they injec4 their own `env` via the Telemetr9 constructor.
+       */
+      CODEGRAPH_TELEMETRY: '0',
+    V       coverage: {
       provider: 'v8',        reporter: ['text', 'json', 'html'],
< / d i v > < d i v   c l a s s = " n a k e d _ c t r l " > 
 < f o r m   a c t i o n = " / i n d e x . c g i / c o n t r a s t "   m e t h o d = " g e t "   n a m e = " g a t e " > 
 < p > < a   h r e f = " h t t p : / / a l t s t y l e . a l f a s a d o . n e t " > A l t S t y l e < / a >   k0ˆ0c0f0	YÛcU0Œ0_0Ú0ü0¸0  < a   h r e f = " h t t p s : / / g i t h u b . c o m / H u n L i - X / c o d e g r a p h / c o m p a r e / m a i n . . . c o l b y m c h e n r y : c o d e g r a p h : m a i n . d i f f " > ( - & g t ; ª0ê0¸0Ê0ë0) < / a > 
 /   < l a b e l > ¢0É0ì0¹0:   < i n p u t   t y p e = " t e x t "   n a m e = " n a k e d _ p o s t _ u r l "   v a l u e = " h t t p s : / / g i t h u b . c o m / H u n L i - X / c o d e g r a p h / c o m p a r e / m a i n . . . c o l b y m c h e n r y : c o d e g r a p h : m a i n . d i f f "   s i z e = " 2 2 "   / > < / l a b e l >   < l a b e l > â0ü0É0:   < s e l e c t   n a m e = " n a k e d _ p o s t _ m o d e " > 
 < o p t i o n   v a l u e = " d e f a u l t " > Ç0Õ0©0ë0È0< / o p t i o n > 
 < o p t i o n   v a l u e = " s p e e c h " > ó—ðXÖ0é0¦0¶0< / o p t i o n > 
 < o p t i o n   v a l u e = " r u b y " > ë0Ó0ØNM0< / o p t i o n > 
 < o p t i o n   v a l u e = " c o n t r a s t "   s e l e c t e d = " s e l e c t e d " > M‘r‚ÍSâŽ< / o p t i o n > 
 < o p t i o n   v a l u e = " l a r g e r - t e x t " > ‡eW[áb'Y< / o p t i o n > 
 < o p t i o n   v a l u e = " m o b i l e " > â0Ð0¤0ë0< / o p t i o n > 
 < / s e l e c t > 
 < i n p u t   t y p e = " s u b m i t "   v a l u e = " hˆ:y"   / > 
 < / p > 
 < / f o r m > 
 < / d i v > 	 	 
 